media: Add RunOnDestruction

mojo/public/cpp/bindings/tests/binding_unittest.cc

 // Copyright 2015 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.
 
 // Note: This file tests both binding.h (mojo::Binding) and strong_binding.h
 // (mojo::StrongBinding).
 
 #include "mojo/public/cpp/bindings/binding.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/interfaces/bindings/tests/ping_service.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_interfaces.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include "media/base/run_on_destruction.h"
+
 namespace mojo {
 namespace {
 
 class BindingTestBase : public testing::Test {
  public:
   BindingTestBase() {}
   ~BindingTestBase() override {}
 
   base::MessageLoop& loop() { return loop_; }
 
@@ skipping 14 matching lines @@
 
  private:
   // sample::Service implementation
   void Frobinate(sample::FooPtr foo,
                  BazOptions options,
                  sample::PortPtr port,
                  const FrobinateCallback& callback) override {
     callback.Run(1);
   }
   void GetPort(InterfaceRequest<sample::Port> port) override {}
+  void EatCallback(const EatCallbackCallback& callback) override {
+    eat_callback_ = callback;
+  }
 
   bool* const was_deleted_;
+  EatCallbackCallback eat_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImpl);
 };
 
 template <typename... Args>
 void DoSetFlagAndRunClosure(bool* flag,
                             const base::Closure& closure,
                             Args... args) {
   *flag = true;
   if (!closure.is_null())
     closure.Run();
 }
 
 template <typename... Args>
 base::Callback<void(Args...)> SetFlagAndRunClosure(
     bool* flag,
     const base::Closure& callback = base::Closure()) {
   return base::Bind(&DoSetFlagAndRunClosure<Args...>, flag, callback);
 }
 
+void OnResult(bool* result_storage, bool result) {
+  LOG(ERROR) << __func__ << ": " << result;
+  *result_storage = result;
+}
+
 // BindingTest -----------------------------------------------------------------
 
 using BindingTest = BindingTestBase;
 
 TEST_F(BindingTest, Close) {
   bool called = false;
   sample::ServicePtr ptr;
   auto request = MakeRequest(&ptr);
   base::RunLoop run_loop;
   ptr.set_connection_error_handler(
@@ skipping 10 matching lines @@
 // Tests that destroying a mojo::Binding closes the bound message pipe handle.
 TEST_F(BindingTest, DestroyClosesMessagePipe) {
   bool encountered_error = false;
   ServiceImpl impl;
   sample::ServicePtr ptr;
   auto request = MakeRequest(&ptr);
   base::RunLoop run_loop;
   ptr.set_connection_error_handler(
       SetFlagAndRunClosure(&encountered_error, run_loop.QuitClosure()));
   bool called = false;
+  bool result = false;
   base::RunLoop run_loop2;
   {
     Binding<sample::Service> binding(&impl, std::move(request));
     ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    SetFlagAndRunClosure<int32_t>(&called,
                                                  run_loop2.QuitClosure()));
+    ptr->EatCallback(media::RunOnDestruction(base::Bind(&OnResult, &result), true));
     run_loop2.Run();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
+    EXPECT_FALSE(result);
   }
   // Now that the Binding is out of scope we should detect an error on the other
   // end of the pipe.
   run_loop.Run();
   EXPECT_TRUE(encountered_error);
 
   // And calls should fail.
   called = false;
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  SetFlagAndRunClosure<int32_t>(&called,
                                                run_loop2.QuitClosure()));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(called);
+  EXPECT_TRUE(result);
 }
 
 // Tests that the binding's connection error handler gets called when the other
 // end is closed.
 TEST_F(BindingTest, ConnectionError) {
   bool called = false;
   {
     ServiceImpl impl;
     sample::ServicePtr ptr;
     Binding<sample::Service> binding(&impl, MakeRequest(&ptr));
@@ skipping 460 matching lines @@
       },
       run_loop.QuitClosure()));
 
   ptr.ResetWithReason(5678u, "hello");
 
   run_loop.Run();
 }
 
 }  // namespace
 }  // mojo