Add cc:DrawQuad type for surfaces

This quad type just carries a surface ID to be resolved later. A quad of this type will always be replaced by the quads it represents (if any) before being passed to a cc:DirectRenderer for drawing.

BUG=334090

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@245438 0039d316-1c4b-4281-b951-d872f2087c98

cc/cc.gyp

@@ -293,6 +293,8 @@
         'quads/solid_color_draw_quad.h',
         'quads/stream_video_draw_quad.cc',
         'quads/stream_video_draw_quad.h',
+        'quads/surface_draw_quad.cc',
+        'quads/surface_draw_quad.h',
         'quads/texture_draw_quad.cc',
         'quads/texture_draw_quad.h',
         'quads/tile_draw_quad.cc',

cc/output/gl_renderer.cc

@@ -346,6 +346,11 @@ void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
     case DrawQuad::STREAM_VIDEO_CONTENT:
       DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::SURFACE_CONTENT:
+      // Surface content should be fully resolved to other quad types before
+      // reaching a direct renderer.
+      NOTREACHED();
+      break;
     case DrawQuad::TEXTURE_CONTENT:
       EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
       break;

cc/output/software_renderer.cc

@@ -281,6 +281,11 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
     case DrawQuad::TILED_CONTENT:
       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::SURFACE_CONTENT:
+      // Surface content should be fully resolved to other quad types before
+      // reaching a direct renderer.
+      NOTREACHED();
+      break;
     case DrawQuad::INVALID:
     case DrawQuad::IO_SURFACE_CONTENT:
     case DrawQuad::YUV_VIDEO_CONTENT:

cc/quads/draw_quad.cc

@@ -15,6 +15,7 @@
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
@@ -89,6 +90,9 @@ scoped_ptr<DrawQuad> DrawQuad::Copy(
     case STREAM_VIDEO_CONTENT:
       copy_quad.reset(TypedCopy<StreamVideoDrawQuad>(this));
       break;
+    case SURFACE_CONTENT:
+      copy_quad.reset(TypedCopy<SurfaceDrawQuad>(this));
+      break;
     case YUV_VIDEO_CONTENT:
       copy_quad.reset(TypedCopy<YUVVideoDrawQuad>(this));
       break;

cc/quads/draw_quad.h

@@ -37,11 +37,12 @@ class CC_EXPORT DrawQuad {
     IO_SURFACE_CONTENT,
     PICTURE_CONTENT,
     RENDER_PASS,
-    TEXTURE_CONTENT,
     SOLID_COLOR,
+    STREAM_VIDEO_CONTENT,
+    SURFACE_CONTENT,
+    TEXTURE_CONTENT,
     TILED_CONTENT,
     YUV_VIDEO_CONTENT,
-    STREAM_VIDEO_CONTENT,
   };
 
   virtual ~DrawQuad();

cc/quads/draw_quad_unittest.cc

@@ -17,6 +17,7 @@
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
@@ -466,6 +467,20 @@ TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
   EXPECT_EQ(matrix, copy_quad->matrix);
 }
 
+TEST(DrawQuadTest, CopySurfaceDrawQuad) {
+  int surface_id = 1234;
+  CREATE_SHARED_STATE();
+
+  CREATE_QUAD_1_NEW(SurfaceDrawQuad, surface_id);
+  EXPECT_EQ(DrawQuad::SURFACE_CONTENT, copy_quad->material);
+  EXPECT_EQ(surface_id, copy_quad->surface_id);
+
+  CREATE_QUAD_1_ALL(SurfaceDrawQuad, surface_id);
+  EXPECT_EQ(DrawQuad::SURFACE_CONTENT, copy_quad->material);
+  EXPECT_EQ(surface_id, copy_quad->surface_id);
+}
+
+
 TEST(DrawQuadTest, CopyTextureDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
   unsigned resource_id = 82;
@@ -728,6 +743,14 @@ TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
   EXPECT_EQ(resource_id + 1, quad_new->resource_id);
 }
 
+TEST_F(DrawQuadIteratorTest, SurfaceDrawQuad) {
+  int surface_id = 4321;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_1_NEW(SurfaceDrawQuad, surface_id);
+  EXPECT_EQ(0, IterateAndCount(quad_new.get()));
+}
+
 TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
   unsigned resource_id = 82;

cc/quads/surface_draw_quad.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/quads/surface_draw_quad.h"
+
+#include "base/logging.h"
+#include "base/values.h"
+
+namespace cc {
+
+SurfaceDrawQuad::SurfaceDrawQuad() : surface_id(0) {}
+
+scoped_ptr<SurfaceDrawQuad> SurfaceDrawQuad::Create() {
+  return make_scoped_ptr(new SurfaceDrawQuad);
+}
+
+void SurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                             gfx::Rect rect,
+                             int surface_id) {
+  gfx::Rect opaque_rect;
+  gfx::Rect visible_rect = rect;
+  bool needs_blending = false;
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::SURFACE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->surface_id = surface_id;
+}
+
+
+void SurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                             gfx::Rect rect,
+                             gfx::Rect opaque_rect,
+                             gfx::Rect visible_rect,
+                             bool needs_blending,
+                             int surface_id) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::SURFACE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->surface_id = surface_id;
+}
+
+void SurfaceDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {}
+
+const SurfaceDrawQuad* SurfaceDrawQuad::MaterialCast(const DrawQuad* quad) {
+  DCHECK_EQ(quad->material, DrawQuad::SURFACE_CONTENT);
+  return static_cast<const SurfaceDrawQuad*>(quad);
+}
+
+void SurfaceDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+  value->SetInteger("surface_id", surface_id);
+}
+
+
+}  // namespace cc

cc/quads/surface_draw_quad.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_QUADS_SURFACE_DRAW_QUAD_H_
+#define CC_QUADS_SURFACE_DRAW_QUAD_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/quads/draw_quad.h"
+
+namespace cc {
+
+class CC_EXPORT SurfaceDrawQuad : public DrawQuad {
+ public:
+  static scoped_ptr<SurfaceDrawQuad> Create();
+
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              int surface_id);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              int surface_id);
+
+  int surface_id;
+
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
+      OVERRIDE;
+
+  static const SurfaceDrawQuad* MaterialCast(const DrawQuad* quad);
+
+ private:
+  SurfaceDrawQuad();
+  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+};
+
+}  // namespace cc
+
+#endif  // CC_QUADS_SURFACE_DRAW_QUAD_H_

content/common/cc_messages.cc

@@ -327,6 +327,9 @@ void ParamTraits<cc::RenderPass>::Write(
       case cc::DrawQuad::SOLID_COLOR:
         WriteParam(m, *cc::SolidColorDrawQuad::MaterialCast(quad));
         break;
+      case cc::DrawQuad::SURFACE_CONTENT:
+        WriteParam(m, *cc::SurfaceDrawQuad::MaterialCast(quad));
+        break;
       case cc::DrawQuad::TILED_CONTENT:
         WriteParam(m, *cc::TileDrawQuad::MaterialCast(quad));
         break;
@@ -441,6 +444,9 @@ bool ParamTraits<cc::RenderPass>::Read(
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         return false;
+      case cc::DrawQuad::SURFACE_CONTENT:
+        draw_quad = ReadDrawQuad<cc::SurfaceDrawQuad>(m, iter);
+        break;
       case cc::DrawQuad::TEXTURE_CONTENT:
         draw_quad = ReadDrawQuad<cc::TextureDrawQuad>(m, iter);
         break;
@@ -551,6 +557,9 @@ void ParamTraits<cc::RenderPass>::Log(
       case cc::DrawQuad::SOLID_COLOR:
         LogParam(*cc::SolidColorDrawQuad::MaterialCast(quad), l);
         break;
+      case cc::DrawQuad::SURFACE_CONTENT:
+        LogParam(*cc::SurfaceDrawQuad::MaterialCast(quad), l);
+        break;
       case cc::DrawQuad::TILED_CONTENT:
         LogParam(*cc::TileDrawQuad::MaterialCast(quad), l);
         break;

content/common/cc_messages.h

@@ -18,6 +18,7 @@
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
@@ -175,6 +176,11 @@ IPC_STRUCT_TRAITS_BEGIN(cc::StreamVideoDrawQuad)
   IPC_STRUCT_TRAITS_MEMBER(matrix)
 IPC_STRUCT_TRAITS_END()
 
+IPC_STRUCT_TRAITS_BEGIN(cc::SurfaceDrawQuad)
+  IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad)
+  IPC_STRUCT_TRAITS_MEMBER(surface_id)
+IPC_STRUCT_TRAITS_END()
+
 IPC_STRUCT_TRAITS_BEGIN(cc::TextureDrawQuad)
   IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad)
   IPC_STRUCT_TRAITS_MEMBER(resource_id)

content/common/cc_messages_unittest.cc

@@ -27,6 +27,7 @@ using cc::RenderPassDrawQuad;
 using cc::ResourceProvider;
 using cc::SharedQuadState;
 using cc::SolidColorDrawQuad;
+using cc::SurfaceDrawQuad;
 using cc::TextureDrawQuad;
 using cc::TileDrawQuad;
 using cc::TransferableResource;
@@ -105,6 +106,10 @@ class CCMessagesTest : public testing::Test {
         Compare(StreamVideoDrawQuad::MaterialCast(a),
                 StreamVideoDrawQuad::MaterialCast(b));
         break;
+      case DrawQuad::SURFACE_CONTENT:
+        Compare(SurfaceDrawQuad::MaterialCast(a),
+                SurfaceDrawQuad::MaterialCast(b));
+        break;
       case DrawQuad::YUV_VIDEO_CONTENT:
         Compare(YUVVideoDrawQuad::MaterialCast(a),
                 YUVVideoDrawQuad::MaterialCast(b));
@@ -159,6 +164,10 @@ class CCMessagesTest : public testing::Test {
     EXPECT_EQ(a->matrix, b->matrix);
   }
 
+  void Compare(const SurfaceDrawQuad* a, const SurfaceDrawQuad* b) {
+    EXPECT_EQ(a->surface_id, b->surface_id);
+  }
+
   void Compare(const TextureDrawQuad* a, const TextureDrawQuad* b) {
     EXPECT_EQ(a->resource_id, b->resource_id);
     EXPECT_EQ(a->premultiplied_alpha, b->premultiplied_alpha);
@@ -362,6 +371,17 @@ TEST_F(CCMessagesTest, AllQuads) {
   scoped_ptr<DrawQuad> streamvideo_cmp = streamvideo_in->Copy(
       streamvideo_in->shared_quad_state);
 
+  int arbitrary_surface_id = 3;
+  scoped_ptr<SurfaceDrawQuad> surface_in = SurfaceDrawQuad::Create();
+  surface_in->SetAll(shared_state3_in.get(),
+                         arbitrary_rect2,
+                         arbitrary_rect2_inside_rect2,
+                         arbitrary_rect1_inside_rect2,
+                         arbitrary_bool1,
+                         arbitrary_surface_id);
+  scoped_ptr<DrawQuad> surface_cmp = surface_in->Copy(
+      surface_in->shared_quad_state);
+
   scoped_ptr<TextureDrawQuad> texture_in = TextureDrawQuad::Create();
   texture_in->SetAll(shared_state3_in.get(),
                      arbitrary_rect2,
@@ -422,6 +442,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   pass_in->shared_quad_state_list.push_back(shared_state3_in.Pass());
   pass_in->quad_list.push_back(solidcolor_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(streamvideo_in.PassAs<DrawQuad>());
+  pass_in->quad_list.push_back(surface_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(texture_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(tile_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(yuvvideo_in.PassAs<DrawQuad>());
@@ -442,6 +463,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   pass_cmp->shared_quad_state_list.push_back(shared_state3_cmp.Pass());
   pass_cmp->quad_list.push_back(solidcolor_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(streamvideo_cmp.PassAs<DrawQuad>());
+  pass_cmp->quad_list.push_back(surface_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(texture_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(tile_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(yuvvideo_cmp.PassAs<DrawQuad>());
@@ -449,7 +471,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   // Make sure the in and cmp RenderPasses match.
   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(10u, pass_in->quad_list.size());
   for (size_t i = 0; i < 3; ++i) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_in->shared_quad_state_list[i]);
@@ -481,7 +503,7 @@ TEST_F(CCMessagesTest, AllQuads) {
       frame_out.render_pass_list.begin());
   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(10u, pass_out->quad_list.size());
   for (size_t i = 0; i < 3; ++i) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_out->shared_quad_state_list[i]);
@@ -697,6 +719,9 @@ TEST_F(CCMessagesTest, LargestQuadType) {
       case cc::DrawQuad::SOLID_COLOR:
         largest = std::max(largest, sizeof(cc::SolidColorDrawQuad));
         break;
+      case cc::DrawQuad::SURFACE_CONTENT:
+        largest = std::max(largest, sizeof(cc::SurfaceDrawQuad));
+        break;
       case cc::DrawQuad::TILED_CONTENT:
         largest = std::max(largest, sizeof(cc::TileDrawQuad));
         break;