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

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.
 
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/utility/run_loop.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"
@@ skipping 23 matching lines @@
   ~IntegerAccessorImpl() override {}
 
  private:
   // sample::IntegerAccessor implementation.
   void GetInteger(const GetIntegerCallback& callback) override {
     callback.Run(1, sample::ENUM_VALUE);
   }
   void SetInteger(int64_t data, sample::Enum type) override {}
 };
 
-class RecordingErrorHandler : public ErrorHandler {
- public:
-  RecordingErrorHandler() : error_(false) {}
-  ~RecordingErrorHandler() override {}
-
-  bool encountered_error() const { return error_; }
-
- private:
-  // ErrorHandler implementation.
-  void OnConnectionError() override { error_ = true; }
-
-  bool error_;
-};
-
 class BindingTest : public testing::Test {
  public:
   BindingTest() {}
   ~BindingTest() override {}
 
  protected:
-  RecordingErrorHandler handler_;
   Environment env_;
   RunLoop loop_;
 };
 
 // Tests that destroying a mojo::Binding closes the bound message pipe handle.
 TEST_F(BindingTest, DestroyClosesMessagePipe) {
+  bool encountered_error = false;
   ServiceImpl impl;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
-  ptr.set_error_handler(&handler_);
+  ptr.set_connection_error_handler(
+      [&encountered_error]() { encountered_error = true; });
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   {
     Binding<sample::Service> binding(&impl, request.Pass());
     ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                    called_cb);
     loop_.RunUntilIdle();
     EXPECT_TRUE(called);
-    EXPECT_FALSE(handler_.encountered_error());
+    EXPECT_FALSE(encountered_error);
   }
   // Now that the Binding is out of scope we should detect an error on the other
   // end of the pipe.
   loop_.RunUntilIdle();
-  EXPECT_TRUE(handler_.encountered_error());
+  EXPECT_TRUE(encountered_error);
 
   // And calls should fail.
   called = false;
   ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                  called_cb);
   loop_.RunUntilIdle();
   EXPECT_FALSE(called);
 }
 
 // Tests that explicitly calling Unbind followed by rebinding works.
@@ skipping 30 matching lines @@
 
 TEST_F(BindingTest, SetInterfacePtrVersion) {
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
   Binding<sample::IntegerAccessor> binding(&impl, &ptr);
   EXPECT_EQ(3u, ptr.version());
 }
 
 }  // namespace
 }  // mojo