CopyOutputResult must have a working release callback when received over mojo

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 "base/run_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"
@@ skipping 108 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) {}
+void CopyOutputResultCallback(base::Closure quit_closure,
+                              const gpu::SyncToken& expected_sync_token,
+                              bool expected_is_lost,
+                              const gpu::SyncToken& sync_token,
+                              bool is_lost) {
+  EXPECT_EQ(expected_sync_token, sync_token);
+  EXPECT_EQ(expected_is_lost, is_lost);
+  quit_closure.Run();
+}
 
 }  // 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;
@@ skipping 278 matching lines @@
   EXPECT_EQ(in_bitmap->getSize(), out_bitmap->getSize());
   EXPECT_EQ(0, std::memcmp(in_bitmap->getPixels(), out_bitmap->getPixels(),
                            in_bitmap->getSize()));
 }
 
 TEST_F(StructTraitsTest, CopyOutputResult_Texture) {
   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::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
+                            gpu::CommandBufferId::FromUnsafeValue(0x123),
+                            71234838);
+  bool is_lost = true;
+  base::RunLoop run_loop;
+  auto callback = SingleReleaseCallback::Create(base::Bind(
+      CopyOutputResultCallback, run_loop.QuitClosure(), sync_token, is_lost));
   gpu::Mailbox mailbox;
   mailbox.SetName(mailbox_name);
   TextureMailbox texture_mailbox(mailbox, gpu::SyncToken(), target);
 
   auto input = CopyOutputResult::CreateTextureResult(size, texture_mailbox,
                                                      std::move(callback));
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   std::unique_ptr<CopyOutputResult> output;
   proxy->EchoCopyOutputResult(std::move(input), &output);
 
   EXPECT_FALSE(output->HasBitmap());
   EXPECT_TRUE(output->HasTexture());
   EXPECT_EQ(size, output->size());
 
   TextureMailbox out_mailbox;
   std::unique_ptr<SingleReleaseCallback> out_callback;
   output->TakeTexture(&out_mailbox, &out_callback);
   EXPECT_EQ(mailbox, out_mailbox.mailbox());
+  out_callback->Run(sync_token, is_lost);
+  // If CopyOutputResultCallback is called (which is the intended behaviour),
+  // this will exit. Otherwise, this test will time out and fail.
+  // In CopyOutputResultCallback we verify that the given sync_token and is_lost
+  // have their intended values.
+  run_loop.Run();
 }
 
 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,
@@ skipping 617 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