Mojo C++ Bindings: Introduce mojo::SupportsStrongBinding

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>
@@ skipping 18 matching lines @@
   ~BindingTestBase() override {}
 
   base::MessageLoop& loop() { return loop_; }
 
  private:
   base::MessageLoop loop_;
 
   DISALLOW_COPY_AND_ASSIGN(BindingTestBase);
 };
 
-class ServiceImpl : public sample::Service {
+class ServiceImpl : public SupportsStrongBinding<sample::Service> {
  public:
-  explicit ServiceImpl(bool* was_deleted = nullptr)
-      : was_deleted_(was_deleted) {}
+  explicit ServiceImpl(
+      bool* was_deleted = nullptr,
+      const base::Closure& destruction_callback = base::Closure())
+      : was_deleted_(was_deleted),
+        destruction_callback_(destruction_callback) {}
   ~ServiceImpl() override {
     if (was_deleted_)
       *was_deleted_ = true;
+    if (!destruction_callback_.is_null())
+      destruction_callback_.Run();
   }
 
  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 {}
 
   bool* const was_deleted_;
+  const base::Closure destruction_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())
@@ skipping 97 matching lines @@
   // We can also close the other end, and the error handler still won't be
   // called.
   ptr.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(called);
 }
 
 class ServiceImplWithBinding : public ServiceImpl {
  public:
   ServiceImplWithBinding(bool* was_deleted,
-                         const base::Closure& closure,
+                         const base::Closure& destruction_callback,
                          InterfaceRequest<sample::Service> request)
-      : ServiceImpl(was_deleted),
-        binding_(this, std::move(request)),
-        closure_(closure) {
+      : ServiceImpl(was_deleted, destruction_callback),
+        binding_(this, std::move(request)) {
     binding_.set_connection_error_handler(
         base::Bind(&ServiceImplWithBinding::OnConnectionError,
                    base::Unretained(this)));
   }
 
  private:
-  ~ServiceImplWithBinding() override{
-    closure_.Run();
-  }
-
   void OnConnectionError() { delete this; }
 
   Binding<sample::Service> binding_;
-  base::Closure closure_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImplWithBinding);
 };
 
 // Tests that the binding may be deleted in the connection error handler.
 TEST_F(BindingTest, SelfDeleteOnConnectionError) {
   bool was_deleted = false;
   sample::ServicePtr ptr;
   // This should delete itself on connection error.
   base::RunLoop run_loop;
@@ skipping 276 matching lines @@
     proxy.set_connection_error_handler(run_loop.QuitClosure());
     weak_factory.InvalidateWeakPtrs();
     run_loop.Run();
   }
 }
 
 // StrongBindingTest -----------------------------------------------------------
 
 using StrongBindingTest = BindingTestBase;
 
-// Tests that destroying a mojo::StrongBinding closes the bound message pipe
-// handle but does *not* destroy the implementation object.
-TEST_F(StrongBindingTest, DestroyClosesMessagePipe) {
-  base::RunLoop run_loop;
-  bool encountered_error = false;
-  bool was_deleted = false;
-  sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
-  ptr.set_connection_error_handler(
-      SetFlagAndRunClosure(&encountered_error, run_loop.QuitClosure()));
-  bool called = false;
-  base::RunLoop run_loop2;
-
-  auto binding = MakeStrongBinding(base::MakeUnique<ServiceImpl>(&was_deleted),
-                                   std::move(request));
-  ptr->Frobinate(
-      nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-      SetFlagAndRunClosure<int32_t>(&called, run_loop2.QuitClosure()));
-  run_loop2.Run();
-  EXPECT_TRUE(called);
-  EXPECT_FALSE(encountered_error);
-  binding->Close();
-
-  // Now that the StrongBinding is closed we should detect an error on the other
-  // end of the pipe.
-  run_loop.Run();
-  EXPECT_TRUE(encountered_error);
-
-  // Destroying the StrongBinding also destroys the impl.
-  ASSERT_TRUE(was_deleted);
-}
-
-// Tests the typical case, where the implementation object owns the
-// StrongBinding (and should be destroyed on connection error).
 TEST_F(StrongBindingTest, ConnectionErrorDestroysImpl) {
   sample::ServicePtr ptr;
   bool was_deleted = false;
-  // Will delete itself.
+
   base::RunLoop run_loop;
-  new ServiceImplWithBinding(&was_deleted, run_loop.QuitClosure(),
-                             GetProxy(&ptr));
-
-  base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(was_deleted);
-
+  StrongBindingPtr<sample::Service> weak_binding = mojo::MakeStrongBinding(
+      base::MakeUnique<ServiceImpl>(&was_deleted, run_loop.QuitClosure()),
+      GetProxy(&ptr));
   ptr.reset();
   EXPECT_FALSE(was_deleted);
   run_loop.Run();
   EXPECT_TRUE(was_deleted);
+  EXPECT_FALSE(weak_binding);
+}
+
+TEST_F(StrongBindingTest, ExplicitImplDeletionIsSafe) {
+  sample::ServicePtr ptr;
+  bool was_deleted = false;
+
+  base::Closure close_callback;
+
+  std::unique_ptr<ServiceImpl> impl =
+      base::MakeUnique<ServiceImpl>(&was_deleted);
+  ServiceImpl* raw_impl = impl.get();
+  StrongBindingPtr<sample::Service> weak_binding =
+      mojo::MakeStrongBinding(std::move(impl), GetProxy(&ptr));
+
+  EXPECT_FALSE(was_deleted);
+
+  base::RunLoop run_loop;
+  ptr.set_connection_error_handler(run_loop.QuitClosure());
+
+  EXPECT_TRUE(weak_binding);
+
+  delete raw_impl;
+
+  EXPECT_TRUE(was_deleted);
+  EXPECT_FALSE(weak_binding);
+
+  run_loop.Run();
 }
 
 TEST_F(StrongBindingTest, FlushForTesting) {
   bool called = false;
   bool was_deleted = false;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   auto binding = MakeStrongBinding(base::MakeUnique<ServiceImpl>(&was_deleted),
                                    std::move(request));
   binding->set_connection_error_handler(base::Bind(&Fail));
@@ skipping 51 matching lines @@
       },
       run_loop.QuitClosure()));
 
   ptr.ResetWithReason(5678u, "hello");
 
   run_loop.Run();
 }
 
 }  // namespace
 }  // mojo