Add cc:DrawQuad type for surfaces

content/common/cc_messages_unittest.cc

 // Copyright (c) 2012 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 "content/common/cc_messages.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "cc/output/compositor_frame.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 
 using cc::CheckerboardDrawQuad;
 using cc::DelegatedFrameData;
 using cc::DebugBorderDrawQuad;
 using cc::DrawQuad;
 using cc::FilterOperation;
 using cc::FilterOperations;
 using cc::IOSurfaceDrawQuad;
 using cc::PictureDrawQuad;
 using cc::RenderPass;
 using cc::RenderPassDrawQuad;
 using cc::ResourceProvider;
 using cc::SharedQuadState;
 using cc::SolidColorDrawQuad;
+using cc::SurfaceDrawQuad;
 using cc::TextureDrawQuad;
 using cc::TileDrawQuad;
 using cc::TransferableResource;
 using cc::StreamVideoDrawQuad;
 using cc::VideoLayerImpl;
 using cc::YUVVideoDrawQuad;
 using gfx::Transform;
 
 namespace content {
 namespace {
@@ skipping 58 matching lines @@
                 TileDrawQuad::MaterialCast(b));
         break;
       case DrawQuad::SOLID_COLOR:
         Compare(SolidColorDrawQuad::MaterialCast(a),
                 SolidColorDrawQuad::MaterialCast(b));
         break;
       case DrawQuad::STREAM_VIDEO_CONTENT:
         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));
         break;
       case DrawQuad::INVALID:
         break;
     }
   }
 
   void Compare(const CheckerboardDrawQuad* a, const CheckerboardDrawQuad* b) {
@@ skipping 34 matching lines @@
   void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
     EXPECT_EQ(a->force_anti_aliasing_off, b->force_anti_aliasing_off);
   }
 
   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
     EXPECT_EQ(a->resource_id, b->resource_id);
     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);
     EXPECT_EQ(a->uv_top_left, b->uv_top_left);
     EXPECT_EQ(a->uv_bottom_right, b->uv_bottom_right);
     EXPECT_EQ(a->background_color, b->background_color);
     EXPECT_EQ(a->vertex_opacity[0], b->vertex_opacity[0]);
     EXPECT_EQ(a->vertex_opacity[1], b->vertex_opacity[1]);
     EXPECT_EQ(a->vertex_opacity[2], b->vertex_opacity[2]);
     EXPECT_EQ(a->vertex_opacity[3], b->vertex_opacity[3]);
@@ skipping 183 matching lines @@
   streamvideo_in->SetAll(shared_state3_in.get(),
                          arbitrary_rect2,
                          arbitrary_rect2_inside_rect2,
                          arbitrary_rect1_inside_rect2,
                          arbitrary_bool1,
                          arbitrary_resourceid2,
                          arbitrary_matrix);
   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,
                      arbitrary_rect2_inside_rect2,
                      arbitrary_rect1_inside_rect2,
                      arbitrary_bool1,
                      arbitrary_resourceid1,
                      arbitrary_bool2,
                      arbitrary_pointf1,
                      arbitrary_pointf2,
@@ skipping 40 matching lines @@
 
   pass_in->shared_quad_state_list.push_back(shared_state1_in.Pass());
   pass_in->quad_list.push_back(checkerboard_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(debugborder_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(iosurface_in.PassAs<DrawQuad>());
   pass_in->quad_list.push_back(renderpass_in.PassAs<DrawQuad>());
   pass_in->shared_quad_state_list.push_back(shared_state2_in.Pass());
   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>());
 
   scoped_ptr<RenderPass> pass_cmp = RenderPass::Create();
   pass_cmp->SetAll(arbitrary_id,
                    arbitrary_rect1,
                    arbitrary_rectf1,
                    arbitrary_matrix,
                    arbitrary_bool1);
 
   pass_cmp->shared_quad_state_list.push_back(shared_state1_cmp.Pass());
   pass_cmp->quad_list.push_back(checkerboard_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(debugborder_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(iosurface_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.push_back(renderpass_cmp.PassAs<DrawQuad>());
   pass_cmp->shared_quad_state_list.push_back(shared_state2_cmp.Pass());
   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>());
 
   // 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]);
   }
   for (size_t i = 0; i < pass_in->quad_list.size(); ++i)
     Compare(pass_cmp->quad_list[i], pass_in->quad_list[i]);
   for (size_t i = 1; i < pass_in->quad_list.size(); ++i) {
     bool same_shared_quad_state_cmp =
         pass_cmp->quad_list[i]->shared_quad_state ==
         pass_cmp->quad_list[i - 1]->shared_quad_state;
@@ skipping 11 matching lines @@
   DelegatedFrameData frame_out;
   PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
       &iter, &frame_out));
 
   // Make sure the out and cmp RenderPasses match.
   scoped_ptr<RenderPass> pass_out = frame_out.render_pass_list.take(
       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]);
   }
   for (size_t i = 0; i < pass_out->quad_list.size(); ++i)
     Compare(pass_cmp->quad_list[i], pass_out->quad_list[i]);
   for (size_t i = 1; i < pass_out->quad_list.size(); ++i) {
     bool same_shared_quad_state_cmp =
         pass_cmp->quad_list[i]->shared_quad_state ==
         pass_cmp->quad_list[i - 1]->shared_quad_state;
@@ skipping 195 matching lines @@
         break;
       case cc::DrawQuad::TEXTURE_CONTENT:
         largest = std::max(largest, sizeof(cc::TextureDrawQuad));
         break;
       case cc::DrawQuad::RENDER_PASS:
         largest = std::max(largest, sizeof(cc::RenderPassDrawQuad));
         break;
       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;
       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
         largest = std::max(largest, sizeof(cc::StreamVideoDrawQuad));
         break;
       case cc::DrawQuad::YUV_VIDEO_CONTENT:
         largest = std::max(largest, sizeof(cc::YUVVideoDrawQuad));
         break;
       case cc::DrawQuad::INVALID:
         break;
       default:
         done = true;
     }
   }
 
   // Verify the largest DrawQuad type is RenderPassDrawQuad. If this ever
   // changes, then the ReserveSizeForRenderPassWrite() method needs to be
   // updated as well to use the new largest quad.
   EXPECT_EQ(sizeof(RenderPassDrawQuad), largest);
 }
 
 }  // namespace
 }  // namespace content