Mojo C++ bindings: support disconnect with a reason.

mojo/public/cpp/bindings/tests/associated_interface_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.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 92 matching lines @@
   AssociatedInterfacePtrInfo<T> EmulatePassingAssociatedPtrInfo(
       AssociatedInterfacePtrInfo<T> ptr_info,
       scoped_refptr<MultiplexRouter> target) {
     ScopedInterfaceEndpointHandle handle = ptr_info.PassHandle();
     CHECK(!handle.is_local());
     return AssociatedInterfacePtrInfo<T>(
         target->CreateLocalEndpointHandle(handle.release()),
         ptr_info.version());
   }
 
-  template <typename T>
-  AssociatedInterfaceRequest<T> EmulatePassingAssociatedRequest(
-      AssociatedInterfaceRequest<T> request,
-      scoped_refptr<MultiplexRouter> target) {
-    ScopedInterfaceEndpointHandle handle = request.PassHandle();
-    CHECK(!handle.is_local());
-    return MakeAssociatedRequest<T>(
-        target->CreateLocalEndpointHandle(handle.release()));
+  void CreateRouterPair(scoped_refptr<MultiplexRouter>* router0,
+                        scoped_refptr<MultiplexRouter>* router1) {
+    MessagePipe pipe;
+    *router0 = new MultiplexRouter(true, std::move(pipe.handle0),
+                                   base::ThreadTaskRunnerHandle::Get());
+    *router1 = new MultiplexRouter(false, std::move(pipe.handle1),
+                                   base::ThreadTaskRunnerHandle::Get());
+  }
+
+  void CreateIntegerSenderWithExistingRouters(
+      scoped_refptr<MultiplexRouter> router0,
+      IntegerSenderAssociatedPtrInfo* ptr_info0,
+      scoped_refptr<MultiplexRouter> router1,
+      IntegerSenderAssociatedRequest* request1) {
+    router1->CreateAssociatedGroup()->CreateAssociatedInterface(
+        AssociatedGroup::WILL_PASS_PTR, ptr_info0, request1);
+    *ptr_info0 =
+        EmulatePassingAssociatedPtrInfo(std::move(*ptr_info0), router0);
+  }
+
+  void CreateIntegerSender(IntegerSenderAssociatedPtrInfo* ptr_info,
+                           IntegerSenderAssociatedRequest* request) {
+    scoped_refptr<MultiplexRouter> router0;
+    scoped_refptr<MultiplexRouter> router1;
+    CreateRouterPair(&router0, &router1);
+    CreateIntegerSenderWithExistingRouters(router1, ptr_info, router0, request);
   }
 
   // Okay to call from any thread.
   void QuitRunLoop(base::RunLoop* run_loop) {
     if (loop_.task_runner()->BelongsToCurrentThread()) {
       run_loop->Quit();
     } else {
       loop_.task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&AssociatedInterfaceTest::QuitRunLoop,
@@ skipping 31 matching lines @@
 }
 
 void Fail() {
   FAIL() << "Unexpected connection error";
 }
 
 TEST_F(AssociatedInterfaceTest, InterfacesAtBothEnds) {
   // Bind to the same pipe two associated interfaces, whose implementation lives
   // at different ends. Test that the two don't interfere with each other.
 
-  MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
+  scoped_refptr<MultiplexRouter> router0;
+  scoped_refptr<MultiplexRouter> router1;
+  CreateRouterPair(&router0, &router1);
 
   AssociatedInterfaceRequest<IntegerSender> request;
   IntegerSenderAssociatedPtrInfo ptr_info;
-
-  router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-      AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
-  ptr_info = EmulatePassingAssociatedPtrInfo(std::move(ptr_info), router1);
+  CreateIntegerSenderWithExistingRouters(router1, &ptr_info, router0, &request);
 
   IntegerSenderImpl impl0(std::move(request));
   AssociatedInterfacePtr<IntegerSender> ptr0;
   ptr0.Bind(std::move(ptr_info));
 
-  router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-      AssociatedGroup::WILL_PASS_REQUEST, &ptr_info, &request);
-  request = EmulatePassingAssociatedRequest(std::move(request), router1);
+  CreateIntegerSenderWithExistingRouters(router0, &ptr_info, router1, &request);
 
   IntegerSenderImpl impl1(std::move(request));
   AssociatedInterfacePtr<IntegerSender> ptr1;
   ptr1.Bind(std::move(ptr_info));
 
   base::RunLoop run_loop, run_loop2;
   bool ptr0_callback_run = false;
   ptr0->Echo(123, ExpectValueSetFlagAndRunClosure(123, &ptr0_callback_run,
                                                   run_loop.QuitClosure()));
 
@@ skipping 156 matching lines @@
   base::Closure notify_finish_;
 };
 
 TEST_F(AssociatedInterfaceTest, MultiThreadAccess) {
   // Set up four associated interfaces on a message pipe. Use the inteface
   // pointers on four threads in parallel; run the interface implementations on
   // two threads. Test that multi-threaded access works.
 
   const int32_t kMaxValue = 1000;
   MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
+  scoped_refptr<MultiplexRouter> router0;
+  scoped_refptr<MultiplexRouter> router1;
+  CreateRouterPair(&router0, &router1);
 
   AssociatedInterfaceRequest<IntegerSender> requests[4];
   IntegerSenderAssociatedPtrInfo ptr_infos[4];
-
   for (size_t i = 0; i < 4; ++i) {
-    router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-        AssociatedGroup::WILL_PASS_PTR, &ptr_infos[i], &requests[i]);
-    ptr_infos[i] =
-        EmulatePassingAssociatedPtrInfo(std::move(ptr_infos[i]), router1);
+    CreateIntegerSenderWithExistingRouters(router1, &ptr_infos[i], router0,
+                                           &requests[i]);
   }
 
   TestSender senders[4];
   for (size_t i = 0; i < 4; ++i) {
     senders[i].sender_thread()->task_runner()->PostTask(
         FROM_HERE, base::Bind(&TestSender::SetUp, base::Unretained(&senders[i]),
                               base::Passed(&ptr_infos[i]), nullptr,
                               kMaxValue * (i + 1) / 4));
   }
 
@@ skipping 56 matching lines @@
 }
 
 TEST_F(AssociatedInterfaceTest, FIFO) {
   // Set up four associated interfaces on a message pipe. Use the inteface
   // pointers on four threads; run the interface implementations on two threads.
   // Take turns to make calls using the four pointers. Test that FIFO-ness is
   // preserved.
 
   const int32_t kMaxValue = 100;
   MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
+  scoped_refptr<MultiplexRouter> router0;
+  scoped_refptr<MultiplexRouter> router1;
+  CreateRouterPair(&router0, &router1);
 
   AssociatedInterfaceRequest<IntegerSender> requests[4];
   IntegerSenderAssociatedPtrInfo ptr_infos[4];
-
   for (size_t i = 0; i < 4; ++i) {
-    router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-        AssociatedGroup::WILL_PASS_PTR, &ptr_infos[i], &requests[i]);
-    ptr_infos[i] =
-        EmulatePassingAssociatedPtrInfo(std::move(ptr_infos[i]), router1);
+    CreateIntegerSenderWithExistingRouters(router1, &ptr_infos[i], router0,
+                                           &requests[i]);
   }
 
   TestSender senders[4];
   for (size_t i = 0; i < 4; ++i) {
     senders[i].sender_thread()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&TestSender::SetUp, base::Unretained(&senders[i]),
                    base::Passed(&ptr_infos[i]),
                    base::Unretained(&senders[(i + 1) % 4]), kMaxValue));
   }
@@ skipping 259 matching lines @@
       ping_b->Ping(loop.QuitClosure());
       loop.Run();
     }
 
     EXPECT_EQ(3, a_status);
     EXPECT_EQ(3, b_status);
   }
 }
 
 TEST_F(AssociatedInterfaceTest, AssociatedPtrFlushForTesting) {
-  MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
-
   AssociatedInterfaceRequest<IntegerSender> request;
   IntegerSenderAssociatedPtrInfo ptr_info;
-
-  router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-      AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
-  ptr_info = EmulatePassingAssociatedPtrInfo(std::move(ptr_info), router1);
+  CreateIntegerSender(&ptr_info, &request);
 
   IntegerSenderImpl impl0(std::move(request));
   AssociatedInterfacePtr<IntegerSender> ptr0;
   ptr0.Bind(std::move(ptr_info));
   ptr0.set_connection_error_handler(base::Bind(&Fail));
 
   bool ptr0_callback_run = false;
   ptr0->Echo(123, ExpectValueSetFlagAndRunClosure(
                       123, &ptr0_callback_run, base::Bind(&base::DoNothing)));
   ptr0.FlushForTesting();
   EXPECT_TRUE(ptr0_callback_run);
 }
 
 void SetBool(bool* value) {
   *value = true;
 }
 
 template <typename T>
 void SetBoolWithUnusedParameter(bool* value, T unused) {
   *value = true;
 }
 
 TEST_F(AssociatedInterfaceTest, AssociatedPtrFlushForTestingWithClosedPeer) {
-  MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
-
   AssociatedInterfaceRequest<IntegerSender> request;
   IntegerSenderAssociatedPtrInfo ptr_info;
-
-  router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-      AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
-  ptr_info = EmulatePassingAssociatedPtrInfo(std::move(ptr_info), router1);
+  CreateIntegerSender(&ptr_info, &request);
 
   AssociatedInterfacePtr<IntegerSender> ptr0;
   ptr0.Bind(std::move(ptr_info));
   bool called = false;
   ptr0.set_connection_error_handler(base::Bind(&SetBool, &called));
   request = nullptr;
 
   ptr0.FlushForTesting();
   EXPECT_TRUE(called);
   ptr0.FlushForTesting();
 }
 
 TEST_F(AssociatedInterfaceTest, AssociatedBindingFlushForTesting) {
-  MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
-
   AssociatedInterfaceRequest<IntegerSender> request;
   IntegerSenderAssociatedPtrInfo ptr_info;
-
-  router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-      AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
-  ptr_info = EmulatePassingAssociatedPtrInfo(std::move(ptr_info), router1);
+  CreateIntegerSender(&ptr_info, &request);
 
   IntegerSenderImpl impl0(std::move(request));
   impl0.set_connection_error_handler(base::Bind(&Fail));
   AssociatedInterfacePtr<IntegerSender> ptr0;
   ptr0.Bind(std::move(ptr_info));
 
   bool ptr0_callback_run = false;
   ptr0->Echo(123, ExpectValueSetFlagAndRunClosure(
                       123, &ptr0_callback_run, base::Bind(&base::DoNothing)));
   // Because the flush is sent from the binding, it only guarantees that the
   // request has been received, not the response. The second flush waits for the
   // response to be received.
   impl0.binding()->FlushForTesting();
   impl0.binding()->FlushForTesting();
   EXPECT_TRUE(ptr0_callback_run);
 }
 
 TEST_F(AssociatedInterfaceTest,
        AssociatedBindingFlushForTestingWithClosedPeer) {
-  MessagePipe pipe;
-  scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
-      true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
-  scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
-      false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
+  scoped_refptr<MultiplexRouter> router0;
+  scoped_refptr<MultiplexRouter> router1;
+  CreateRouterPair(&router0, &router1);
 
   AssociatedInterfaceRequest<IntegerSender> request;
   {
     IntegerSenderAssociatedPtrInfo ptr_info;
-
-    router0->CreateAssociatedGroup()->CreateAssociatedInterface(
-        AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
+    CreateIntegerSenderWithExistingRouters(router1, &ptr_info, router0,
+                                           &request);
   }
 
   IntegerSenderImpl impl(std::move(request));
   bool called = false;
   impl.set_connection_error_handler(base::Bind(&SetBool, &called));
   impl.binding()->FlushForTesting();
   EXPECT_TRUE(called);
   impl.binding()->FlushForTesting();
 }
 
@@ skipping 78 matching lines @@
   IntegerSenderConnectionPtr ptr;
   GetProxy(&ptr);
   bool called = false;
   ptr.set_connection_error_handler(base::Bind(&SetBool, &called));
   EXPECT_FALSE(called);
   ptr.FlushForTesting();
   EXPECT_TRUE(called);
   ptr.FlushForTesting();
 }
 
+TEST_F(AssociatedInterfaceTest, AssociatedBindingConnectionErrorWithReason) {
+  AssociatedInterfaceRequest<IntegerSender> request;
+  IntegerSenderAssociatedPtrInfo ptr_info;
+  CreateIntegerSender(&ptr_info, &request);
+
+  IntegerSenderImpl impl(std::move(request));
+  AssociatedInterfacePtr<IntegerSender> ptr;
+  ptr.Bind(std::move(ptr_info));
+
+  base::RunLoop run_loop;
+  impl.binding()->set_connection_error_with_reason_handler(base::Bind(
+      [](const base::Closure& quit_closure, uint32_t custom_reason,
+         const std::string& description) {
+        EXPECT_EQ(123u, custom_reason);
+        EXPECT_EQ("farewell", description);
+        quit_closure.Run();
+      },
+      run_loop.QuitClosure()));
+
+  ptr.ResetWithReason(123u, "farewell");
+
+  run_loop.Run();
+}
+
+TEST_F(AssociatedInterfaceTest, AssociatedPtrConnectionErrorWithReason) {
+  AssociatedInterfaceRequest<IntegerSender> request;
+  IntegerSenderAssociatedPtrInfo ptr_info;
+  CreateIntegerSender(&ptr_info, &request);
+
+  IntegerSenderImpl impl(std::move(request));
+  AssociatedInterfacePtr<IntegerSender> ptr;
+  ptr.Bind(std::move(ptr_info));
+
+  base::RunLoop run_loop;
+  ptr.set_connection_error_with_reason_handler(base::Bind(
+      [](const base::Closure& quit_closure, uint32_t custom_reason,
+         const std::string& description) {
+        EXPECT_EQ(456u, custom_reason);
+        EXPECT_EQ("farewell", description);
+        quit_closure.Run();
+      },
+      run_loop.QuitClosure()));
+
+  impl.binding()->CloseWithReason(456u, "farewell");
+
+  run_loop.Run();
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo