Implement StreamVideoDrawQuad StructTraits

cc/ipc/struct_traits_unittest.cc

 // Copyright 2016 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 "base/message_loop/message_loop.h"
 #include "cc/input/selection.h"
 #include "cc/ipc/traits_test_service.mojom.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/render_pass_id.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/yuv_video_draw_quad.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkString.h"
 #include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 
 namespace cc {
 
@@ skipping 314 matching lines @@
   const bool y_flipped = true;
   const bool nearest_neighbor = true;
   const bool secure_output_only = true;
   TextureDrawQuad* texture_draw_quad =
       input.AllocateAndConstruct<TextureDrawQuad>();
   texture_draw_quad->SetNew(&sqs, rect5, rect5, rect5, resource_id5,
                             premultiplied_alpha, uv_top_left, uv_bottom_right,
                             background_color, vertex_opacity, y_flipped,
                             nearest_neighbor, secure_output_only);
 
+  const gfx::Rect rect6(321, 765, 11109, 151413);
+  const ResourceId resource_id6(1234);
+  const gfx::Size resource_size_in_pixels(1234, 5678);
+  const gfx::Transform matrix(16.1f, 15.3f, 14.3f, 13.7f, 12.2f, 11.4f, 10.4f,
+                              9.8f, 8.1f, 7.3f, 6.3f, 5.7f, 4.8f, 3.4f, 2.4f,
+                              1.2f);
+  StreamVideoDrawQuad* stream_video_draw_quad =
+      input.AllocateAndConstruct<StreamVideoDrawQuad>();
+  stream_video_draw_quad->SetNew(&sqs, rect6, rect6, rect6, resource_id6,
+                                 resource_size_in_pixels, matrix);
+
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   QuadList output;
   proxy->EchoQuadList(input, &output);
 
   ASSERT_EQ(input.size(), output.size());
 
   const DebugBorderDrawQuad* out_debug_border_draw_quad =
       DebugBorderDrawQuad::MaterialCast(output.ElementAt(0));
   EXPECT_EQ(rect1, out_debug_border_draw_quad->rect);
   EXPECT_EQ(rect1, out_debug_border_draw_quad->visible_rect);
@@ skipping 41 matching lines @@
   EXPECT_EQ(uv_top_left, out_texture_draw_quad->uv_top_left);
   EXPECT_EQ(uv_bottom_right, out_texture_draw_quad->uv_bottom_right);
   EXPECT_EQ(background_color, out_texture_draw_quad->background_color);
   EXPECT_EQ(vertex_opacity[0], out_texture_draw_quad->vertex_opacity[0]);
   EXPECT_EQ(vertex_opacity[1], out_texture_draw_quad->vertex_opacity[1]);
   EXPECT_EQ(vertex_opacity[2], out_texture_draw_quad->vertex_opacity[2]);
   EXPECT_EQ(vertex_opacity[3], out_texture_draw_quad->vertex_opacity[3]);
   EXPECT_EQ(y_flipped, out_texture_draw_quad->y_flipped);
   EXPECT_EQ(nearest_neighbor, out_texture_draw_quad->nearest_neighbor);
   EXPECT_EQ(secure_output_only, out_texture_draw_quad->secure_output_only);
+
+  const StreamVideoDrawQuad* out_stream_video_draw_quad =
+      StreamVideoDrawQuad::MaterialCast(output.ElementAt(5));
+  EXPECT_EQ(rect6, out_stream_video_draw_quad->rect);
+  EXPECT_EQ(rect6, out_stream_video_draw_quad->opaque_rect);
+  EXPECT_EQ(rect6, out_stream_video_draw_quad->visible_rect);
+  EXPECT_EQ(resource_id6, out_stream_video_draw_quad->resource_id());
+  EXPECT_EQ(resource_size_in_pixels,
+            out_stream_video_draw_quad->resource_size_in_pixels());
+  EXPECT_EQ(matrix, out_stream_video_draw_quad->matrix);
 }
 
 TEST_F(StructTraitsTest, RenderPass) {
   const RenderPassId id(3, 2);
   const gfx::Rect output_rect(45, 22, 120, 13);
   const gfx::Transform transform_to_root =
       gfx::Transform(1.0, 0.5, 0.5, -0.5, -1.0, 0.0);
   const gfx::Rect damage_rect(56, 123, 19, 43);
   const bool has_transparent_background = true;
   std::unique_ptr<RenderPass> input = RenderPass::Create();
@@ skipping 309 matching lines @@
   EXPECT_EQ(y_plane_resource_id, out_quad->y_plane_resource_id());
   EXPECT_EQ(u_plane_resource_id, out_quad->u_plane_resource_id());
   EXPECT_EQ(v_plane_resource_id, out_quad->v_plane_resource_id());
   EXPECT_EQ(a_plane_resource_id, out_quad->a_plane_resource_id());
   EXPECT_EQ(color_space, out_quad->color_space);
   EXPECT_EQ(resource_offset, out_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, out_quad->resource_multiplier);
 }
 
 }  // namespace cc