Allow IOSurfaceDrawQuad to be a candidate for overlays

Add allow_overlay field to IOSurfaceDrawQuad, and use it to check whether an
IOSurface quad can be an overlay candidate.

BUG=510252
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1304533002

Cr-Commit-Position: refs/heads/master@{#344771}

10 files changed, 77 insertions, 23 deletions

diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 234d3f3..902a73d 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -85,7 +85,8 @@ void IOSurfaceLayerImpl::AppendQuads(
                visible_quad_rect,
                io_surface_size_,
                io_surface_resource_id_,
-               IOSurfaceDrawQuad::FLIPPED);
+               IOSurfaceDrawQuad::FLIPPED,
+               false);
   ValidateQuadResources(quad);
 }
 
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 77b2bfb..3313aa5 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -327,7 +327,8 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       io_surface_quad->SetNew(shared_quad_state, quad_rect, opaque_rect,
                               visible_quad_rect, visible_rect.size(),
                               frame_resources_[0].id,
-                              IOSurfaceDrawQuad::UNFLIPPED);
+                              IOSurfaceDrawQuad::UNFLIPPED,
+                              frame_resources_[0].allow_overlay);
       ValidateQuadResources(io_surface_quad);
       break;
     }
diff --git a/cc/output/overlay_strategy_common.cc b/cc/output/overlay_strategy_common.cc
index 33b4594..7da74ca 100644
--- a/cc/output/overlay_strategy_common.cc
+++ b/cc/output/overlay_strategy_common.cc
@@ -6,6 +6,7 @@
 
 #include <limits>
 
+#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"
@@ -50,6 +51,8 @@ bool OverlayStrategyCommon::IsOverlayQuad(const DrawQuad* draw_quad) {
       return TextureDrawQuad::MaterialCast(draw_quad)->allow_overlay();
     case DrawQuad::STREAM_VIDEO_CONTENT:
       return StreamVideoDrawQuad::MaterialCast(draw_quad)->allow_overlay();
+    case DrawQuad::IO_SURFACE_CONTENT:
+      return IOSurfaceDrawQuad::MaterialCast(draw_quad)->allow_overlay;
     default:
       return false;
   }
@@ -127,6 +130,20 @@ bool OverlayStrategyCommon::GetVideoQuadInfo(const StreamVideoDrawQuad& quad,
   return true;
 }
 
+bool OverlayStrategyCommon::GetIOSurfaceQuadInfo(const IOSurfaceDrawQuad& quad,
+                                                 OverlayCandidate* quad_info) {
+  gfx::OverlayTransform overlay_transform =
+      OverlayCandidate::GetOverlayTransform(
+          quad.shared_quad_state->quad_to_target_transform, false);
+  if (overlay_transform != gfx::OVERLAY_TRANSFORM_NONE)
+    return false;
+  quad_info->resource_id = quad.io_surface_resource_id();
+  quad_info->resource_size_in_pixels = quad.io_surface_size;
+  quad_info->transform = overlay_transform;
+  quad_info->uv_rect = gfx::Rect(0, 0, 1, 1);
+  return true;
+}
+
 bool OverlayStrategyCommon::GetCandidateQuadInfo(const DrawQuad& draw_quad,
                                                  OverlayCandidate* quad_info) {
   // All quad checks.
@@ -134,14 +151,23 @@ bool OverlayStrategyCommon::GetCandidateQuadInfo(const DrawQuad& draw_quad,
       draw_quad.shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode)
     return false;
 
-  if (draw_quad.material == DrawQuad::TEXTURE_CONTENT) {
-    const TextureDrawQuad& quad = *TextureDrawQuad::MaterialCast(&draw_quad);
-    if (!GetTextureQuadInfo(quad, quad_info))
-      return false;
-  } else if (draw_quad.material == DrawQuad::STREAM_VIDEO_CONTENT) {
-    const StreamVideoDrawQuad& quad =
-        *StreamVideoDrawQuad::MaterialCast(&draw_quad);
-    if (!GetVideoQuadInfo(quad, quad_info))
+  switch (draw_quad.material) {
+    case DrawQuad::TEXTURE_CONTENT: {
+      auto* quad = TextureDrawQuad::MaterialCast(&draw_quad);
+      if (!GetTextureQuadInfo(*quad, quad_info))
+        return false;
+    } break;
+    case DrawQuad::STREAM_VIDEO_CONTENT: {
+      auto* quad = StreamVideoDrawQuad::MaterialCast(&draw_quad);
+      if (!GetVideoQuadInfo(*quad, quad_info))
+        return false;
+    } break;
+    case DrawQuad::IO_SURFACE_CONTENT: {
+      auto* quad = IOSurfaceDrawQuad::MaterialCast(&draw_quad);
+      if (!GetIOSurfaceQuadInfo(*quad, quad_info))
+        return false;
+    } break;
+    default:
       return false;
   }
 
diff --git a/cc/output/overlay_strategy_common.h b/cc/output/overlay_strategy_common.h
index 2b81b90..0291be7 100644
--- a/cc/output/overlay_strategy_common.h
+++ b/cc/output/overlay_strategy_common.h
@@ -10,10 +10,11 @@
 #include "cc/output/overlay_processor.h"
 
 namespace cc {
+class IOSurfaceDrawQuad;
+class OverlayCandidate;
 class OverlayCandidateValidator;
 class StreamVideoDrawQuad;
 class TextureDrawQuad;
-class OverlayCandidate;
 
 class CC_EXPORT OverlayStrategyCommon : public OverlayProcessor::Strategy {
  public:
@@ -39,6 +40,8 @@ class CC_EXPORT OverlayStrategyCommon : public OverlayProcessor::Strategy {
                           OverlayCandidate* quad_info);
   bool GetVideoQuadInfo(const StreamVideoDrawQuad& quad,
                         OverlayCandidate* quad_info);
+  bool GetIOSurfaceQuadInfo(const IOSurfaceDrawQuad& quad,
+                            OverlayCandidate* quad_info);
 
   virtual bool TryOverlay(OverlayCandidateValidator* capability_checker,
                           RenderPassList* render_passes_in_draw_order,
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index 1b1e961..205243a 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -384,26 +384,34 @@ TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
   gfx::Size size(58, 95);
   ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
+  bool allow_overlay = true;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_5_NEW(IOSurfaceDrawQuad,
+  CREATE_QUAD_6_NEW(IOSurfaceDrawQuad,
                     opaque_rect,
                     visible_rect,
                     size,
                     resource_id,
-                    orientation);
+                    orientation,
+                    allow_overlay);
   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(opaque_rect, copy_quad->opaque_rect);
   EXPECT_EQ(size, copy_quad->io_surface_size);
   EXPECT_EQ(resource_id, copy_quad->io_surface_resource_id());
   EXPECT_EQ(orientation, copy_quad->orientation);
+  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay);
 
-  CREATE_QUAD_3_ALL(IOSurfaceDrawQuad, size, resource_id, orientation);
+  CREATE_QUAD_4_ALL(IOSurfaceDrawQuad,
+                    size,
+                    resource_id,
+                    orientation,
+                    allow_overlay);
   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
   EXPECT_EQ(size, copy_quad->io_surface_size);
   EXPECT_EQ(resource_id, copy_quad->io_surface_resource_id());
   EXPECT_EQ(orientation, copy_quad->orientation);
+  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay);
 }
 
 TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
@@ -738,17 +746,20 @@ TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
   gfx::Size size(58, 95);
   ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
+  bool allow_overlay = true;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_5_NEW(IOSurfaceDrawQuad,
+  CREATE_QUAD_6_NEW(IOSurfaceDrawQuad,
                     opaque_rect,
                     visible_rect,
                     size,
                     resource_id,
-                    orientation);
+                    orientation,
+                    allow_overlay);
   EXPECT_EQ(resource_id, quad_new->io_surface_resource_id());
   EXPECT_EQ(1, IterateAndCount(quad_new));
   EXPECT_EQ(resource_id + 1, quad_new->io_surface_resource_id());
+  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay);
 }
 
 TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
diff --git a/cc/quads/io_surface_draw_quad.cc b/cc/quads/io_surface_draw_quad.cc
index 0ad70fc..32e2ffc4 100644
--- a/cc/quads/io_surface_draw_quad.cc
+++ b/cc/quads/io_surface_draw_quad.cc
@@ -11,7 +11,8 @@
 
 namespace cc {
 
-IOSurfaceDrawQuad::IOSurfaceDrawQuad() : orientation(FLIPPED) {
+IOSurfaceDrawQuad::IOSurfaceDrawQuad()
+    : orientation(FLIPPED), allow_overlay(false) {
 }
 
 void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
@@ -20,7 +21,8 @@ void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                const gfx::Rect& visible_rect,
                                const gfx::Size& io_surface_size,
                                unsigned io_surface_resource_id,
-                               Orientation orientation) {
+                               Orientation orientation,
+                               bool allow_overlay) {
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
@@ -28,6 +30,7 @@ void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
   resources.ids[kIOSurfaceResourceIdIndex] = io_surface_resource_id;
   resources.count = 1;
   this->orientation = orientation;
+  this->allow_overlay = allow_overlay;
 }
 
 void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
@@ -37,13 +40,15 @@ void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                bool needs_blending,
                                const gfx::Size& io_surface_size,
                                unsigned io_surface_resource_id,
-                               Orientation orientation) {
+                               Orientation orientation,
+                               bool allow_overlay) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
   this->io_surface_size = io_surface_size;
   resources.ids[kIOSurfaceResourceIdIndex] = io_surface_resource_id;
   resources.count = 1;
   this->orientation = orientation;
+  this->allow_overlay = allow_overlay;
 }
 
 const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast(
diff --git a/cc/quads/io_surface_draw_quad.h b/cc/quads/io_surface_draw_quad.h
index 4a8a072..0374aa9 100644
--- a/cc/quads/io_surface_draw_quad.h
+++ b/cc/quads/io_surface_draw_quad.h
@@ -28,7 +28,8 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
               const gfx::Rect& visible_rect,
               const gfx::Size& io_surface_size,
               unsigned io_surface_resource_id,
-              Orientation orientation);
+              Orientation orientation,
+              bool allow_overlay);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
@@ -37,10 +38,12 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
               bool needs_blending,
               const gfx::Size& io_surface_size,
               unsigned io_surface_resource_id,
-              Orientation orientation);
+              Orientation orientation,
+              bool allow_overlay);
 
   gfx::Size io_surface_size;
   Orientation orientation;
+  bool allow_overlay;
 
   ResourceId io_surface_resource_id() const {
     return resources.ids[kIOSurfaceResourceIdIndex];
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index 5f023bf..c858ea5 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -219,7 +219,7 @@ void AddOneOfEveryQuadType(RenderPass* to_pass,
       to_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
   io_surface_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
                           gfx::Size(50, 50), resource7,
-                          IOSurfaceDrawQuad::FLIPPED);
+                          IOSurfaceDrawQuad::FLIPPED, false);
 
   if (child_pass.layer_id) {
     RenderPassDrawQuad* render_pass_quad =
diff --git a/content/common/cc_messages.h b/content/common/cc_messages.h
index 1692311..55a8c49 100644
--- a/content/common/cc_messages.h
+++ b/content/common/cc_messages.h
@@ -187,6 +187,7 @@ 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_MEMBER(allow_overlay)
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(cc::RenderPassDrawQuad)
diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc
index 5d4ccab..4cb3dc6 100644
--- a/content/common/cc_messages_unittest.cc
+++ b/content/common/cc_messages_unittest.cc
@@ -131,6 +131,7 @@ class CCMessagesTest : public testing::Test {
     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);
+    EXPECT_EQ(a->allow_overlay, b->allow_overlay);
   }
 
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
@@ -268,6 +269,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   SkXfermode::Mode arbitrary_blend_mode3 = SkXfermode::kOverlay_Mode;
   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
       IOSurfaceDrawQuad::UNFLIPPED;
+  bool arbitrary_allow_overlay = true;
   ResourceId arbitrary_resourceid1 = 55;
   ResourceId arbitrary_resourceid2 = 47;
   ResourceId arbitrary_resourceid3 = 23;
@@ -337,7 +339,8 @@ TEST_F(CCMessagesTest, AllQuads) {
                        arbitrary_bool1,
                        arbitrary_size1,
                        arbitrary_resourceid3,
-                       arbitrary_orientation);
+                       arbitrary_orientation,
+                       arbitrary_allow_overlay);
   pass_cmp->CopyFromAndAppendDrawQuad(iosurface_in,
                                       iosurface_in->shared_quad_state);