Implemented StructTraits for cc::CopyOutputRequest

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/output/copy_output_result.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/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"
@@ skipping 25 matching lines @@
       const EchoCompositorFrameCallback& callback) override {
     callback.Run(std::move(c));
   }
 
   void EchoCompositorFrameMetadata(
       const CompositorFrameMetadata& c,
       const EchoCompositorFrameMetadataCallback& callback) override {
     callback.Run(c);
   }
 
+  void EchoCopyOutputRequest(
+      const CopyOutputRequest& c,
+      const EchoCopyOutputRequestCallback& callback) override {
+    callback.Run(std::move(c));
+  }
+
   void EchoFilterOperation(
       const FilterOperation& f,
       const EchoFilterOperationCallback& callback) override {
     callback.Run(f);
   }
 
   void EchoFilterOperations(
       const FilterOperations& f,
       const EchoFilterOperationsCallback& callback) override {
     callback.Run(f);
@@ skipping 46 matching lines @@
   void EchoTransferableResource(
       const TransferableResource& t,
       const EchoTransferableResourceCallback& callback) override {
     callback.Run(t);
   }
 
   mojo::BindingSet<TraitsTestService> traits_test_bindings_;
   DISALLOW_COPY_AND_ASSIGN(StructTraitsTest);
 };
 
+void StubCopyOutputRequestCallback(std::unique_ptr<CopyOutputResult> result) {}
+
 }  // namespace
 
 TEST_F(StructTraitsTest, BeginFrameArgs) {
   const base::TimeTicks frame_time = base::TimeTicks::Now();
   const base::TimeTicks deadline = base::TimeTicks::Now();
   const base::TimeDelta interval = base::TimeDelta::FromMilliseconds(1337);
   const BeginFrameArgs::BeginFrameArgsType type = BeginFrameArgs::NORMAL;
   const bool on_critical_path = true;
   BeginFrameArgs input;
   input.frame_time = frame_time;
@@ skipping 208 matching lines @@
   ui::LatencyInfo::LatencyComponent component;
   EXPECT_TRUE(output.latency_info[0].FindLatency(
       ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT, 1337,
       &component));
   EXPECT_EQ(7331, component.sequence_number);
   EXPECT_EQ(referenced_surfaces.size(), output.referenced_surfaces.size());
   for (uint32_t i = 0; i < referenced_surfaces.size(); ++i)
     EXPECT_EQ(referenced_surfaces[i], output.referenced_surfaces[i]);
 }
 
+TEST_F(StructTraitsTest, CopyOutputRequest) {
+  const gfx::Rect area(5, 7, 44, 55);
+  const auto callback = base::Bind(StubCopyOutputRequestCallback);
+  const int8_t mailbox_name[GL_MAILBOX_SIZE_CHROMIUM] = {
+      0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 3};
+  const uint32_t target = 3;
+  const auto source =
+      base::UnguessableToken::Deserialize(0xdeadbeef, 0xdeadf00d);
+  gpu::Mailbox mailbox;
+  mailbox.SetName(mailbox_name);
+  TextureMailbox texture_mailbox(mailbox, gpu::SyncToken(), target);
+
+  // Test with bitmap.
+  std::unique_ptr<CopyOutputRequest> input;
+  input = CopyOutputRequest::CreateBitmapRequest(callback);
+  input->set_area(area);
+  input->set_source(source);
+
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  CopyOutputRequest output;
+  proxy->EchoCopyOutputRequest(*input.get(), &output);
+
+  EXPECT_TRUE(output.force_bitmap_result());
+  EXPECT_FALSE(output.has_texture_mailbox());
+  EXPECT_TRUE(output.has_area());
+  EXPECT_EQ(area, output.area());
+  EXPECT_EQ(source, output.source());
+
+  // Test with texture mailbox.
+  input = CopyOutputRequest::CreateRequest(callback);
+  input->SetTextureMailbox(texture_mailbox);
+
+  CopyOutputRequest output2;
+  proxy->EchoCopyOutputRequest(*input.get(), &output2);
+
+  EXPECT_TRUE(output2.has_texture_mailbox());
+  EXPECT_FALSE(output2.has_area());
+  EXPECT_EQ(mailbox, output2.texture_mailbox().mailbox());
+  EXPECT_EQ(target, output2.texture_mailbox().target());
+  EXPECT_FALSE(output2.has_source());
+}
+
 TEST_F(StructTraitsTest, FilterOperation) {
   const FilterOperation inputs[] = {
       FilterOperation::CreateBlurFilter(20),
       FilterOperation::CreateDropShadowFilter(gfx::Point(4, 4), 4.0f,
                                               SkColorSetARGB(255, 40, 0, 0)),
       FilterOperation::CreateReferenceFilter(SkDropShadowImageFilter::Make(
           SkIntToScalar(3), SkIntToScalar(8), SkIntToScalar(4),
           SkIntToScalar(9), SK_ColorBLACK,
           SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
           nullptr))};
@@ skipping 615 matching lines @@
   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);
   EXPECT_EQ(bits_per_channel, out_quad->bits_per_channel);
 }
 
 }  // namespace cc