Convert all usages of mojo::ErrorHandler in //device/serial to callbacks.

device/serial/serial_connection_unittest.cc

 // Copyright 2014 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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "device/serial/data_receiver.h"
 #include "device/serial/data_sender.h"
 #include "device/serial/data_stream.mojom.h"
 #include "device/serial/serial.mojom.h"
 #include "device/serial/serial_connection.h"
 #include "device/serial/serial_service_impl.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_ptr.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 
 namespace device {
 namespace {
 
 class FakeSerialDeviceEnumerator : public SerialDeviceEnumerator {
   mojo::Array<serial::DeviceInfoPtr> GetDevices() override {
     mojo::Array<serial::DeviceInfoPtr> devices(1);
     devices[0] = serial::DeviceInfo::New();
     devices[0]->path = "device";
     return devices.Pass();
   }
 };
 
 }  // namespace
 
-class SerialConnectionTest : public testing::Test, public mojo::ErrorHandler {
+class SerialConnectionTest : public testing::Test {
  public:
   enum Event {
     EVENT_NONE,
     EVENT_GOT_INFO,
     EVENT_SET_OPTIONS,
     EVENT_GOT_CONTROL_SIGNALS,
     EVENT_SET_CONTROL_SIGNALS,
     EVENT_FLUSHED,
     EVENT_DATA_AT_IO_HANDLER,
     EVENT_DATA_SENT,
@@ skipping 17 matching lines @@
   void SetUp() override {
     message_loop_.reset(new base::MessageLoop);
     mojo::InterfacePtr<serial::SerialService> service;
     new SerialServiceImpl(
         new SerialConnectionFactory(
             base::Bind(&SerialConnectionTest::CreateIoHandler,
                        base::Unretained(this)),
             base::ThreadTaskRunnerHandle::Get()),
         scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator),
         mojo::GetProxy(&service));
-    service.set_error_handler(this);
+    service.set_connection_error_handler(base::Bind(
+        &SerialConnectionTest::OnConnectionError, base::Unretained(this)));
     mojo::InterfacePtr<serial::DataSink> sink;
     mojo::InterfacePtr<serial::DataSource> source;
     mojo::InterfacePtr<serial::DataSourceClient> source_client;
     mojo::InterfaceRequest<serial::DataSourceClient> source_client_request =
         mojo::GetProxy(&source_client);
     service->Connect("device", serial::ConnectionOptions::New(),
                      mojo::GetProxy(&connection_), mojo::GetProxy(&sink),
                      mojo::GetProxy(&source), source_client.Pass());
     sender_.reset(new DataSender(sink.Pass(), kBufferSize,
                                  serial::SEND_ERROR_DISCONNECTED));
     receiver_ =
         new DataReceiver(source.Pass(), source_client_request.Pass(),
                          kBufferSize, serial::RECEIVE_ERROR_DISCONNECTED);
-    connection_.set_error_handler(this);
+    connection_.set_connection_error_handler(base::Bind(
+        &SerialConnectionTest::OnConnectionError, base::Unretained(this)));
     connection_->GetInfo(
         base::Bind(&SerialConnectionTest::StoreInfo, base::Unretained(this)));
     WaitForEvent(EVENT_GOT_INFO);
     ASSERT_TRUE(io_handler_.get());
   }
 
   void StoreInfo(serial::ConnectionInfoPtr options) {
     info_ = options.Pass();
     EventReceived(EVENT_GOT_INFO);
   }
@@ skipping 62 matching lines @@
     buffer->Done(buffer->GetSize());
     receive_error_ = serial::RECEIVE_ERROR_NONE;
     EventReceived(EVENT_DATA_RECEIVED);
   }
 
   void OnReceiveError(int32_t error) {
     receive_error_ = static_cast<serial::ReceiveError>(error);
     EventReceived(EVENT_RECEIVE_ERROR);
   }
 
-  void OnConnectionError() override {
+  void OnConnectionError() {
     EventReceived(EVENT_ERROR);
     FAIL() << "Connection error";
   }
 
   mojo::Array<serial::DeviceInfoPtr> devices_;
   serial::ConnectionInfoPtr info_;
   serial::DeviceControlSignalsPtr signals_;
   bool connected_;
   bool success_;
   int bytes_sent_;
@@ skipping 141 matching lines @@
   WaitForEvent(EVENT_DATA_SENT);
   EXPECT_EQ(serial::SEND_ERROR_NONE, send_error_);
   EXPECT_EQ(4, bytes_sent_);
   ASSERT_NO_FATAL_FAILURE(Receive());
   WaitForEvent(EVENT_DATA_RECEIVED);
   EXPECT_EQ("data", data_received_);
   EXPECT_EQ(serial::RECEIVE_ERROR_NONE, receive_error_);
 }
 
 }  // namespace device