Implement DrawQuad 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/surface_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 {
 
 namespace {
 
 class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
@@ skipping 23 matching lines @@
       const EchoFilterOperationCallback& callback) override {
     callback.Run(f);
   }
 
   void EchoFilterOperations(
       const FilterOperations& f,
       const EchoFilterOperationsCallback& callback) override {
     callback.Run(f);
   }
 
+  void EchoQuadList(const QuadList& q,
+                    const EchoQuadListCallback& callback) override {
+    callback.Run(q);
+  }
+
   void EchoRenderPassId(const RenderPassId& r,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoReturnedResource(
       const ReturnedResource& r,
       const EchoReturnedResourceCallback& callback) override {
     callback.Run(r);
   }
@@ skipping 198 matching lines @@
   input.Append(FilterOperation::CreateZoomFilter(2.0f, 1));
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   FilterOperations output;
   proxy->EchoFilterOperations(input, &output);
   EXPECT_EQ(input.size(), output.size());
   for (size_t i = 0; i < input.size(); ++i) {
     EXPECT_EQ(input.at(i), output.at(i));
   }
 }
 
+TEST_F(StructTraitsTest, QuadListBasic) {
+  const DrawQuad::Material material1 = DrawQuad::DEBUG_BORDER;
+  const DrawQuad::Material material2 = DrawQuad::SOLID_COLOR;
+  const DrawQuad::Material material3 = DrawQuad::SURFACE_CONTENT;
+  const DrawQuad::Material material4 = DrawQuad::RENDER_PASS;
+  const gfx::Rect rect1(1234, 4321, 1357, 7531);
+  const gfx::Rect rect2(2468, 8642, 4321, 1234);
+  const gfx::Rect rect3(1029, 3847, 5610, 2938);
+  const gfx::Rect rect4(1234, 5678, 9101112, 13141516);
+  const int32_t width1 = 1337;
+  const uint32_t color2 = 0xffffffff;
+  const SurfaceId surface_id(1234, 5678, 2468);
+  const RenderPassId render_pass_id(1234, 5678);
+
+  QuadList input;
+  DebugBorderDrawQuad* debug_quad =
+      input.AllocateAndConstruct<DebugBorderDrawQuad>();
+  debug_quad->material = material1;
+  debug_quad->rect = rect1;
+  debug_quad->width = width1;
+
+  SolidColorDrawQuad* solid_quad =
+      input.AllocateAndConstruct<SolidColorDrawQuad>();
+  solid_quad->material = material2;
+  solid_quad->rect = rect2;
+  solid_quad->color = color2;
+
+  SurfaceDrawQuad* surface_quad = input.AllocateAndConstruct<SurfaceDrawQuad>();
+  surface_quad->material = material3;
+  surface_quad->rect = rect3;
+  surface_quad->surface_id = surface_id;
+
+  RenderPassDrawQuad* render_pass_quad =
+      input.AllocateAndConstruct<RenderPassDrawQuad>();
+  render_pass_quad->material = material4;
+  render_pass_quad->rect = rect4;
+  render_pass_quad->render_pass_id = render_pass_id;
+
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  QuadList output;
+  proxy->EchoQuadList(input, &output);
+
+  ASSERT_EQ(input.size(), output.size());
+
+  ASSERT_EQ(material1, output.ElementAt(0)->material);
+  EXPECT_EQ(rect1, output.ElementAt(0)->rect);
+  EXPECT_EQ(width1,
+            static_cast<DebugBorderDrawQuad*>(output.ElementAt(0))->width);
+
+  ASSERT_EQ(material2, output.ElementAt(1)->material);
+  EXPECT_EQ(rect2, output.ElementAt(1)->rect);
+  EXPECT_EQ(color2,
+            static_cast<SolidColorDrawQuad*>(output.ElementAt(1))->color);
+
+  ASSERT_EQ(material3, output.ElementAt(2)->material);
+  EXPECT_EQ(rect3, output.ElementAt(2)->rect);
+  EXPECT_EQ(surface_id,
+            static_cast<SurfaceDrawQuad*>(output.ElementAt(2))->surface_id);
+
+  ASSERT_EQ(material4, output.ElementAt(3)->material);
+  EXPECT_EQ(rect4, output.ElementAt(3)->rect);
+  EXPECT_EQ(
+      render_pass_id,
+      static_cast<RenderPassDrawQuad*>(output.ElementAt(3))->render_pass_id);
+}
+
 TEST_F(StructTraitsTest, RenderPassId) {
   const int layer_id = 1337;
   const uint32_t index = 0xdeadbeef;
   RenderPassId input(layer_id, index);
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   RenderPassId output;
   proxy->EchoRenderPassId(input, &output);
   EXPECT_EQ(layer_id, output.layer_id);
   EXPECT_EQ(index, output.index);
 }
@@ skipping 148 matching lines @@
   EXPECT_EQ(mailbox_holder.sync_token, output.mailbox_holder.sync_token);
   EXPECT_EQ(mailbox_holder.texture_target,
             output.mailbox_holder.texture_target);
   EXPECT_EQ(read_lock_fences_enabled, output.read_lock_fences_enabled);
   EXPECT_EQ(is_software, output.is_software);
   EXPECT_EQ(gpu_memory_buffer_id, output.gpu_memory_buffer_id.id);
   EXPECT_EQ(is_overlay_candidate, output.is_overlay_candidate);
 }
 
 }  // namespace cc