Implemented StructTraits for cc::CopyOutputResult

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"
@@ skipping 39 matching lines @@
       const EchoCompositorFrameMetadataCallback& callback) override {
     callback.Run(c);
   }
 
   void EchoCopyOutputRequest(
       const CopyOutputRequest& c,
       const EchoCopyOutputRequestCallback& callback) override {
     callback.Run(std::move(c));
   }
 
+  void EchoCopyOutputResult(
+      const CopyOutputResult& c,
+      const EchoCopyOutputResultCallback& callback) override {
+    callback.Run(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 48 matching lines @@
       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) {}
 
+void StubCopyOutputResultCallback(const gpu::SyncToken& sync_token,
+                                  bool is_lost) {}
+
 }  // 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 225 matching lines @@
       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, CopyOutputResult) {
+  const gfx::Size size(1234, 5678);
+  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;
+  auto callback =
+      SingleReleaseCallback::Create(base::Bind(StubCopyOutputResultCallback));
+  gpu::Mailbox mailbox;
+  mailbox.SetName(mailbox_name);
+  TextureMailbox texture_mailbox(mailbox, gpu::SyncToken(), target);
+  auto bitmap = base::MakeUnique<SkBitmap>();
+  bitmap->allocN32Pixels(7, 8);
+  bitmap->eraseARGB(123, 213, 77, 33);
+
+  // Bitmap test
+  auto in_bitmap = base::MakeUnique<SkBitmap>(*bitmap);
+  auto input = CopyOutputResult::CreateBitmapResult(std::move(in_bitmap));
+
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  CopyOutputResult output;
+  proxy->EchoCopyOutputResult(*input, &output);
+
+  EXPECT_TRUE(output.HasBitmap());
+  EXPECT_FALSE(output.HasTexture());
+  EXPECT_EQ(input->size(), output.size());
+  std::unique_ptr<SkBitmap> out_bitmap = output.TakeBitmap();
+  EXPECT_EQ(bitmap->getSize(), out_bitmap->getSize());
+  EXPECT_EQ(0, std::memcmp(bitmap->getPixels(), out_bitmap->getPixels(),
+                           bitmap->getSize()));
+
+  // Texture test

[vmpstr, 2017/01/31 21:32:19]

nit: Can you create a different TEST_F for this (even though there will be some
boilerplate code)

+  input = CopyOutputResult::CreateTextureResult(size, texture_mailbox,
+                                                std::move(callback));
+
+  CopyOutputResult output2;
+  proxy->EchoCopyOutputResult(*input, &output2);
+
+  EXPECT_FALSE(output2.HasBitmap());
+  EXPECT_TRUE(output2.HasTexture());
+  EXPECT_EQ(size, output2.size());
+  TextureMailbox out_mailbox;
+  std::unique_ptr<SingleReleaseCallback> out_callback;
+  output2.TakeTexture(&out_mailbox, &out_callback);
+  EXPECT_EQ(mailbox, out_mailbox.mailbox());
+}
+
 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