C++ bindings: support using a callback as connection error handler.

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 "mojo/public/cpp/bindings/binding.h"
-#include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/public/interfaces/bindings/tests/math_calculator.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 test {
 namespace {
 
-class ErrorObserver : public ErrorHandler {
- public:
-  ErrorObserver() : encountered_error_(false) {}
-
-  bool encountered_error() const { return encountered_error_; }
-
-  void OnConnectionError() override { encountered_error_ = true; }
-
- private:
-  bool encountered_error_;
-};
-
 template <typename Method, typename Class>
 class RunnableImpl {
  public:
   RunnableImpl(Method method, Class instance)
       : method_(method), instance_(instance) {}
   template <typename... Args>
   void Run(Args... args) const {
     (instance_->*method_)(args...);
   }
 
@@ skipping 271 matching lines @@
   PumpMessages();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 }
 
 TEST_F(InterfacePtrTest, EncounteredErrorCallback) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl calc_impl(GetProxy(&proxy));
 
-  ErrorObserver error_observer;
-  proxy.set_error_handler(&error_observer);
+  bool encountered_error = false;
+  proxy.set_connection_error_handler(
+      [&encountered_error]() { encountered_error = true; });
 
   MathCalculatorUI calculator_ui(proxy.Pass());
 
   calculator_ui.Add(2.0);
   PumpMessages();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0);
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
   calc_impl.CloseMessagePipe();
 
   // The state change isn't picked up locally yet.
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   PumpMessages();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 
-  // We should have also been able to observe the error through the
-  // ErrorHandler interface.
-  EXPECT_TRUE(error_observer.encountered_error());
+  // We should have also been able to observe the error through the error
+  // handler.
+  EXPECT_TRUE(encountered_error);
 }
 
 TEST_F(InterfacePtrTest, DestroyInterfacePtrOnMethodResponse) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl calc_impl(GetProxy(&proxy));
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
   SelfDestructingMathCalculatorUI* impl =
       new SelfDestructingMathCalculatorUI(proxy.Pass());
@@ skipping 73 matching lines @@
   ptr.RequireVersion(4u);
   // This value is set to the input of RequireVersion() synchronously.
   EXPECT_EQ(4u, ptr.version());
   ptr->SetInteger(789, sample::ENUM_VALUE);
   PumpMessages();
   EXPECT_TRUE(ptr.encountered_error());
   // The call to SetInteger() after RequireVersion(4u) is ignored.
   EXPECT_EQ(456, impl.integer());
 }
 
-class StrongMathCalculatorImpl : public math::Calculator, public ErrorHandler {
+class StrongMathCalculatorImpl : public math::Calculator {
  public:
   StrongMathCalculatorImpl(ScopedMessagePipeHandle handle,
                            bool* error_received,
                            bool* destroyed)
       : error_received_(error_received),
         destroyed_(destroyed),
         binding_(this, handle.Pass()) {
-    binding_.set_error_handler(this);
+    binding_.set_connection_error_handler(
+        [this]() { *error_received_ = true; });
   }
   ~StrongMathCalculatorImpl() override { *destroyed_ = true; }
 
   // math::Calculator implementation.
   void Clear(const CalcCallback& callback) override { 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_);
   }
 
-  // ErrorHandler implementation.
-  void OnConnectionError() override { *error_received_ = true; }
-
  private:
   double total_ = 0.0;
   bool* error_received_;
   bool* destroyed_;
 
   StrongBinding<math::Calculator> binding_;
 };
 
 TEST(StrongConnectorTest, Math) {
   Environment env;
@@ skipping 24 matching lines @@
   }
   // Destroying calculator_ui should close the pipe and generate an error on the
   // other
   // end which will destroy the instance since it is strongly bound.
 
   loop.RunUntilIdle();
   EXPECT_TRUE(error_received);
   EXPECT_TRUE(destroyed);
 }
 
-class WeakMathCalculatorImpl : public math::Calculator, public ErrorHandler {
+class WeakMathCalculatorImpl : public math::Calculator {
  public:
   WeakMathCalculatorImpl(ScopedMessagePipeHandle handle,
                          bool* error_received,
                          bool* destroyed)
       : error_received_(error_received),
         destroyed_(destroyed),
         binding_(this, handle.Pass()) {
-    binding_.set_error_handler(this);
+    binding_.set_connection_error_handler(
+        [this]() { *error_received_ = true; });
   }
   ~WeakMathCalculatorImpl() override { *destroyed_ = true; }
 
   void Clear(const CalcCallback& callback) override { 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_);
   }
 
-  // ErrorHandler implementation.
-  void OnConnectionError() override { *error_received_ = true; }
-
  private:
   double total_ = 0.0;
   bool* error_received_;
   bool* destroyed_;
 
   Binding<math::Calculator> binding_;
 };
 
 TEST(WeakConnectorTest, Math) {
   Environment env;
@@ skipping 26 matching lines @@
   }
 
   loop.RunUntilIdle();
   EXPECT_TRUE(error_received);
   EXPECT_FALSE(destroyed);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo