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

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

 // Copyright 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 11 matching lines @@
 namespace {
 
 typedef base::Callback<void(double)> CalcCallback;
 
 class MathCalculatorImpl : public math::Calculator {
  public:
   explicit MathCalculatorImpl(InterfaceRequest<math::Calculator> request)
       : total_(0.0), binding_(this, std::move(request)) {}
   ~MathCalculatorImpl() override {}
 
-  void CloseMessagePipe() { binding_.Close(); }
-
-  void WaitForIncomingMethodCall() { binding_.WaitForIncomingMethodCall(); }
-
   void Clear(const CalcCallback& callback) override {
     total_ = 0.0;
     callback.Run(total_);
   }
 
   void Add(double value, const CalcCallback& callback) override {
     total_ += value;
     callback.Run(total_);
   }
 
   void Multiply(double value, const CalcCallback& callback) override {
     total_ *= value;
     callback.Run(total_);
   }
 
+  Binding<math::Calculator>* binding() { return &binding_; }
+
  private:
   double total_;
   Binding<math::Calculator> binding_;
 };
 
 class MathCalculatorUI {
  public:
   explicit MathCalculatorUI(math::CalculatorPtr calculator)
       : calculator_(std::move(calculator)),
         output_(0.0) {}
@@ skipping 184 matching lines @@
   MathCalculatorImpl calc_impl(GetProxy(&calc));
 
   // Suppose this is instantiated in a process that has pipe1_.
   MathCalculatorUI calculator_ui(std::move(calc));
 
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
 
   base::RunLoop run_loop;
   calculator_ui.Add(2.0, run_loop.QuitClosure());
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
-  calc_impl.WaitForIncomingMethodCall();
+  calc_impl.binding()->WaitForIncomingMethodCall();
   run_loop.Run();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
 
   base::RunLoop run_loop2;
   calculator_ui.Multiply(5.0, run_loop2.QuitClosure());
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
-  calc_impl.WaitForIncomingMethodCall();
+  calc_impl.binding()->WaitForIncomingMethodCall();
   run_loop2.Run();
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(InterfacePtrTest, Movable) {
   math::CalculatorPtr a;
   math::CalculatorPtr b;
   MathCalculatorImpl calc_impl(GetProxy(&b));
 
   EXPECT_TRUE(!a);
@@ skipping 48 matching lines @@
   base::RunLoop run_loop;
   calculator_ui.Add(2.0, run_loop.QuitClosure());
   run_loop.Run();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0, base::Closure());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
-  calc_impl.CloseMessagePipe();
+  calc_impl.binding()->Close();
 
   // The state change isn't picked up locally yet.
   base::RunLoop run_loop2;
   calculator_ui.set_connection_error_handler(run_loop2.QuitClosure());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   run_loop2.Run();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
@@ skipping 14 matching lines @@
   base::RunLoop run_loop2;
   calculator_ui.Add(2.0, run_loop2.QuitClosure());
   run_loop2.Run();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0, base::Closure());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
-  calc_impl.CloseMessagePipe();
+  calc_impl.binding()->Close();
 
   // The state change isn't picked up locally yet.
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   run_loop.Run();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 
   // We should have also been able to observe the error through the error
@@ skipping 370 matching lines @@
 TEST_F(InterfacePtrTest, FlushForTestingWithClosedPeer) {
   math::CalculatorPtr calc;
   GetProxy(&calc);
   bool called = false;
   calc.set_connection_error_handler(base::Bind(&SetBool, &called));
   calc.FlushForTesting();
   EXPECT_TRUE(called);
   calc.FlushForTesting();
 }
 
+TEST_F(InterfacePtrTest, ConnectionErrorWithReason) {
+  math::CalculatorPtr calc;
+  MathCalculatorImpl calc_impl(GetProxy(&calc));
+
+  base::RunLoop run_loop;
+  calc.set_connection_error_with_reason_handler(base::Bind(
+      [](const base::Closure& quit_closure, uint32_t custom_reason,
+         const std::string& description) {
+        EXPECT_EQ(42u, custom_reason);
+        EXPECT_EQ("hey", description);
+        quit_closure.Run();
+      },
+      run_loop.QuitClosure()));
+
+  calc_impl.binding()->CloseWithReason(42u, "hey");
+
+  run_loop.Run();
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo