cc: Remove IOSurfaceDrawQuad

This isn't being used anymore. It existed to support rectangle
textures, but regular texture draw quads support that now.
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review-Url: https://codereview.chromium.org/1990773002
Cr-Commit-Position: refs/heads/master@{#394602}

cc/BUILD.gn

@@ -327,8 +327,6 @@ component("cc") {
     "quads/draw_polygon.h",
     "quads/draw_quad.cc",
     "quads/draw_quad.h",
-    "quads/io_surface_draw_quad.cc",
-    "quads/io_surface_draw_quad.h",
     "quads/largest_draw_quad.cc",
     "quads/largest_draw_quad.h",
     "quads/picture_draw_quad.cc",

cc/cc.gyp

@@ -388,8 +388,6 @@
         'quads/draw_polygon.h',
         'quads/draw_quad.cc',
         'quads/draw_quad.h',
-        'quads/io_surface_draw_quad.cc',
-        'quads/io_surface_draw_quad.h',
         'quads/largest_draw_quad.cc',
         'quads/largest_draw_quad.h',
         'quads/picture_draw_quad.cc',

cc/ipc/cc_param_traits.cc

@@ -13,7 +13,6 @@
 #include "cc/output/filter_operations.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
-#include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ -345,9 +344,6 @@ void ParamTraits<cc::RenderPass>::Write(base::Pickle* m, const param_type& p) {
       case cc::DrawQuad::DEBUG_BORDER:
         WriteParam(m, *cc::DebugBorderDrawQuad::MaterialCast(quad));
         break;
-      case cc::DrawQuad::IO_SURFACE_CONTENT:
-        WriteParam(m, *cc::IOSurfaceDrawQuad::MaterialCast(quad));
-        break;
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         break;
@@ -453,9 +449,6 @@ bool ParamTraits<cc::RenderPass>::Read(const base::Pickle* m,
       case cc::DrawQuad::DEBUG_BORDER:
         draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter, p);
         break;
-      case cc::DrawQuad::IO_SURFACE_CONTENT:
-        draw_quad = ReadDrawQuad<cc::IOSurfaceDrawQuad>(m, iter, p);
-        break;
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         return false;
@@ -543,9 +536,6 @@ void ParamTraits<cc::RenderPass>::Log(const param_type& p, std::string* l) {
       case cc::DrawQuad::DEBUG_BORDER:
         LogParam(*cc::DebugBorderDrawQuad::MaterialCast(quad), l);
         break;
-      case cc::DrawQuad::IO_SURFACE_CONTENT:
-        LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(quad), l);
-        break;
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         break;

cc/ipc/cc_param_traits_macros.h

@@ -11,7 +11,6 @@
 #include "cc/output/filter_operation.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
-#include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_id.h"
 #include "cc/quads/shared_quad_state.h"
@@ -34,8 +33,6 @@
 #define IPC_MESSAGE_EXPORT CC_IPC_EXPORT
 
 IPC_ENUM_TRAITS_MAX_VALUE(cc::DrawQuad::Material, cc::DrawQuad::MATERIAL_LAST)
-IPC_ENUM_TRAITS_MAX_VALUE(cc::IOSurfaceDrawQuad::Orientation,
-                          cc::IOSurfaceDrawQuad::ORIENTATION_LAST)
 IPC_ENUM_TRAITS_MAX_VALUE(cc::FilterOperation::FilterType,
                           cc::FilterOperation::FILTER_TYPE_LAST)
 IPC_ENUM_TRAITS_MAX_VALUE(cc::ResourceFormat, cc::RESOURCE_FORMAT_MAX)
@@ -75,12 +72,6 @@ IPC_STRUCT_TRAITS_BEGIN(cc::DebugBorderDrawQuad)
   IPC_STRUCT_TRAITS_MEMBER(width)
 IPC_STRUCT_TRAITS_END()
 
-IPC_STRUCT_TRAITS_BEGIN(cc::IOSurfaceDrawQuad)
-  IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad)
-  IPC_STRUCT_TRAITS_MEMBER(io_surface_size)
-  IPC_STRUCT_TRAITS_MEMBER(orientation)
-IPC_STRUCT_TRAITS_END()
-
 IPC_STRUCT_TRAITS_BEGIN(cc::RenderPassDrawQuad)
   IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad)
   IPC_STRUCT_TRAITS_MEMBER(render_pass_id)

cc/ipc/cc_param_traits_unittest.cc

@@ -26,7 +26,6 @@ using cc::DebugBorderDrawQuad;
 using cc::DrawQuad;
 using cc::FilterOperation;
 using cc::FilterOperations;
-using cc::IOSurfaceDrawQuad;
 using cc::PictureDrawQuad;
 using cc::RenderPass;
 using cc::RenderPassId;
@@ -82,10 +81,6 @@ class CCParamTraitsTest : public testing::Test {
         Compare(DebugBorderDrawQuad::MaterialCast(a),
                 DebugBorderDrawQuad::MaterialCast(b));
         break;
-      case DrawQuad::IO_SURFACE_CONTENT:
-        Compare(IOSurfaceDrawQuad::MaterialCast(a),
-                IOSurfaceDrawQuad::MaterialCast(b));
-        break;
       case DrawQuad::PICTURE_CONTENT:
         Compare(PictureDrawQuad::MaterialCast(a),
                 PictureDrawQuad::MaterialCast(b));
@@ -127,12 +122,6 @@ class CCParamTraitsTest : public testing::Test {
     EXPECT_EQ(a->width, b->width);
   }
 
-  void Compare(const IOSurfaceDrawQuad* a, const IOSurfaceDrawQuad* b) {
-    EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString());
-    EXPECT_EQ(a->io_surface_resource_id(), b->io_surface_resource_id());
-    EXPECT_EQ(a->orientation, b->orientation);
-  }
-
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
     EXPECT_EQ(a->render_pass_id, b->render_pass_id);
     EXPECT_EQ(a->mask_resource_id(), b->mask_resource_id());
@@ -264,8 +253,6 @@ TEST_F(CCParamTraitsTest, AllQuads) {
   SkXfermode::Mode arbitrary_blend_mode1 = SkXfermode::kScreen_Mode;
   SkXfermode::Mode arbitrary_blend_mode2 = SkXfermode::kLighten_Mode;
   SkXfermode::Mode arbitrary_blend_mode3 = SkXfermode::kOverlay_Mode;
-  IOSurfaceDrawQuad::Orientation arbitrary_orientation =
-      IOSurfaceDrawQuad::UNFLIPPED;
   ResourceId arbitrary_resourceid1 = 55;
   ResourceId arbitrary_resourceid2 = 47;
   ResourceId arbitrary_resourceid3 = 23;
@@ -321,15 +308,6 @@ TEST_F(CCParamTraitsTest, AllQuads) {
   pass_cmp->CopyFromAndAppendDrawQuad(debugborder_in,
                                       debugborder_in->shared_quad_state);
 
-  IOSurfaceDrawQuad* iosurface_in =
-      pass_in->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
-  iosurface_in->SetAll(
-      shared_state1_in, arbitrary_rect2, arbitrary_rect2_inside_rect2,
-      arbitrary_rect1_inside_rect2, arbitrary_bool1, arbitrary_size1,
-      arbitrary_resourceid3, arbitrary_orientation);
-  pass_cmp->CopyFromAndAppendDrawQuad(iosurface_in,
-                                      iosurface_in->shared_quad_state);
-
   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state2_in->SetAll(arbitrary_matrix2, arbitrary_size2, arbitrary_rect2,
                            arbitrary_rect3, arbitrary_bool1, arbitrary_float2,
@@ -418,7 +396,7 @@ TEST_F(CCParamTraitsTest, AllQuads) {
   ASSERT_EQ(0u, child_pass_in->quad_list.size());
   Compare(pass_cmp.get(), pass_in.get());
   ASSERT_EQ(3u, pass_in->shared_quad_state_list.size());
-  ASSERT_EQ(9u, pass_in->quad_list.size());
+  ASSERT_EQ(8u, pass_in->quad_list.size());
   for (cc::SharedQuadStateList::ConstIterator
            cmp_iterator = pass_cmp->shared_quad_state_list.begin(),
            in_iterator = pass_in->shared_quad_state_list.begin();
@@ -462,7 +440,7 @@ TEST_F(CCParamTraitsTest, AllQuads) {
       std::move(frame_out.render_pass_list[1]);
   Compare(pass_cmp.get(), pass_out.get());
   ASSERT_EQ(3u, pass_out->shared_quad_state_list.size());
-  ASSERT_EQ(9u, pass_out->quad_list.size());
+  ASSERT_EQ(8u, pass_out->quad_list.size());
   for (cc::SharedQuadStateList::ConstIterator
            cmp_iterator = pass_cmp->shared_quad_state_list.begin(),
            out_iterator = pass_out->shared_quad_state_list.begin();

cc/layers/video_layer_impl.cc

@@ -10,7 +10,6 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
-#include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"

cc/output/ca_layer_overlay.cc

@@ -5,7 +5,6 @@
 #include "cc/output/ca_layer_overlay.h"
 
 #include "base/metrics/histogram.h"
-#include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
@@ -39,17 +38,6 @@ enum CALayerResult {
   CA_LAYER_FAILED_COUNT,
 };
 
-CALayerResult FromIOSurfaceQuad(ResourceProvider* resource_provider,
-                                const IOSurfaceDrawQuad* quad,
-                                CALayerOverlay* ca_layer_overlay) {
-  unsigned resource_id = quad->io_surface_resource_id();
-  if (!resource_provider->IsOverlayCandidate(resource_id))
-    return CA_LAYER_FAILED_IO_SURFACE_NOT_CANDIDATE;
-  ca_layer_overlay->contents_resource_id = resource_id;
-  ca_layer_overlay->contents_rect = gfx::RectF(0, 0, 1, 1);
-  return CA_LAYER_SUCCESS;
-}
-
 CALayerResult FromStreamVideoQuad(ResourceProvider* resource_provider,
                                   const StreamVideoDrawQuad* quad,
                                   CALayerOverlay* ca_layer_overlay) {
@@ -155,10 +143,6 @@ CALayerResult FromDrawQuad(ResourceProvider* resource_provider,
       quad->shared_quad_state->quad_to_target_transform.matrix();
 
   switch (quad->material) {
-    case DrawQuad::IO_SURFACE_CONTENT:
-      return FromIOSurfaceQuad(resource_provider,
-                               IOSurfaceDrawQuad::MaterialCast(quad),
-                               ca_layer_overlay);
     case DrawQuad::TEXTURE_CONTENT:
       return FromTextureQuad(resource_provider,
                              TextureDrawQuad::MaterialCast(quad),

cc/output/delegating_renderer_unittest.cc

@@ -116,12 +116,12 @@ class DelegatingRendererTestResources : public DelegatingRendererTest {
     ASSERT_TRUE(last_frame.delegated_frame_data);
 
     EXPECT_EQ(2u, last_frame.delegated_frame_data->render_pass_list.size());
-    // Each render pass has 11 resources in it. And the root render pass has a
+    // Each render pass has 10 resources in it. And the root render pass has a
     // mask resource used when drawing the child render pass, as well as its
-    // replica (it's added twice). The number 11 may change if
+    // replica (it's added twice). The number 10 may change if
     // AppendOneOfEveryQuadType() is updated, and the value here should be
     // updated accordingly.
-    EXPECT_EQ(24u, last_frame.delegated_frame_data->resource_list.size());
+    EXPECT_EQ(22u, last_frame.delegated_frame_data->resource_list.size());
 
     EndTest();
   }

cc/output/gl_renderer.cc

@@ -526,10 +526,6 @@ void GLRenderer::DoDrawQuad(DrawingFrame* frame,
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
       break;
-    case DrawQuad::IO_SURFACE_CONTENT:
-      DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad),
-                        clip_region);
-      break;
     case DrawQuad::PICTURE_CONTENT:
       // PictureDrawQuad should only be used for resourceless software draws.
       NOTREACHED();
@@ -2480,55 +2476,6 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
   }
 }
 
-void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
-                                   const IOSurfaceDrawQuad* quad,
-                                   const gfx::QuadF* clip_region) {
-  SetBlendEnabled(quad->ShouldDrawWithBlending());
-
-  TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      gl_, &highp_threshold_cache_, highp_threshold_min_,
-      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
-
-  TexTransformTextureProgramBinding binding;
-  binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision));
-
-  SetUseProgram(binding.program_id);
-  gl_->Uniform1i(binding.sampler_location, 0);
-  if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) {
-    gl_->Uniform4f(
-        binding.tex_transform_location, 0, quad->io_surface_size.height(),
-        quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0f);
-  } else {
-    gl_->Uniform4f(binding.tex_transform_location, 0, 0,
-                   quad->io_surface_size.width(),
-                   quad->io_surface_size.height());
-  }
-
-  const float vertex_opacity[] = {quad->shared_quad_state->opacity,
-                                  quad->shared_quad_state->opacity,
-                                  quad->shared_quad_state->opacity,
-                                  quad->shared_quad_state->opacity};
-  gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity);
-
-  ResourceProvider::ScopedReadLockGL lock(resource_provider_,
-                                          quad->io_surface_resource_id());
-  DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
-  gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
-
-  if (!clip_region) {
-    DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
-                     gfx::RectF(quad->rect), binding.matrix_location);
-  } else {
-    float uvs[8] = {0};
-    GetScaledUVs(quad->visible_rect, clip_region, uvs);
-    DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->quad_to_target_transform,
-        gfx::RectF(quad->rect), *clip_region, binding.matrix_location, uvs);
-  }
-
-  gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
-}
-
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
@@ -3412,19 +3359,6 @@ GLRenderer::GetNonPremultipliedTextureBackgroundProgram(
   return program;
 }
 
-const GLRenderer::TextureProgram* GLRenderer::GetTextureIOSurfaceProgram(
-    TexCoordPrecision precision) {
-  DCHECK_GE(precision, 0);
-  DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
-  TextureProgram* program = &texture_io_surface_program_[precision];
-  if (!program->initialized()) {
-    TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");
-    program->Initialize(output_surface_->context_provider(), precision,
-                        SAMPLER_TYPE_2D_RECT);
-  }
-  return program;
-}
-
 const GLRenderer::VideoYUVProgram* GLRenderer::GetVideoYUVProgram(
     TexCoordPrecision precision,
     SamplerType sampler) {
@@ -3525,7 +3459,6 @@ void GLRenderer::CleanupSharedObjects() {
       texture_background_program_[i][j].Cleanup(gl_);
       nonpremultiplied_texture_background_program_[i][j].Cleanup(gl_);
     }
-    texture_io_surface_program_[i].Cleanup(gl_);
 
     video_stream_texture_program_[i].Cleanup(gl_);
   }

cc/output/gl_renderer.h

@@ -16,7 +16,6 @@
 #include "cc/output/program_binding.h"
 #include "cc/output/renderer.h"
 #include "cc/quads/debug_border_draw_quad.h"
-#include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
@@ -194,9 +193,6 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
                           const TextureDrawQuad* quad,
                           const gfx::QuadF* clip_region);
   void FlushTextureQuadCache(BoundGeometry flush_binding);
-  void DrawIOSurfaceQuad(const DrawingFrame* frame,
-                         const IOSurfaceDrawQuad* quad,
-                         const gfx::QuadF* clip_region);
   void DrawTileQuad(const DrawingFrame* frame,
                     const TileDrawQuad* quad,
                     const gfx::QuadF* clip_region);
@@ -400,8 +396,6 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   const NonPremultipliedTextureBackgroundProgram*
   GetNonPremultipliedTextureBackgroundProgram(TexCoordPrecision precision,
                                               SamplerType sampler);
-  const TextureProgram* GetTextureIOSurfaceProgram(
-      TexCoordPrecision precision);
 
   const VideoYUVProgram* GetVideoYUVProgram(TexCoordPrecision precision,
                                             SamplerType sampler);
@@ -441,7 +435,6 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   NonPremultipliedTextureBackgroundProgram
       nonpremultiplied_texture_background_program_[LAST_TEX_COORD_PRECISION +
                                                    1][LAST_SAMPLER_TYPE + 1];
-  TextureProgram texture_io_surface_program_[LAST_TEX_COORD_PRECISION + 1];
 
   RenderPassProgram
       render_pass_program_[LAST_TEX_COORD_PRECISION + 1][LAST_BLEND_MODE + 1];

cc/output/gl_renderer_unittest.cc

@@ -133,7 +133,6 @@ class GLRendererShaderPixelTest : public GLRendererPixelTest {
   }
 
   void TestShadersWithPrecision(TexCoordPrecision precision) {
-    EXPECT_PROGRAM_VALID(renderer()->GetTextureIOSurfaceProgram(precision));
     // This program uses external textures and sampler, so it won't compile
     // everywhere.
     if (renderer()->Capabilities().using_egl_image)
@@ -947,7 +946,7 @@ TEST_F(GLRendererTest, ActiveTextureState) {
 
     // The remaining quads also use GL_LINEAR because nearest neighbor
     // filtering is currently only used with tile quads.
-    EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(6);
+    EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(5);
   }
 
   gfx::Rect viewport_rect(100, 100);