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 68 matching lines @@
       const ReturnedResource& r,
       const EchoReturnedResourceCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoSelection(const Selection<gfx::SelectionBound>& s,
                      const EchoSelectionCallback& callback) override {
     callback.Run(s);
   }
 
+  void EchoSingleReleaseCallback(
+      std::unique_ptr<SingleReleaseCallback> s,
+      const EchoSingleReleaseCallbackCallback& callback) override {
+    callback.Run(std::move(s));
+  }
+
   void EchoSharedQuadState(
       const SharedQuadState& s,
       const EchoSharedQuadStateCallback& callback) override {
     callback.Run(s);
   }
 
   void EchoSurfaceId(const SurfaceId& s,
                      const EchoSurfaceIdCallback& callback) override {
     callback.Run(s);
   }
@@ skipping 18 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);
 };
 
+class TextureMailboxReleaserImpl : public mojom::TextureMailboxReleaser {
+ public:
+  TextureMailboxReleaserImpl(mojom::TextureMailboxReleaserRequest request,
+                             base::Closure quit_closure)
+      : quit_closure_(quit_closure), binding_(this, std::move(request)) {}
+
+  bool is_called() { return is_called_; }
+
+  // mojom::TextureMailboxReleaser implementation:
+  void Release(const gpu::SyncToken& sync_token, bool is_lost) override {
+    is_called_ = true;
+    quit_closure_.Run();
+  }
+
+ private:
+  bool is_called_ = false;
+  base::Closure quit_closure_;
+  mojo::Binding<mojom::TextureMailboxReleaser> binding_;
+};
+
 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();
@@ skipping 712 matching lines @@
   input.is_empty_text_form_control = is_empty_text_form_control;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   Selection<gfx::SelectionBound> output;
   proxy->EchoSelection(input, &output);
   EXPECT_EQ(start, output.start);
   EXPECT_EQ(end, output.end);
   EXPECT_EQ(is_editable, output.is_editable);
   EXPECT_EQ(is_empty_text_form_control, output.is_empty_text_form_control);
 }
 
+TEST_F(StructTraitsTest, SingleReleaseCallback) {
+  base::RunLoop run_loop;
+  mojom::TextureMailboxReleaserPtr releaser;
+  TextureMailboxReleaserImpl impl(MakeRequest(&releaser),
+                                  run_loop.QuitClosure());
+  auto input = SingleReleaseCallback::Create(std::move(releaser));
+
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  std::unique_ptr<SingleReleaseCallback> output;
+  proxy->EchoSingleReleaseCallback(std::move(input), &output);
+
+  EXPECT_FALSE(impl.is_called());
+  output->Run(gpu::SyncToken(), true);
+  run_loop.Run();
+  EXPECT_TRUE(impl.is_called());
+}
+
 TEST_F(StructTraitsTest, SurfaceId) {
   static constexpr FrameSinkId frame_sink_id(1337, 1234);
   static LocalSurfaceId local_surface_id(0xfbadbeef,
                                          base::UnguessableToken::Create());
   SurfaceId input(frame_sink_id, local_surface_id);
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   SurfaceId output;
   proxy->EchoSurfaceId(input, &output);
   EXPECT_EQ(frame_sink_id, output.frame_sink_id());
   EXPECT_EQ(local_surface_id, output.local_surface_id());
@@ skipping 208 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