cc: Move video upload to VideoResourceUpdater.

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 "cc/output/compositor_frame.h"
 #include "ipc/ipc_message.h"
@@ skipping 104 matching lines @@
     EXPECT_EQ(a->color, b->color);
   }
 
   void Compare(const DebugBorderDrawQuad* a, const DebugBorderDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
     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_texture_id, b->io_surface_texture_id);
+    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->is_replica, b->is_replica);
     EXPECT_EQ(a->mask_resource_id, b->mask_resource_id);
     EXPECT_EQ(a->contents_changed_since_last_frame,
               b->contents_changed_since_last_frame);
     EXPECT_EQ(a->mask_uv_rect.ToString(), b->mask_uv_rect.ToString());
     EXPECT_EQ(a->filters, b->filters);
     EXPECT_EQ(a->filter, b->filter);
     EXPECT_EQ(a->background_filters, b->background_filters);
   }
 
   void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
   }
 
   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
-    EXPECT_EQ(a->texture_id, b->texture_id);
+    EXPECT_EQ(a->resource_id, b->resource_id);
     EXPECT_EQ(a->matrix, b->matrix);
   }
 
   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->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]);
     EXPECT_EQ(a->flipped, b->flipped);
   }
 
   void Compare(const TileDrawQuad* a, const TileDrawQuad* b) {
     EXPECT_EQ(a->resource_id, b->resource_id);
     EXPECT_EQ(a->tex_coord_rect, b->tex_coord_rect);
     EXPECT_EQ(a->texture_size, b->texture_size);
     EXPECT_EQ(a->swizzle_contents, b->swizzle_contents);
   }
 
   void Compare(const YUVVideoDrawQuad* a, const YUVVideoDrawQuad* b) {
     EXPECT_EQ(a->tex_scale, b->tex_scale);
-    EXPECT_EQ(a->y_plane.resource_id, b->y_plane.resource_id);
-    EXPECT_EQ(a->y_plane.size.ToString(), b->y_plane.size.ToString());
-    EXPECT_EQ(a->y_plane.format, b->y_plane.format);
-    EXPECT_EQ(a->u_plane.resource_id, b->u_plane.resource_id);
-    EXPECT_EQ(a->u_plane.size.ToString(), b->u_plane.size.ToString());
-    EXPECT_EQ(a->u_plane.format, b->u_plane.format);
-    EXPECT_EQ(a->v_plane.resource_id, b->v_plane.resource_id);
-    EXPECT_EQ(a->v_plane.size.ToString(), b->v_plane.size.ToString());
-    EXPECT_EQ(a->v_plane.format, b->v_plane.format);
+    EXPECT_EQ(a->y_plane_resource_id, b->y_plane_resource_id);
+    EXPECT_EQ(a->u_plane_resource_id, b->u_plane_resource_id);
+    EXPECT_EQ(a->v_plane_resource_id, b->v_plane_resource_id);
   }
 
   void Compare(const TransferableResource& a, const TransferableResource& b) {
     EXPECT_EQ(a.id, b.id);
     EXPECT_EQ(a.sync_point, b.sync_point);
     EXPECT_EQ(a.format, b.format);
     EXPECT_EQ(a.filter, b.filter);
     EXPECT_EQ(a.size.ToString(), b.size.ToString());
     for (size_t i = 0; i < arraysize(a.mailbox.name); ++i)
       EXPECT_EQ(a.mailbox.name[i], b.mailbox.name[i]);
@@ skipping 22 matching lines @@
   float arbitrary_float3 = 0.9f;
   float arbitrary_float_array[4] = {3.5f, 6.2f, 9.3f, 12.3f};
   bool arbitrary_bool1 = true;
   bool arbitrary_bool2 = false;
   bool arbitrary_bool3 = true;
   int arbitrary_int = 5;
   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
       IOSurfaceDrawQuad::UNFLIPPED;
   RenderPass::Id arbitrary_id(10, 14);
-  ResourceProvider::ResourceId arbitrary_resourceid = 55;
-
-  VideoLayerImpl::FramePlane arbitrary_plane1;
-  arbitrary_plane1.resource_id = arbitrary_resourceid;
-  arbitrary_plane1.size = arbitrary_size1;
-  arbitrary_plane1.format = arbitrary_int;
-
-  VideoLayerImpl::FramePlane arbitrary_plane2;
-  arbitrary_plane2.resource_id = arbitrary_resourceid;
-  arbitrary_plane2.size = arbitrary_size2;
-  arbitrary_plane2.format = arbitrary_int;
-
-  VideoLayerImpl::FramePlane arbitrary_plane3;
-  arbitrary_plane3.resource_id = arbitrary_resourceid;
-  arbitrary_plane3.size = arbitrary_size3;
-  arbitrary_plane3.format = arbitrary_int;
+  ResourceProvider::ResourceId arbitrary_resourceid1 = 55;
+  ResourceProvider::ResourceId arbitrary_resourceid2 = 47;
+  ResourceProvider::ResourceId arbitrary_resourceid3 = 23;
 
   WebFilterOperations arbitrary_filters1;
   arbitrary_filters1.append(WebFilterOperation::createGrayscaleFilter(
       arbitrary_float1));
 
   WebFilterOperations arbitrary_filters2;
   arbitrary_filters2.append(WebFilterOperation::createBrightnessFilter(
       arbitrary_float2));
 
   // TODO(danakj): filter is not serialized.
@@ skipping 32 matching lines @@
       debugborder_in->shared_quad_state);
 
   scoped_ptr<IOSurfaceDrawQuad> iosurface_in =
       IOSurfaceDrawQuad::Create();
   iosurface_in->SetAll(shared_state1_in.get(),
                        arbitrary_rect2,
                        arbitrary_rect3,
                        arbitrary_rect1,
                        arbitrary_bool1,
                        arbitrary_size1,
-                       arbitrary_int,
+                       arbitrary_resourceid3,
                        arbitrary_orientation);
   scoped_ptr<DrawQuad> iosurface_cmp = iosurface_in->Copy(
       iosurface_in->shared_quad_state);
 
   scoped_ptr<RenderPassDrawQuad> renderpass_in =
       RenderPassDrawQuad::Create();
   renderpass_in->SetAll(shared_state1_in.get(),
                         arbitrary_rect1,
                         arbitrary_rect2,
                         arbitrary_rect3,
                         arbitrary_bool1,
                         arbitrary_id,
                         arbitrary_bool2,
-                        arbitrary_resourceid,
+                        arbitrary_resourceid2,
                         arbitrary_rect1,
                         arbitrary_rectf1,
                         arbitrary_filters1,
                         arbitrary_filter, // TODO(piman): not serialized.
                         arbitrary_filters2);
   scoped_ptr<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy(
       renderpass_in->shared_quad_state, renderpass_in->render_pass_id);
 
   scoped_ptr<SharedQuadState> shared_state2_in = SharedQuadState::Create();
   shared_state2_in->SetAll(arbitrary_matrix,
@@ skipping 24 matching lines @@
   scoped_ptr<DrawQuad> solidcolor_cmp = solidcolor_in->Copy(
       solidcolor_in->shared_quad_state);
 
   scoped_ptr<StreamVideoDrawQuad> streamvideo_in =
       StreamVideoDrawQuad::Create();
   streamvideo_in->SetAll(shared_state1_in.get(),
                          arbitrary_rect2,
                          arbitrary_rect3,
                          arbitrary_rect1,
                          arbitrary_bool1,
-                         arbitrary_int,
+                         arbitrary_resourceid2,
                          arbitrary_matrix);
   scoped_ptr<DrawQuad> streamvideo_cmp = streamvideo_in->Copy(
       streamvideo_in->shared_quad_state);
 
   scoped_ptr<TextureDrawQuad> texture_in = TextureDrawQuad::Create();
   texture_in->SetAll(shared_state1_in.get(),
                      arbitrary_rect2,
                      arbitrary_rect3,
                      arbitrary_rect1,
                      arbitrary_bool1,
-                     arbitrary_resourceid,
+                     arbitrary_resourceid1,
                      arbitrary_bool2,
                      arbitrary_pointf1,
                      arbitrary_pointf2,
                      arbitrary_float_array,
                      arbitrary_bool3);
   scoped_ptr<DrawQuad> texture_cmp = texture_in->Copy(
       texture_in->shared_quad_state);
 
   scoped_ptr<TileDrawQuad> tile_in = TileDrawQuad::Create();
   tile_in->SetAll(shared_state1_in.get(),
                   arbitrary_rect2,
                   arbitrary_rect3,
                   arbitrary_rect1,
                   arbitrary_bool1,
-                  arbitrary_resourceid,
+                  arbitrary_resourceid3,
                   arbitrary_rectf1,
                   arbitrary_size1,
                   arbitrary_bool2);
   scoped_ptr<DrawQuad> tile_cmp = tile_in->Copy(
       tile_in->shared_quad_state);
 
   scoped_ptr<YUVVideoDrawQuad> yuvvideo_in =
       YUVVideoDrawQuad::Create();
   yuvvideo_in->SetAll(shared_state1_in.get(),
                       arbitrary_rect1,
                       arbitrary_rect2,
                       arbitrary_rect3,
                       arbitrary_bool1,
                       arbitrary_sizef1,
-                      arbitrary_plane1,
-                      arbitrary_plane2,
-                      arbitrary_plane3);
+                      arbitrary_resourceid1,
+                      arbitrary_resourceid2,
+                      arbitrary_resourceid3);
   scoped_ptr<DrawQuad> yuvvideo_cmp = yuvvideo_in->Copy(
       yuvvideo_in->shared_quad_state);
 
   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(arbitrary_id,
                   arbitrary_rect1,
                   arbitrary_rectf1,
                   arbitrary_matrix,
                   arbitrary_bool1,
                   arbitrary_bool2);
@@ skipping 132 matching lines @@
   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
       &iter, &frame_out));
 
   ASSERT_EQ(2u, frame_out.resource_list.size());
   Compare(arbitrary_resource1, frame_out.resource_list[0]);
   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 }
 
 }  // namespace
 }  // namespace content