Mojo C++ Bindings: Support custom impl ref types

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/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"
 
 namespace mojo {
 namespace {
@@ skipping 283 matching lines @@
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger the error handler.
   binding.ResumeIncomingMethodCallProcessing();
   run_loop.Run();
   EXPECT_TRUE(called);
 }
 
 class PingServiceImpl : public test::PingService {
  public:
-  explicit PingServiceImpl(test::PingServiceRequest request)
-      : binding_(this, std::move(request)) {}
+  PingServiceImpl() {}
   ~PingServiceImpl() override {}
 
   // test::PingService:
   void Ping(const PingCallback& callback) override {
     if (!ping_handler_.is_null())
       ping_handler_.Run();
     callback.Run();
   }
 
-  mojo::Binding<test::PingService>& binding() { return binding_; }
-
   void set_ping_handler(const base::Closure& handler) {
     ping_handler_ = handler;
   }
 
  private:
-  mojo::Binding<test::PingService> binding_;
   base::Closure ping_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(PingServiceImpl);
 };
 
 class CallbackFilter : public MessageReceiver {
  public:
   explicit CallbackFilter(const base::Closure& callback)
       : callback_(callback) {}
   ~CallbackFilter() override {}
 
   static std::unique_ptr<CallbackFilter> Wrap(const base::Closure& callback) {
     return base::MakeUnique<CallbackFilter>(callback);
   }
 
   // MessageReceiver:
   bool Accept(Message* message) override {
     callback_.Run();
     return true;
   }
 
  private:
   const base::Closure callback_;
 };
 
 // Verifies that message filters are notified in the order they were added and
 // are always notified before a message is dispatched.
 TEST_F(BindingTest, MessageFilter) {
   test::PingServicePtr ptr;
-  PingServiceImpl impl(GetProxy(&ptr));
+  PingServiceImpl impl;
+  mojo::Binding<test::PingService> binding(&impl, GetProxy(&ptr));
 
   int status = 0;
   auto handler_helper = [] (int* status, int expected_status, int new_status) {
     EXPECT_EQ(expected_status, *status);
     *status = new_status;
   };
   auto create_handler = [&] (int expected_status, int new_status) {
     return base::Bind(handler_helper, &status, expected_status, new_status);
   };
 
-  impl.binding().AddFilter(CallbackFilter::Wrap(create_handler(0, 1)));
-  impl.binding().AddFilter(CallbackFilter::Wrap(create_handler(1, 2)));
+  binding.AddFilter(CallbackFilter::Wrap(create_handler(0, 1)));
+  binding.AddFilter(CallbackFilter::Wrap(create_handler(1, 2)));
   impl.set_ping_handler(create_handler(2, 3));
 
   for (int i = 0; i < 10; ++i) {
     status = 0;
     base::RunLoop loop;
     ptr->Ping(loop.QuitClosure());
     loop.Run();
     EXPECT_EQ(3, status);
   }
 }
@@ skipping 50 matching lines @@
         EXPECT_EQ("hello", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
 
   ptr.ResetWithReason(1234u, "hello");
 
   run_loop.Run();
 }
 
+template <typename T>
+struct WeakPtrImplRefTraits {
+  using PointerType = base::WeakPtr<T>;
+
+  static bool IsNull(const base::WeakPtr<T>& ptr) { return !ptr; }
+  static T* GetRawPointer(base::WeakPtr<T>* ptr) { return ptr->get(); }
+};
+
+template <typename T>
+using WeakBinding = Binding<T, WeakPtrImplRefTraits<T>>;
+
+TEST_F(BindingTest, CustomImplPointerType) {
+  PingServiceImpl impl;
+  base::WeakPtrFactory<test::PingService> weak_factory(&impl);
+
+  test::PingServicePtr proxy;
+  WeakBinding<test::PingService> binding(weak_factory.GetWeakPtr(),
+                                         GetProxy(&proxy));
+
+  {
+    // Ensure the binding is functioning.
+    base::RunLoop run_loop;
+    proxy->Ping(run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  {
+    // Attempt to dispatch another message after the WeakPtr is invalidated.
+    base::Closure assert_not_reached = base::Bind([] { NOTREACHED(); });
+    impl.set_ping_handler(assert_not_reached);
+    proxy->Ping(assert_not_reached);
+
+    // The binding will close its end of the pipe which will trigger a
+    // connection error on |proxy|.
+    base::RunLoop run_loop;
+    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;
@@ skipping 104 matching lines @@
       },
       run_loop.QuitClosure()));
 
   ptr.ResetWithReason(5678u, "hello");
 
   run_loop.Run();
 }
 
 }  // namespace
 }  // mojo