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

device/devices_app/usb/device_manager_impl_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 <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/core/device_client.h"
 #include "device/devices_app/usb/device_impl.h"
 #include "device/devices_app/usb/device_manager_impl.h"
 #include "device/devices_app/usb/public/cpp/device_manager_delegate.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "device/usb/mock_usb_service.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_request.h"
 
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace device {
 namespace usb {
 
 namespace {
 
@@ skipping 40 matching lines @@
         scoped_ptr<DeviceManagerDelegate>(new TestDeviceManagerDelegate),
         base::ThreadTaskRunnerHandle::Get());
     return device_manager.Pass();
   }
 
  private:
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<TestDeviceClient> device_client_;
 };
 
-// This is used this to watch a MessagePipe and run a given callback when the
-// pipe is closed.
-class PipeWatcher : public mojo::ErrorHandler {
- public:
-  PipeWatcher(const base::Closure& error_callback)
-      : error_callback_(error_callback) {}
-  ~PipeWatcher() override {}
-
- private:
-  // mojo::ErrorHandler:
-  void OnConnectionError() override { error_callback_.Run(); }
-
-  const base::Closure error_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(PipeWatcher);
-};
-
 class MockOpenCallback {
  public:
   explicit MockOpenCallback(UsbDevice* device) : device_(device) {}
 
   void Open(const UsbDevice::OpenCallback& callback) {
     device_handle_ = new MockUsbDeviceHandle(device_);
     callback.Run(device_handle_);
   }
 
   scoped_refptr<MockUsbDeviceHandle> mock_handle() { return device_handle_; }
@@ skipping 105 matching lines @@
   DCHECK(open_callback.mock_handle());
   EXPECT_CALL(*open_callback.mock_handle().get(), Close());
 
   DevicePtr bad_device;
   device_manager->OpenDevice(
       "not a real guid", mojo::GetProxy(&bad_device),
       base::Bind(&ExpectOpenDeviceError, OPEN_DEVICE_ERROR_NOT_FOUND));
 
   {
     base::RunLoop loop;
-    scoped_ptr<PipeWatcher> watcher(new PipeWatcher(loop.QuitClosure()));
-    bad_device.set_error_handler(watcher.get());
+    bad_device.set_connection_error_handler(loop.QuitClosure());
     bad_device->GetDeviceInfo(base::Bind(&FailOnGetDeviceInfoResponse));
     loop.Run();
   }
 }
 
 }  // namespace usb
 }  // namespace device