Remove //device/devices_app.

This change removes the code to create a Mojo app containing device
services (currently only USB) and instead makes the Mojo bindings for
//device/usb part of that directory.

The Mojo service implementation is still in a separate //device/usb/mojo
target but this will eventually merge into its parent directory as the
Mojo interface becomes the only public interface for //device/usb.

BUG=None

Review URL: https://codereview.chromium.org/1682363002

Cr-Commit-Position: refs/heads/master@{#374778}

28 files changed, 0 insertions, 3456 deletions

diff --git a/device/devices_app/BUILD.gn b/device/devices_app/BUILD.gn
deleted file mode 100644
index f189e6b..0000000
--- a/device/devices_app/BUILD.gn
+++ /dev/null
@@ -1,77 +0,0 @@
-# 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.
-
-import("//mojo/public/mojo_application.gni")
-
-source_set("lib") {
-  sources = [
-    "devices_app.cc",
-    "devices_app.h",
-    "usb/device_impl.cc",
-    "usb/device_impl.h",
-    "usb/device_manager_impl.cc",
-    "usb/device_manager_impl.h",
-    "usb/type_converters.cc",
-    "usb/type_converters.h",
-  ]
-
-  deps = [
-    "//device/core",
-    "//device/devices_app/usb/public/interfaces",
-    "//device/usb",
-    "//mojo/common",
-    "//mojo/public/cpp/bindings",
-    "//mojo/public/cpp/bindings:callback",
-    "//net",
-    "//url",
-  ]
-
-  public_deps = [
-    "//base",
-    "//mojo/shell/public/cpp",
-    "//mojo/shell/public/interfaces",
-  ]
-}
-
-if (!is_component_build) {
-  mojo_native_application("devices") {
-    sources = [
-      "main.cc",
-    ]
-
-    deps = [
-      "//base",
-      "//device/devices_app/public/cpp:factory",
-      "//mojo/shell/public/cpp",
-    ]
-
-    public_deps = [
-      ":lib",
-    ]
-  }
-
-  mojo_native_application("apptests") {
-    output_name = "devices_apptests"
-
-    testonly = true
-
-    sources = [
-      "devices_apptest.cc",
-    ]
-
-    deps = [
-      "//base",
-      "//mojo/shell/public/cpp:test_support",
-    ]
-
-    public_deps = [
-      ":lib",
-      "//device/devices_app/usb/public/interfaces",
-    ]
-
-    data_deps = [
-      ":devices",
-    ]
-  }
-}
diff --git a/device/devices_app/DEPS b/device/devices_app/DEPS
deleted file mode 100644
index 7256f77..0000000
--- a/device/devices_app/DEPS
+++ /dev/null
@@ -1,4 +0,0 @@
-include_rules = [
-  "+mojo/shell/public",
-  "+mojo/common",
-]
diff --git a/device/devices_app/OWNERS b/device/devices_app/OWNERS
deleted file mode 100644
index b16946a..0000000
--- a/device/devices_app/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-reillyg@chromium.org
-rockot@chromium.org
diff --git a/device/devices_app/devices_app.cc b/device/devices_app/devices_app.cc
deleted file mode 100644
index 8bb9ab9..0000000
--- a/device/devices_app/devices_app.cc
+++ /dev/null
@@ -1,139 +0,0 @@
-// 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 "device/devices_app/devices_app.h"
-
-#include <stdint.h>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/sequenced_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/threading/thread.h"
-#include "base/time/time.h"
-#include "device/core/device_client.h"
-#include "device/devices_app/usb/device_manager_impl.h"
-#include "device/usb/usb_service.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "mojo/shell/public/cpp/connection.h"
-#include "mojo/shell/public/cpp/shell.h"
-#include "url/gurl.h"
-
-namespace device {
-
-namespace {
-
-// The number of seconds to wait without any bound DeviceManagers before
-// exiting the app.
-const int64_t kIdleTimeoutInSeconds = 10;
-
-// A DeviceClient implementation to be constructed iff the app is not running
-// in an embedder that provides a DeviceClient (i.e. running as a standalone
-// Mojo app, not in Chrome).
-class AppDeviceClient : public DeviceClient {
- public:
-  explicit AppDeviceClient(
-      scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-      : blocking_task_runner_(blocking_task_runner) {}
-  ~AppDeviceClient() override {}
-
- private:
-  // DeviceClient:
-  UsbService* GetUsbService() override {
-    if (!usb_service_) {
-      usb_service_ = UsbService::Create(blocking_task_runner_);
-    }
-    return usb_service_.get();
-  }
-
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
-  scoped_ptr<UsbService> usb_service_;
-};
-
-}  // namespace
-
-// This class insures that a UsbService has been initialized and is accessible
-// via the DeviceClient interface.
-class DevicesApp::USBServiceInitializer {
- public:
-  USBServiceInitializer()
-      : blocking_thread_("USB service blocking I/O thread") {
-    blocking_thread_.Start();
-    app_device_client_.reset(
-        new AppDeviceClient(blocking_thread_.task_runner()));
-  }
-
-  ~USBServiceInitializer() {}
-
- private:
-  scoped_ptr<AppDeviceClient> app_device_client_;
-  base::Thread blocking_thread_;
-
-  DISALLOW_COPY_AND_ASSIGN(USBServiceInitializer);
-};
-
-DevicesApp::DevicesApp() : shell_(nullptr), active_device_manager_count_(0) {}
-
-DevicesApp::~DevicesApp() {
-}
-
-void DevicesApp::Initialize(mojo::Shell* shell,
-                            const std::string& url,
-                            uint32_t id) {
-  shell_ = shell;
-  service_initializer_.reset(new USBServiceInitializer);
-  StartIdleTimer();
-}
-
-bool DevicesApp::AcceptConnection(mojo::Connection* connection) {
-  connection->AddInterface<usb::DeviceManager>(this);
-  return true;
-}
-
-void DevicesApp::Quit() {
-  service_initializer_.reset();
-  shell_ = nullptr;
-}
-
-void DevicesApp::Create(mojo::Connection* connection,
-                        mojo::InterfaceRequest<usb::DeviceManager> request) {
-  // Bind the new device manager to the connecting application's permission
-  // provider.
-  usb::PermissionProviderPtr permission_provider;
-  connection->GetInterface(&permission_provider);
-
-  // Owned by its message pipe.
-  usb::DeviceManagerImpl* device_manager = new usb::DeviceManagerImpl(
-      std::move(permission_provider), std::move(request));
-  device_manager->set_connection_error_handler(
-      base::Bind(&DevicesApp::OnConnectionError, base::Unretained(this)));
-
-  active_device_manager_count_++;
-  idle_timeout_callback_.Cancel();
-}
-
-void DevicesApp::OnConnectionError() {
-  DCHECK_GE(active_device_manager_count_, 0u);
-  active_device_manager_count_--;
-  if (active_device_manager_count_ == 0) {
-    // If the last DeviceManager connection has been dropped, kick off an idle
-    // timeout to shut ourselves down.
-    StartIdleTimer();
-  }
-}
-
-void DevicesApp::StartIdleTimer() {
-  // Passing unretained |shell_| is safe here because |shell_| is
-  // guaranteed to outlive |this|, and the callback is canceled if |this| is
-  // destroyed.
-  idle_timeout_callback_.Reset(
-      base::Bind(&mojo::Shell::Quit, base::Unretained(shell_)));
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, idle_timeout_callback_.callback(),
-      base::TimeDelta::FromSeconds(kIdleTimeoutInSeconds));
-}
-
-}  // namespace device
diff --git a/device/devices_app/devices_app.gyp b/device/devices_app/devices_app.gyp
deleted file mode 100644
index 6027a85..0000000
--- a/device/devices_app/devices_app.gyp
+++ /dev/null
@@ -1,85 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    'chromium_code': 1,
-  },
-  'targets': [
-    {
-      'target_name': 'devices_app_lib',
-      'type': 'static_library',
-      'include_dirs': [
-        '../..',
-      ],
-      'sources': [
-        'devices_app.cc',
-        'devices_app.h',
-        'usb/device_impl.cc',
-        'usb/device_impl.h',
-        'usb/device_manager_impl.cc',
-        'usb/device_manager_impl.h',
-        'usb/type_converters.cc',
-        'usb/type_converters.h',
-      ],
-      'dependencies': [
-        'device_usb_mojo_bindings_lib',
-        '<(DEPTH)/device/core/core.gyp:device_core',
-        '<(DEPTH)/device/usb/usb.gyp:device_usb',
-        '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_base',
-        '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_bindings',
-        '<(DEPTH)/mojo/mojo_base.gyp:mojo_url_type_converters',
-        '<(DEPTH)/mojo/mojo_public.gyp:mojo_cpp_bindings',
-      ],
-      'export_dependent_settings': [
-        '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_base',
-        '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_bindings',
-        '<(DEPTH)/mojo/mojo_public.gyp:mojo_cpp_bindings',
-      ],
-    },
-    {
-      'target_name': 'device_usb_mojo_bindings',
-      'type': 'none',
-      'variables': {
-        'mojom_files': [
-          'usb/public/interfaces/device.mojom',
-          'usb/public/interfaces/device_manager.mojom',
-          'usb/public/interfaces/permission_provider.mojom',
-        ],
-      },
-      'includes': [
-        '../../mojo/mojom_bindings_generator_explicit.gypi',
-      ],
-    },
-    {
-      'target_name': 'device_usb_mojo_bindings_lib',
-      'type': 'static_library',
-      'dependencies': [
-        'device_usb_mojo_bindings',
-      ],
-    },
-    {
-      'target_name': 'devices_app_public_cpp',
-      'type': 'static_library',
-      'sources': [
-        'public/cpp/constants.cc',
-        'public/cpp/constants.h',
-      ],
-      'dependencies': [
-        'devices_app_lib',
-      ],
-    },
-    {
-      'target_name': 'devices_app_public_cpp_factory',
-      'type': 'static_library',
-      'sources': [
-        'public/cpp/devices_app_factory.cc',
-        'public/cpp/devices_app_factory.h',
-      ],
-      'dependencies': [
-        'devices_app_lib',
-      ],
-    },
-  ],
-}
diff --git a/device/devices_app/devices_app.h b/device/devices_app/devices_app.h
deleted file mode 100644
index 0fecb42..0000000
--- a/device/devices_app/devices_app.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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.
-
-#ifndef DEVICE_DEVICES_DEVICES_APP_H_
-#define DEVICE_DEVICES_DEVICES_APP_H_
-
-#include <stddef.h>
-
-#include "base/cancelable_callback.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "mojo/shell/public/cpp/interface_factory.h"
-#include "mojo/shell/public/cpp/shell_client.h"
-
-namespace mojo {
-class Shell;
-}
-
-namespace device {
-
-namespace usb {
-class DeviceManager;
-}
-
-class DevicesApp : public mojo::ShellClient,
-                   public mojo::InterfaceFactory<usb::DeviceManager> {
- public:
-  DevicesApp();
-  ~DevicesApp() override;
-
- private:
-  class USBServiceInitializer;
-
-  // mojo::ShellClient:
-  void Initialize(mojo::Shell* shell,
-                  const std::string& url,
-                  uint32_t id) override;
-  bool AcceptConnection(mojo::Connection* connection) override;
-  void Quit() override;
-
-  // mojo::InterfaceFactory<usb::DeviceManager>:
-  void Create(mojo::Connection* connection,
-              mojo::InterfaceRequest<usb::DeviceManager> request) override;
-
-  // Mojo error handler to track device manager count.
-  void OnConnectionError();
-
-  // Sets the app for destruction after a period of idle time. If any top-level
-  // services (e.g. usb::DeviceManager) are bound before the timeout elapses,
-  // it's canceled.
-  void StartIdleTimer();
-
-  mojo::Shell* shell_;
-  scoped_ptr<USBServiceInitializer> service_initializer_;
-  size_t active_device_manager_count_;
-
-  // Callback used to shut down the app after a period of inactivity.
-  base::CancelableClosure idle_timeout_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevicesApp);
-};
-
-}  // naespace device
-
-#endif  // DEVICE_DEVICES_DEVICES_APP_H_
diff --git a/device/devices_app/devices_apptest.cc b/device/devices_app/devices_apptest.cc
deleted file mode 100644
index 1ac56ae..0000000
--- a/device/devices_app/devices_apptest.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// 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 <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/run_loop.h"
-#include "device/devices_app/devices_app.h"
-#include "device/devices_app/usb/public/interfaces/device_manager.mojom.h"
-#include "mojo/shell/public/cpp/application_test_base.h"
-
-namespace device {
-namespace {
-
-class DevicesAppTest : public mojo::test::ApplicationTestBase {
- public:
-  DevicesAppTest() {}
-  ~DevicesAppTest() override {}
-
-  void SetUp() override {
-    ApplicationTestBase::SetUp();
-    shell()->ConnectToInterface("mojo:devices", &usb_device_manager_);
-  }
-
-  usb::DeviceManager* usb_device_manager() { return usb_device_manager_.get(); }
-
- private:
-  usb::DeviceManagerPtr usb_device_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevicesAppTest);
-};
-
-void OnGetDevices(const base::Closure& continuation,
-                  mojo::Array<usb::DeviceInfoPtr> devices) {
-  continuation.Run();
-}
-
-}  // namespace
-
-// Simple test to verify that we can connect to the USB DeviceManager and get
-// a response.
-TEST_F(DevicesAppTest, GetUSBDevices) {
-  base::RunLoop loop;
-  usb::EnumerationOptionsPtr options = usb::EnumerationOptions::New();
-  options->filters = mojo::Array<usb::DeviceFilterPtr>(1);
-  options->filters[0] = usb::DeviceFilter::New();
-  usb_device_manager()->GetDevices(
-      std::move(options), base::Bind(&OnGetDevices, loop.QuitClosure()));
-  loop.Run();
-}
-
-}  // namespace device
diff --git a/device/devices_app/main.cc b/device/devices_app/main.cc
deleted file mode 100644
index 1694aac..0000000
--- a/device/devices_app/main.cc
+++ /dev/null
@@ -1,15 +0,0 @@
-// 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 "base/sequenced_task_runner.h"
-#include "device/devices_app/public/cpp/devices_app_factory.h"
-#include "mojo/public/c/system/main.h"
-#include "mojo/shell/public/cpp/application_runner.h"
-#include "mojo/shell/public/cpp/shell_client.h"
-
-MojoResult MojoMain(MojoHandle shell_handle) {
-  mojo::ApplicationRunner runner(
-      device::DevicesAppFactory::CreateApp().release());
-  return runner.Run(shell_handle);
-}
diff --git a/device/devices_app/public/cpp/BUILD.gn b/device/devices_app/public/cpp/BUILD.gn
deleted file mode 100644
index 301d20f..0000000
--- a/device/devices_app/public/cpp/BUILD.gn
+++ /dev/null
@@ -1,29 +0,0 @@
-# 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.
-
-source_set("cpp") {
-  sources = [
-    "constants.cc",
-    "constants.h",
-  ]
-
-  public_deps = [
-    "//base",
-  ]
-}
-
-source_set("factory") {
-  sources = [
-    "devices_app_factory.cc",
-    "devices_app_factory.h",
-  ]
-
-  deps = [
-    "//device/devices_app:lib",
-  ]
-
-  public_deps = [
-    "//base",
-  ]
-}
diff --git a/device/devices_app/public/cpp/constants.cc b/device/devices_app/public/cpp/constants.cc
deleted file mode 100644
index 3bf4e01..0000000
--- a/device/devices_app/public/cpp/constants.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-// 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 "device/devices_app/public/cpp/constants.h"
-
-namespace device {
-
-const char kDevicesMojoAppUrl[] = "mojo:devices";
-
-}  // namespace device
diff --git a/device/devices_app/public/cpp/constants.h b/device/devices_app/public/cpp/constants.h
deleted file mode 100644
index dfe242a..0000000
--- a/device/devices_app/public/cpp/constants.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// 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.
-
-#ifndef DEVICE_DEVICES_APP_PUBLIC_CPP_CONSTANTS_H_
-#define DEVICE_DEVICES_APP_PUBLIC_CPP_CONSTANTS_H_
-
-namespace device {
-
-extern const char kDevicesMojoAppUrl[];
-
-}  // namespace device
-
-#endif  // DEVICE_DEVICES_APP_PUBLIC_CPP_CONSTANTS_H_
diff --git a/device/devices_app/public/cpp/devices_app_factory.cc b/device/devices_app/public/cpp/devices_app_factory.cc
deleted file mode 100644
index 154f67c..0000000
--- a/device/devices_app/public/cpp/devices_app_factory.cc
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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 "device/devices_app/public/cpp/devices_app_factory.h"
-
-#include "device/devices_app/devices_app.h"
-
-namespace device {
-
-// static
-scoped_ptr<mojo::ShellClient> DevicesAppFactory::CreateApp() {
-  return scoped_ptr<mojo::ShellClient>(new DevicesApp());
-}
-
-}  // namespace device
diff --git a/device/devices_app/public/cpp/devices_app_factory.h b/device/devices_app/public/cpp/devices_app_factory.h
deleted file mode 100644
index 6ba7447..0000000
--- a/device/devices_app/public/cpp/devices_app_factory.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// 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.
-
-#ifndef DEVICE_DEVICES_APP_PUBLIC_CPP_DEVICES_APP_FACTORY_H_
-#define DEVICE_DEVICES_APP_PUBLIC_CPP_DEVICES_APP_FACTORY_H_
-
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-
-namespace mojo {
-class ShellClient;
-}
-
-namespace device {
-
-// Public factory for creating new instances of the devices app.
-class DevicesAppFactory {
- public:
-  // Creates a DevicesApp delegate which can be used to launch a new instance
-  // of the devices app on a mojo application runner. The caller owns the
-  // delegate.
-  static scoped_ptr<mojo::ShellClient> CreateApp();
-};
-
-}  // namespace device
-
-#endif  // DEVICE_DEVICES_APP_PUBLIC_CPP_DEVICES_APP_FACTORY_H_
diff --git a/device/devices_app/usb/DEPS b/device/devices_app/usb/DEPS
deleted file mode 100644
index 134e14a..0000000
--- a/device/devices_app/usb/DEPS
+++ /dev/null
@@ -1,4 +0,0 @@
-include_rules = [
-  "-net",
-  "+net/base",
-]
diff --git a/device/devices_app/usb/device_impl.cc b/device/devices_app/usb/device_impl.cc
deleted file mode 100644
index 2eb3ed5..0000000
--- a/device/devices_app/usb/device_impl.cc
+++ /dev/null
@@ -1,464 +0,0 @@
-// 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 "device/devices_app/usb/device_impl.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <numeric>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/stl_util.h"
-#include "device/devices_app/usb/type_converters.h"
-#include "device/usb/usb_descriptors.h"
-#include "device/usb/usb_device.h"
-#include "net/base/io_buffer.h"
-
-namespace device {
-namespace usb {
-
-namespace {
-
-using MojoTransferInCallback =
-    mojo::Callback<void(TransferStatus, mojo::Array<uint8_t>)>;
-
-using MojoTransferOutCallback = mojo::Callback<void(TransferStatus)>;
-
-template <typename... Args>
-void CallMojoCallback(scoped_ptr<mojo::Callback<void(Args...)>> callback,
-                      Args... args) {
-  callback->Run(args...);
-}
-
-// Generic wrapper to convert a Mojo callback to something we can rebind and
-// pass around. This is only usable for callbacks with no move-only arguments.
-template <typename... Args>
-base::Callback<void(Args...)> WrapMojoCallback(
-    const mojo::Callback<void(Args...)>& callback) {
-  // mojo::Callback is not thread safe. By wrapping |callback| in a scoped_ptr
-  // we guarantee that it will be freed when CallMojoCallback is run and not
-  // retained until the base::Callback is destroyed, which could happen on any
-  // thread. This pattern is also used below in places where this generic
-  // wrapper is not used.
-  auto callback_ptr =
-      make_scoped_ptr(new mojo::Callback<void(Args...)>(callback));
-  return base::Bind(&CallMojoCallback<Args...>, base::Passed(&callback_ptr));
-}
-
-void OnPermissionCheckComplete(
-    const base::Callback<void(bool)>& callback,
-    const base::Callback<void(const base::Callback<void(bool)>&)>& action,
-    bool allowed) {
-  if (allowed)
-    action.Run(callback);
-  else
-    callback.Run(false);
-}
-
-scoped_refptr<net::IOBuffer> CreateTransferBuffer(size_t size) {
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(
-      std::max(static_cast<size_t>(1u), static_cast<size_t>(size)));
-  return buffer;
-}
-
-void OnTransferIn(scoped_ptr<MojoTransferInCallback> callback,
-                  UsbTransferStatus status,
-                  scoped_refptr<net::IOBuffer> buffer,
-                  size_t buffer_size) {
-  mojo::Array<uint8_t> data;
-  if (buffer) {
-    // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a
-    // std::vector<uint8_t> instead of net::IOBuffer. Then we could move
-    // instead of copy.
-    std::vector<uint8_t> bytes(buffer_size);
-    std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin());
-    data.Swap(&bytes);
-  }
-  callback->Run(mojo::ConvertTo<TransferStatus>(status), std::move(data));
-}
-
-void OnControlTransferInPermissionCheckComplete(
-    scoped_refptr<UsbDeviceHandle> device_handle,
-    ControlTransferParamsPtr params,
-    int length,
-    int timeout,
-    scoped_ptr<Device::ControlTransferInCallback> callback,
-    bool allowed) {
-  if (allowed) {
-    scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
-    device_handle->ControlTransfer(
-        USB_DIRECTION_INBOUND,
-        mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
-        mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
-        params->request, params->value, params->index, buffer, length, timeout,
-        base::Bind(&OnTransferIn, base::Passed(&callback)));
-  } else {
-    mojo::Array<uint8_t> data;
-    callback->Run(TransferStatus::PERMISSION_DENIED, std::move(data));
-  }
-}
-
-void OnTransferOut(scoped_ptr<MojoTransferOutCallback> callback,
-                   UsbTransferStatus status,
-                   scoped_refptr<net::IOBuffer> buffer,
-                   size_t buffer_size) {
-  callback->Run(mojo::ConvertTo<TransferStatus>(status));
-}
-
-void OnControlTransferOutPermissionCheckComplete(
-    scoped_refptr<UsbDeviceHandle> device_handle,
-    ControlTransferParamsPtr params,
-    mojo::Array<uint8_t> data,
-    int timeout,
-    scoped_ptr<Device::ControlTransferOutCallback> callback,
-    bool allowed) {
-  if (allowed) {
-    scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
-    const std::vector<uint8_t>& storage = data.storage();
-    std::copy(storage.begin(), storage.end(), buffer->data());
-    device_handle->ControlTransfer(
-        USB_DIRECTION_OUTBOUND,
-        mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
-        mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
-        params->request, params->value, params->index, buffer, data.size(),
-        timeout, base::Bind(&OnTransferOut, base::Passed(&callback)));
-  } else {
-    callback->Run(TransferStatus::PERMISSION_DENIED);
-  }
-}
-
-mojo::Array<IsochronousPacketPtr> BuildIsochronousPacketArray(
-    mojo::Array<uint32_t> packet_lengths,
-    TransferStatus status) {
-  mojo::Array<IsochronousPacketPtr> packets(packet_lengths.size());
-  for (size_t i = 0; i < packet_lengths.size(); ++i) {
-    packets[i] = IsochronousPacket::New();
-    packets[i]->length = packet_lengths[i];
-    packets[i]->status = status;
-  }
-  return packets;
-}
-
-void OnIsochronousTransferIn(
-    scoped_ptr<Device::IsochronousTransferInCallback> callback,
-    scoped_refptr<net::IOBuffer> buffer,
-    const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
-  mojo::Array<uint8_t> data;
-  if (buffer) {
-    // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a
-    // std::vector<uint8_t> instead of net::IOBuffer. Then we could move
-    // instead of copy.
-    uint32_t buffer_size =
-        std::accumulate(packets.begin(), packets.end(), 0u,
-                        [](const uint32_t& a,
-                           const UsbDeviceHandle::IsochronousPacket& packet) {
-                          return a + packet.length;
-                        });
-    std::vector<uint8_t> bytes(buffer_size);
-    std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin());
-    data.Swap(&bytes);
-  }
-  callback->Run(std::move(data),
-                mojo::Array<IsochronousPacketPtr>::From(packets));
-}
-
-void OnIsochronousTransferOut(
-    scoped_ptr<Device::IsochronousTransferOutCallback> callback,
-    scoped_refptr<net::IOBuffer> buffer,
-    const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
-  callback->Run(mojo::Array<IsochronousPacketPtr>::From(packets));
-}
-
-}  // namespace
-
-DeviceImpl::DeviceImpl(scoped_refptr<UsbDevice> device,
-                       PermissionProviderPtr permission_provider,
-                       mojo::InterfaceRequest<Device> request)
-    : binding_(this, std::move(request)),
-      device_(device),
-      permission_provider_(std::move(permission_provider)),
-      weak_factory_(this) {
-  // This object owns itself and will be destroyed if either the message pipe
-  // it is bound to is closed or the PermissionProvider it depends on is
-  // unavailable.
-  binding_.set_connection_error_handler([this]() { delete this; });
-  permission_provider_.set_connection_error_handler([this]() { delete this; });
-}
-
-DeviceImpl::~DeviceImpl() {
-  CloseHandle();
-}
-
-void DeviceImpl::CloseHandle() {
-  if (device_handle_)
-    device_handle_->Close();
-  device_handle_ = nullptr;
-}
-
-void DeviceImpl::HasControlTransferPermission(
-    ControlTransferRecipient recipient,
-    uint16_t index,
-    const base::Callback<void(bool)>& callback) {
-  DCHECK(device_handle_);
-  const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
-
-  if (recipient == ControlTransferRecipient::INTERFACE ||
-      recipient == ControlTransferRecipient::ENDPOINT) {
-    if (!config) {
-      callback.Run(false);
-      return;
-    }
-
-    uint8_t interface_number = index & 0xff;
-    if (recipient == ControlTransferRecipient::ENDPOINT) {
-      if (!device_handle_->FindInterfaceByEndpoint(index & 0xff,
-                                                   &interface_number)) {
-        callback.Run(false);
-        return;
-      }
-    }
-
-    permission_provider_->HasInterfacePermission(
-        interface_number, config->configuration_value,
-        DeviceInfo::From(*device_), callback);
-  } else if (config) {
-    permission_provider_->HasConfigurationPermission(
-        config->configuration_value, DeviceInfo::From(*device_), callback);
-  } else {
-    // Client must already have device permission to have gotten this far.
-    callback.Run(true);
-  }
-}
-
-void DeviceImpl::OnOpen(const OpenCallback& callback,
-                        scoped_refptr<UsbDeviceHandle> handle) {
-  device_handle_ = handle;
-  callback.Run(handle ? OpenDeviceError::OK : OpenDeviceError::ACCESS_DENIED);
-}
-
-void DeviceImpl::GetDeviceInfo(const GetDeviceInfoCallback& callback) {
-  callback.Run(DeviceInfo::From(*device_));
-}
-
-void DeviceImpl::GetConfiguration(const GetConfigurationCallback& callback) {
-  const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
-  callback.Run(config ? config->configuration_value : 0);
-}
-
-void DeviceImpl::Open(const OpenCallback& callback) {
-  device_->Open(
-      base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback));
-}
-
-void DeviceImpl::Close(const CloseCallback& callback) {
-  CloseHandle();
-  callback.Run();
-}
-
-void DeviceImpl::SetConfiguration(uint8_t value,
-                                  const SetConfigurationCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(false);
-    return;
-  }
-
-  auto set_configuration =
-      base::Bind(&UsbDeviceHandle::SetConfiguration, device_handle_, value);
-  permission_provider_->HasConfigurationPermission(
-      value, DeviceInfo::From(*device_),
-      base::Bind(&OnPermissionCheckComplete, WrapMojoCallback(callback),
-                 set_configuration));
-}
-
-void DeviceImpl::ClaimInterface(uint8_t interface_number,
-                                const ClaimInterfaceCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(false);
-    return;
-  }
-
-  const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
-  if (!config) {
-    callback.Run(false);
-    return;
-  }
-
-  auto claim_interface = base::Bind(&UsbDeviceHandle::ClaimInterface,
-                                    device_handle_, interface_number);
-  permission_provider_->HasInterfacePermission(
-      interface_number, config->configuration_value, DeviceInfo::From(*device_),
-      base::Bind(&OnPermissionCheckComplete, WrapMojoCallback(callback),
-                 claim_interface));
-}
-
-void DeviceImpl::ReleaseInterface(uint8_t interface_number,
-                                  const ReleaseInterfaceCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(false);
-    return;
-  }
-
-  device_handle_->ReleaseInterface(interface_number,
-                                   WrapMojoCallback(callback));
-}
-
-void DeviceImpl::SetInterfaceAlternateSetting(
-    uint8_t interface_number,
-    uint8_t alternate_setting,
-    const SetInterfaceAlternateSettingCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(false);
-    return;
-  }
-
-  device_handle_->SetInterfaceAlternateSetting(
-      interface_number, alternate_setting, WrapMojoCallback(callback));
-}
-
-void DeviceImpl::Reset(const ResetCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(false);
-    return;
-  }
-
-  device_handle_->ResetDevice(WrapMojoCallback(callback));
-}
-
-void DeviceImpl::ClearHalt(uint8_t endpoint,
-                           const ClearHaltCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(false);
-    return;
-  }
-
-  device_handle_->ClearHalt(endpoint, WrapMojoCallback(callback));
-}
-
-void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params,
-                                   uint32_t length,
-                                   uint32_t timeout,
-                                   const ControlTransferInCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
-    return;
-  }
-
-  auto callback_ptr = make_scoped_ptr(new ControlTransferInCallback(callback));
-  ControlTransferRecipient recipient = params->recipient;
-  uint16_t index = params->index;
-  HasControlTransferPermission(
-      recipient, index,
-      base::Bind(&OnControlTransferInPermissionCheckComplete, device_handle_,
-                 base::Passed(&params), length, timeout,
-                 base::Passed(&callback_ptr)));
-}
-
-void DeviceImpl::ControlTransferOut(
-    ControlTransferParamsPtr params,
-    mojo::Array<uint8_t> data,
-    uint32_t timeout,
-    const ControlTransferOutCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR);
-    return;
-  }
-
-  auto callback_ptr = make_scoped_ptr(new ControlTransferOutCallback(callback));
-  ControlTransferRecipient recipient = params->recipient;
-  uint16_t index = params->index;
-  HasControlTransferPermission(
-      recipient, index,
-      base::Bind(&OnControlTransferOutPermissionCheckComplete, device_handle_,
-                 base::Passed(&params), base::Passed(&data), timeout,
-                 base::Passed(&callback_ptr)));
-}
-
-void DeviceImpl::GenericTransferIn(uint8_t endpoint_number,
-                                   uint32_t length,
-                                   uint32_t timeout,
-                                   const GenericTransferInCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
-    return;
-  }
-
-  auto callback_ptr = make_scoped_ptr(new GenericTransferInCallback(callback));
-  uint8_t endpoint_address = endpoint_number | 0x80;
-  scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
-  device_handle_->GenericTransfer(
-      USB_DIRECTION_INBOUND, endpoint_address, buffer, length, timeout,
-      base::Bind(&OnTransferIn, base::Passed(&callback_ptr)));
-}
-
-void DeviceImpl::GenericTransferOut(
-    uint8_t endpoint_number,
-    mojo::Array<uint8_t> data,
-    uint32_t timeout,
-    const GenericTransferOutCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR);
-    return;
-  }
-
-  auto callback_ptr = make_scoped_ptr(new GenericTransferOutCallback(callback));
-  uint8_t endpoint_address = endpoint_number;
-  scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
-  const std::vector<uint8_t>& storage = data.storage();
-  std::copy(storage.begin(), storage.end(), buffer->data());
-  device_handle_->GenericTransfer(
-      USB_DIRECTION_OUTBOUND, endpoint_address, buffer, data.size(), timeout,
-      base::Bind(&OnTransferOut, base::Passed(&callback_ptr)));
-}
-
-void DeviceImpl::IsochronousTransferIn(
-    uint8_t endpoint_number,
-    mojo::Array<uint32_t> packet_lengths,
-    uint32_t timeout,
-    const IsochronousTransferInCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(mojo::Array<uint8_t>(),
-                 BuildIsochronousPacketArray(std::move(packet_lengths),
-                                             TransferStatus::TRANSFER_ERROR));
-    return;
-  }
-
-  auto callback_ptr =
-      make_scoped_ptr(new IsochronousTransferInCallback(callback));
-  uint8_t endpoint_address = endpoint_number | 0x80;
-  device_handle_->IsochronousTransferIn(
-      endpoint_address, packet_lengths.storage(), timeout,
-      base::Bind(&OnIsochronousTransferIn, base::Passed(&callback_ptr)));
-}
-
-void DeviceImpl::IsochronousTransferOut(
-    uint8_t endpoint_number,
-    mojo::Array<uint8_t> data,
-    mojo::Array<uint32_t> packet_lengths,
-    uint32_t timeout,
-    const IsochronousTransferOutCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(BuildIsochronousPacketArray(std::move(packet_lengths),
-                                             TransferStatus::TRANSFER_ERROR));
-    return;
-  }
-
-  auto callback_ptr =
-      make_scoped_ptr(new IsochronousTransferOutCallback(callback));
-  uint8_t endpoint_address = endpoint_number;
-  scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
-  {
-    const std::vector<uint8_t>& storage = data.storage();
-    std::copy(storage.begin(), storage.end(), buffer->data());
-  }
-  device_handle_->IsochronousTransferOut(
-      endpoint_address, buffer, packet_lengths.storage(), timeout,
-      base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
-}
-
-}  // namespace usb
-}  // namespace device
diff --git a/device/devices_app/usb/device_impl.h b/device/devices_app/usb/device_impl.h
deleted file mode 100644
index 2b438c8..0000000
--- a/device/devices_app/usb/device_impl.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// 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.
-
-#ifndef DEVICE_DEVICES_APP_USB_DEVICE_IMPL_H_
-#define DEVICE_DEVICES_APP_USB_DEVICE_IMPL_H_
-
-#include <stdint.h>
-
-#include "base/callback_forward.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "device/devices_app/usb/public/interfaces/device.mojom.h"
-#include "device/devices_app/usb/public/interfaces/permission_provider.mojom.h"
-#include "device/usb/usb_device_handle.h"
-#include "mojo/public/cpp/bindings/binding.h"
-#include "mojo/public/cpp/bindings/callback.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-
-namespace net {
-class IOBuffer;
-}
-
-namespace device {
-namespace usb {
-
-// Implementation of the public Device interface. Instances of this class are
-// constructed by DeviceManagerImpl and are strongly bound to their MessagePipe
-// lifetime.
-class DeviceImpl : public Device {
- public:
-  DeviceImpl(scoped_refptr<UsbDevice> device,
-             PermissionProviderPtr permission_provider,
-             mojo::InterfaceRequest<Device> request);
-  ~DeviceImpl() override;
-
- private:
-  // Closes the device if it's open. This will always set |device_handle_| to
-  // null.
-  void CloseHandle();
-
-  // Checks interface permissions for control transfers.
-  void HasControlTransferPermission(ControlTransferRecipient recipient,
-                                    uint16_t index,
-                                    const base::Callback<void(bool)>& callback);
-
-  // Handles completion of an open request.
-  void OnOpen(const OpenCallback& callback,
-              scoped_refptr<device::UsbDeviceHandle> handle);
-
-  // Device implementation:
-  void GetDeviceInfo(const GetDeviceInfoCallback& callback) override;
-  void GetConfiguration(const GetConfigurationCallback& callback) override;
-  void Open(const OpenCallback& callback) override;
-  void Close(const CloseCallback& callback) override;
-  void SetConfiguration(uint8_t value,
-                        const SetConfigurationCallback& callback) override;
-  void ClaimInterface(uint8_t interface_number,
-                      const ClaimInterfaceCallback& callback) override;
-  void ReleaseInterface(uint8_t interface_number,
-                        const ReleaseInterfaceCallback& callback) override;
-  void SetInterfaceAlternateSetting(
-      uint8_t interface_number,
-      uint8_t alternate_setting,
-      const SetInterfaceAlternateSettingCallback& callback) override;
-  void Reset(const ResetCallback& callback) override;
-  void ClearHalt(uint8_t endpoint, const ClearHaltCallback& callback) override;
-  void ControlTransferIn(ControlTransferParamsPtr params,
-                         uint32_t length,
-                         uint32_t timeout,
-                         const ControlTransferInCallback& callback) override;
-  void ControlTransferOut(ControlTransferParamsPtr params,
-                          mojo::Array<uint8_t> data,
-                          uint32_t timeout,
-                          const ControlTransferOutCallback& callback) override;
-  void GenericTransferIn(uint8_t endpoint_number,
-                         uint32_t length,
-                         uint32_t timeout,
-                         const GenericTransferInCallback& callback) override;
-  void GenericTransferOut(uint8_t endpoint_number,
-                          mojo::Array<uint8_t> data,
-                          uint32_t timeout,
-                          const GenericTransferOutCallback& callback) override;
-  void IsochronousTransferIn(
-      uint8_t endpoint_number,
-      mojo::Array<uint32_t> packet_lengths,
-      uint32_t timeout,
-      const IsochronousTransferInCallback& callback) override;
-  void IsochronousTransferOut(
-      uint8_t endpoint_number,
-      mojo::Array<uint8_t> data,
-      mojo::Array<uint32_t> packet_lengths,
-      uint32_t timeout,
-      const IsochronousTransferOutCallback& callback) override;
-
-  mojo::Binding<Device> binding_;
-
-  scoped_refptr<UsbDevice> device_;
-  // The device handle. Will be null before the device is opened and after it
-  // has been closed.
-  scoped_refptr<UsbDeviceHandle> device_handle_;
-  PermissionProviderPtr permission_provider_;
-
-  base::WeakPtrFactory<DeviceImpl> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeviceImpl);
-};
-
-}  // namespace usb
-}  // namespace device
-
-#endif  // DEVICE_DEVICES_APP_USB_DEVICE_IMPL_H_
diff --git a/device/devices_app/usb/device_impl_unittest.cc b/device/devices_app/usb/device_impl_unittest.cc
deleted file mode 100644
index b98d330..0000000
--- a/device/devices_app/usb/device_impl_unittest.cc
+++ /dev/null
@@ -1,895 +0,0 @@
-// 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 "device/devices_app/usb/device_impl.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <numeric>
-#include <queue>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/stl_util.h"
-#include "device/devices_app/usb/fake_permission_provider.h"
-#include "device/usb/mock_usb_device.h"
-#include "device/usb/mock_usb_device_handle.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "net/base/io_buffer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::Invoke;
-using ::testing::_;
-
-namespace device {
-namespace usb {
-
-namespace {
-
-class ConfigBuilder {
- public:
-  explicit ConfigBuilder(uint8_t value) { config_.configuration_value = value; }
-
-  ConfigBuilder& AddInterface(uint8_t interface_number,
-                              uint8_t alternate_setting,
-                              uint8_t class_code,
-                              uint8_t subclass_code,
-                              uint8_t protocol_code) {
-    UsbInterfaceDescriptor interface;
-    interface.interface_number = interface_number;
-    interface.alternate_setting = alternate_setting;
-    interface.interface_class = class_code;
-    interface.interface_subclass = subclass_code;
-    interface.interface_protocol = protocol_code;
-    config_.interfaces.push_back(interface);
-    return *this;
-  }
-
-  const UsbConfigDescriptor& config() const { return config_; }
-
- private:
-  UsbConfigDescriptor config_;
-};
-
-void ExpectOpenAndThen(OpenDeviceError expected,
-                       const base::Closure& continuation,
-                       OpenDeviceError error) {
-  EXPECT_EQ(expected, error);
-  continuation.Run();
-}
-
-void ExpectDeviceInfoAndThen(const std::string& guid,
-                             uint16_t vendor_id,
-                             uint16_t product_id,
-                             const std::string& manufacturer_name,
-                             const std::string& product_name,
-                             const std::string& serial_number,
-                             const base::Closure& continuation,
-                             DeviceInfoPtr device_info) {
-  EXPECT_EQ(guid, device_info->guid);
-  EXPECT_EQ(vendor_id, device_info->vendor_id);
-  EXPECT_EQ(product_id, device_info->product_id);
-  EXPECT_EQ(manufacturer_name, device_info->manufacturer_name);
-  EXPECT_EQ(product_name, device_info->product_name);
-  EXPECT_EQ(serial_number, device_info->serial_number);
-  continuation.Run();
-}
-
-void ExpectResultAndThen(bool expected_result,
-                         const base::Closure& continuation,
-                         bool actual_result) {
-  EXPECT_EQ(expected_result, actual_result);
-  continuation.Run();
-}
-
-void ExpectTransferInAndThen(TransferStatus expected_status,
-                             const std::vector<uint8_t>& expected_bytes,
-                             const base::Closure& continuation,
-                             TransferStatus actual_status,
-                             mojo::Array<uint8_t> actual_bytes) {
-  EXPECT_EQ(expected_status, actual_status);
-  ASSERT_EQ(expected_bytes.size(), actual_bytes.size());
-  for (size_t i = 0; i < actual_bytes.size(); ++i) {
-    EXPECT_EQ(expected_bytes[i], actual_bytes[i])
-        << "Contents differ at index: " << i;
-  }
-  continuation.Run();
-}
-
-void ExpectPacketsOutAndThen(const std::vector<uint32_t>& expected_packets,
-                             const base::Closure& continuation,
-                             mojo::Array<IsochronousPacketPtr> actual_packets) {
-  ASSERT_EQ(expected_packets.size(), actual_packets.size());
-  for (size_t i = 0; i < expected_packets.size(); ++i) {
-    EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
-        << "Packet lengths differ at index: " << i;
-    EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
-        << "Packet at index " << i << " not completed.";
-  }
-  continuation.Run();
-}
-
-void ExpectPacketsInAndThen(const std::vector<uint8_t>& expected_bytes,
-                            const std::vector<uint32_t>& expected_packets,
-                            const base::Closure& continuation,
-                            mojo::Array<uint8_t> actual_bytes,
-                            mojo::Array<IsochronousPacketPtr> actual_packets) {
-  ASSERT_EQ(expected_packets.size(), actual_packets.size());
-  for (size_t i = 0; i < expected_packets.size(); ++i) {
-    EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
-        << "Packet lengths differ at index: " << i;
-    EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
-        << "Packet at index " << i << " not completed.";
-  }
-  ASSERT_EQ(expected_bytes.size(), actual_bytes.size());
-  for (size_t i = 0; i < expected_bytes.size(); ++i) {
-    EXPECT_EQ(expected_bytes[i], actual_bytes[i])
-        << "Contents differ at index: " << i;
-  }
-  continuation.Run();
-}
-
-void ExpectTransferStatusAndThen(TransferStatus expected_status,
-                                 const base::Closure& continuation,
-                                 TransferStatus actual_status) {
-  EXPECT_EQ(expected_status, actual_status);
-  continuation.Run();
-}
-
-class USBDeviceImplTest : public testing::Test {
- public:
-  USBDeviceImplTest()
-      : message_loop_(new base::MessageLoop),
-        is_device_open_(false),
-        allow_reset_(false),
-        current_config_(0) {}
-
-  ~USBDeviceImplTest() override {}
-
- protected:
-  MockUsbDevice& mock_device() { return *mock_device_.get(); }
-  bool is_device_open() const { return is_device_open_; }
-  MockUsbDeviceHandle& mock_handle() { return *mock_handle_.get(); }
-
-  void set_allow_reset(bool allow_reset) { allow_reset_ = allow_reset; }
-
-  // Creates a mock device and binds a Device proxy to a Device service impl
-  // wrapping the mock device.
-  DevicePtr GetMockDeviceProxy(uint16_t vendor_id,
-                               uint16_t product_id,
-                               const std::string& manufacturer,
-                               const std::string& product,
-                               const std::string& serial) {
-    mock_device_ =
-        new MockUsbDevice(vendor_id, product_id, manufacturer, product, serial);
-    mock_handle_ = new MockUsbDeviceHandle(mock_device_.get());
-
-    PermissionProviderPtr permission_provider;
-    permission_provider_.Bind(mojo::GetProxy(&permission_provider));
-    DevicePtr proxy;
-    new DeviceImpl(mock_device_, std::move(permission_provider),
-                   mojo::GetProxy(&proxy));
-
-    // Set up mock handle calls to respond based on mock device configs
-    // established by the test.
-    ON_CALL(mock_device(), Open(_))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::OpenMockHandle));
-    ON_CALL(mock_device(), GetActiveConfiguration())
-        .WillByDefault(
-            Invoke(this, &USBDeviceImplTest::GetActiveConfiguration));
-    ON_CALL(mock_handle(), Close())
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::CloseMockHandle));
-    ON_CALL(mock_handle(), SetConfiguration(_, _))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::SetConfiguration));
-    ON_CALL(mock_handle(), ClaimInterface(_, _))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::ClaimInterface));
-    ON_CALL(mock_handle(), ReleaseInterface(_, _))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::ReleaseInterface));
-    ON_CALL(mock_handle(), SetInterfaceAlternateSetting(_, _, _))
-        .WillByDefault(
-            Invoke(this, &USBDeviceImplTest::SetInterfaceAlternateSetting));
-    ON_CALL(mock_handle(), ResetDevice(_))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::ResetDevice));
-    ON_CALL(mock_handle(), ControlTransfer(_, _, _, _, _, _, _, _, _, _))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::ControlTransfer));
-    ON_CALL(mock_handle(), GenericTransfer(_, _, _, _, _, _))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::GenericTransfer));
-    ON_CALL(mock_handle(), IsochronousTransferIn(_, _, _, _))
-        .WillByDefault(Invoke(this, &USBDeviceImplTest::IsochronousTransferIn));
-    ON_CALL(mock_handle(), IsochronousTransferOut(_, _, _, _, _))
-        .WillByDefault(
-            Invoke(this, &USBDeviceImplTest::IsochronousTransferOut));
-
-    return proxy;
-  }
-
-  DevicePtr GetMockDeviceProxy() {
-    return GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
-  }
-
-  void AddMockConfig(const ConfigBuilder& builder) {
-    const UsbConfigDescriptor& config = builder.config();
-    DCHECK(!ContainsKey(mock_configs_, config.configuration_value));
-    mock_configs_[config.configuration_value] = config;
-  }
-
-  void AddMockInboundData(const std::vector<uint8_t>& data) {
-    mock_inbound_data_.push(data);
-  }
-
-  void AddMockInboundPackets(
-      const std::vector<uint8_t>& data,
-      const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
-    mock_inbound_data_.push(data);
-    mock_inbound_packets_.push(packets);
-  }
-
-  void AddMockOutboundData(const std::vector<uint8_t>& data) {
-    mock_outbound_data_.push(data);
-  }
-
-  void AddMockOutboundPackets(
-      const std::vector<uint8_t>& data,
-      const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
-    mock_outbound_data_.push(data);
-    mock_outbound_packets_.push(packets);
-  }
-
- private:
-  void OpenMockHandle(const UsbDevice::OpenCallback& callback) {
-    EXPECT_FALSE(is_device_open_);
-    is_device_open_ = true;
-    callback.Run(mock_handle_);
-  }
-
-  void CloseMockHandle() {
-    EXPECT_TRUE(is_device_open_);
-    is_device_open_ = false;
-  }
-
-  const UsbConfigDescriptor* GetActiveConfiguration() {
-    if (current_config_ == 0) {
-      return nullptr;
-    } else {
-      const auto it = mock_configs_.find(current_config_);
-      EXPECT_TRUE(it != mock_configs_.end());
-      return &it->second;
-    }
-  }
-
-  void SetConfiguration(uint8_t value,
-                        const UsbDeviceHandle::ResultCallback& callback) {
-    if (mock_configs_.find(value) != mock_configs_.end()) {
-      current_config_ = value;
-      callback.Run(true);
-    } else {
-      callback.Run(false);
-    }
-  }
-
-  void ClaimInterface(uint8_t interface_number,
-                      const UsbDeviceHandle::ResultCallback& callback) {
-    for (const auto& config : mock_configs_) {
-      for (const auto& interface : config.second.interfaces) {
-        if (interface.interface_number == interface_number) {
-          claimed_interfaces_.insert(interface_number);
-          callback.Run(true);
-          return;
-        }
-      }
-    }
-    callback.Run(false);
-  }
-
-  void ReleaseInterface(uint8_t interface_number,
-                        const UsbDeviceHandle::ResultCallback& callback) {
-    if (ContainsKey(claimed_interfaces_, interface_number)) {
-      claimed_interfaces_.erase(interface_number);
-      callback.Run(true);
-    } else {
-      callback.Run(false);
-    }
-  }
-
-  void SetInterfaceAlternateSetting(
-      uint8_t interface_number,
-      uint8_t alternate_setting,
-      const UsbDeviceHandle::ResultCallback& callback) {
-    for (const auto& config : mock_configs_) {
-      for (const auto& interface : config.second.interfaces) {
-        if (interface.interface_number == interface_number &&
-            interface.alternate_setting == alternate_setting) {
-          callback.Run(true);
-          return;
-        }
-      }
-    }
-    callback.Run(false);
-  }
-
-  void ResetDevice(const UsbDeviceHandle::ResultCallback& callback) {
-    callback.Run(allow_reset_);
-  }
-
-  void InboundTransfer(const UsbDeviceHandle::TransferCallback& callback) {
-    ASSERT_GE(mock_inbound_data_.size(), 1u);
-    const std::vector<uint8_t>& bytes = mock_inbound_data_.front();
-    size_t length = bytes.size();
-    scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length);
-    std::copy(bytes.begin(), bytes.end(), buffer->data());
-    mock_inbound_data_.pop();
-    callback.Run(USB_TRANSFER_COMPLETED, buffer, length);
-  }
-
-  void OutboundTransfer(scoped_refptr<net::IOBuffer> buffer,
-                        size_t length,
-                        const UsbDeviceHandle::TransferCallback& callback) {
-    ASSERT_GE(mock_outbound_data_.size(), 1u);
-    const std::vector<uint8_t>& bytes = mock_outbound_data_.front();
-    ASSERT_EQ(bytes.size(), length);
-    for (size_t i = 0; i < length; ++i) {
-      EXPECT_EQ(bytes[i], buffer->data()[i])
-          << "Contents differ at index: " << i;
-    }
-    mock_outbound_data_.pop();
-    callback.Run(USB_TRANSFER_COMPLETED, buffer, length);
-  }
-
-  void ControlTransfer(UsbEndpointDirection direction,
-                       UsbDeviceHandle::TransferRequestType request_type,
-                       UsbDeviceHandle::TransferRecipient recipient,
-                       uint8_t request,
-                       uint16_t value,
-                       uint16_t index,
-                       scoped_refptr<net::IOBuffer> buffer,
-                       size_t length,
-                       unsigned int timeout,
-                       const UsbDeviceHandle::TransferCallback& callback) {
-    if (direction == USB_DIRECTION_INBOUND)
-      InboundTransfer(callback);
-    else
-      OutboundTransfer(buffer, length, callback);
-  }
-
-  void GenericTransfer(UsbEndpointDirection direction,
-                       uint8_t endpoint,
-                       scoped_refptr<net::IOBuffer> buffer,
-                       size_t length,
-                       unsigned int timeout,
-                       const UsbDeviceHandle::TransferCallback& callback) {
-    if (direction == USB_DIRECTION_INBOUND)
-      InboundTransfer(callback);
-    else
-      OutboundTransfer(buffer, length, callback);
-  }
-
-  void IsochronousTransferIn(
-      uint8_t endpoint_number,
-      const std::vector<uint32_t>& packet_lengths,
-      unsigned int timeout,
-      const UsbDeviceHandle::IsochronousTransferCallback& callback) {
-    ASSERT_FALSE(mock_inbound_data_.empty());
-    const std::vector<uint8_t>& bytes = mock_inbound_data_.front();
-    size_t length = bytes.size();
-    scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length);
-    std::copy(bytes.begin(), bytes.end(), buffer->data());
-    mock_inbound_data_.pop();
-
-    ASSERT_FALSE(mock_inbound_packets_.empty());
-    std::vector<UsbDeviceHandle::IsochronousPacket> packets =
-        mock_inbound_packets_.front();
-    ASSERT_EQ(packets.size(), packet_lengths.size());
-    for (size_t i = 0; i < packets.size(); ++i) {
-      EXPECT_EQ(packets[i].length, packet_lengths[i])
-          << "Packet lengths differ at index: " << i;
-    }
-    mock_inbound_packets_.pop();
-
-    callback.Run(buffer, packets);
-  }
-
-  void IsochronousTransferOut(
-      uint8_t endpoint_number,
-      scoped_refptr<net::IOBuffer> buffer,
-      const std::vector<uint32_t>& packet_lengths,
-      unsigned int timeout,
-      const UsbDeviceHandle::IsochronousTransferCallback& callback) {
-    ASSERT_FALSE(mock_outbound_data_.empty());
-    const std::vector<uint8_t>& bytes = mock_outbound_data_.front();
-    size_t length =
-        std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
-    ASSERT_EQ(bytes.size(), length);
-    for (size_t i = 0; i < length; ++i) {
-      EXPECT_EQ(bytes[i], buffer->data()[i]) << "Contents differ at index: "
-                                             << i;
-    }
-    mock_outbound_data_.pop();
-
-    ASSERT_FALSE(mock_outbound_packets_.empty());
-    std::vector<UsbDeviceHandle::IsochronousPacket> packets =
-        mock_outbound_packets_.front();
-    ASSERT_EQ(packets.size(), packet_lengths.size());
-    for (size_t i = 0; i < packets.size(); ++i) {
-      EXPECT_EQ(packets[i].length, packet_lengths[i])
-          << "Packet lengths differ at index: " << i;
-    }
-    mock_outbound_packets_.pop();
-
-    callback.Run(buffer, packets);
-  }
-
-  scoped_ptr<base::MessageLoop> message_loop_;
-  scoped_refptr<MockUsbDevice> mock_device_;
-  scoped_refptr<MockUsbDeviceHandle> mock_handle_;
-  bool is_device_open_;
-  bool allow_reset_;
-
-  std::map<uint8_t, UsbConfigDescriptor> mock_configs_;
-  uint8_t current_config_;
-
-  std::queue<std::vector<uint8_t>> mock_inbound_data_;
-  std::queue<std::vector<uint8_t>> mock_outbound_data_;
-  std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>>
-      mock_inbound_packets_;
-  std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>>
-      mock_outbound_packets_;
-
-  std::set<uint8_t> claimed_interfaces_;
-
-  FakePermissionProvider permission_provider_;
-
-  DISALLOW_COPY_AND_ASSIGN(USBDeviceImplTest);
-};
-
-}  // namespace
-
-TEST_F(USBDeviceImplTest, Open) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_FALSE(is_device_open());
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  base::RunLoop loop;
-  device->Open(
-      base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK, loop.QuitClosure()));
-  loop.Run();
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, Close) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_FALSE(is_device_open());
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-
-  {
-    base::RunLoop loop;
-    device->Close(loop.QuitClosure());
-    loop.Run();
-  }
-
-  EXPECT_FALSE(is_device_open());
-}
-
-// Test that the information returned via the Device::GetDeviceInfo matches that
-// of the underlying device.
-TEST_F(USBDeviceImplTest, GetDeviceInfo) {
-  DevicePtr device =
-      GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
-
-  base::RunLoop loop;
-  device->GetDeviceInfo(base::Bind(&ExpectDeviceInfoAndThen,
-                                   mock_device().guid(), 0x1234, 0x5678, "ACME",
-                                   "Frobinator", "ABCDEF", loop.QuitClosure()));
-  loop.Run();
-}
-
-TEST_F(USBDeviceImplTest, SetInvalidConfiguration) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
-
-  {
-    // SetConfiguration should fail because 42 is not a valid mock
-    // configuration.
-    base::RunLoop loop;
-    device->SetConfiguration(
-        42, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, SetValidConfiguration) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
-
-  AddMockConfig(ConfigBuilder(42));
-
-  {
-    // SetConfiguration should succeed because 42 is a valid mock configuration.
-    base::RunLoop loop;
-    device->SetConfiguration(
-        42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-// Verify that the result of Reset() reflects the underlying UsbDeviceHandle's
-// ResetDevice() result.
-TEST_F(USBDeviceImplTest, Reset) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), ResetDevice(_));
-
-  set_allow_reset(true);
-
-  {
-    base::RunLoop loop;
-    device->Reset(base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), ResetDevice(_));
-
-  set_allow_reset(false);
-
-  {
-    base::RunLoop loop;
-    device->Reset(base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, ClaimAndReleaseInterface) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  // Now add a mock interface #1.
-  AddMockConfig(ConfigBuilder(1).AddInterface(1, 0, 1, 2, 3));
-
-  EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
-
-  {
-    base::RunLoop loop;
-    device->SetConfiguration(
-        1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_device(), GetActiveConfiguration());
-  EXPECT_CALL(mock_handle(), ClaimInterface(2, _));
-
-  {
-    // Try to claim an invalid interface and expect failure.
-    base::RunLoop loop;
-    device->ClaimInterface(
-        2, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_device(), GetActiveConfiguration());
-  EXPECT_CALL(mock_handle(), ClaimInterface(1, _));
-
-  {
-    base::RunLoop loop;
-    device->ClaimInterface(
-        1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), ReleaseInterface(2, _));
-
-  {
-    // Releasing a non-existent interface should fail.
-    base::RunLoop loop;
-    device->ReleaseInterface(
-        2, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), ReleaseInterface(1, _));
-
-  {
-    // Now this should release the claimed interface and close the handle.
-    base::RunLoop loop;
-    device->ReleaseInterface(
-        1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, SetInterfaceAlternateSetting) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  AddMockConfig(ConfigBuilder(1)
-                    .AddInterface(1, 0, 1, 2, 3)
-                    .AddInterface(1, 42, 1, 2, 3)
-                    .AddInterface(2, 0, 1, 2, 3));
-
-  EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 42, _));
-
-  {
-    base::RunLoop loop;
-    device->SetInterfaceAlternateSetting(
-        1, 42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 100, _));
-
-  {
-    base::RunLoop loop;
-    device->SetInterfaceAlternateSetting(
-        1, 100, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, ControlTransfer) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
-
-  EXPECT_CALL(mock_device(), GetActiveConfiguration());
-  EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
-
-  {
-    base::RunLoop loop;
-    device->SetConfiguration(
-        1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  std::vector<uint8_t> fake_data;
-  fake_data.push_back(41);
-  fake_data.push_back(42);
-  fake_data.push_back(43);
-
-  AddMockInboundData(fake_data);
-
-  EXPECT_CALL(mock_handle(),
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 5, 6, 7, _, _, 0, _));
-
-  {
-    auto params = ControlTransferParams::New();
-    params->type = ControlTransferType::STANDARD;
-    params->recipient = ControlTransferRecipient::DEVICE;
-    params->request = 5;
-    params->value = 6;
-    params->index = 7;
-    base::RunLoop loop;
-    device->ControlTransferIn(
-        std::move(params), static_cast<uint32_t>(fake_data.size()), 0,
-        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
-                   fake_data, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  AddMockOutboundData(fake_data);
-
-  EXPECT_CALL(mock_device(), GetActiveConfiguration());
-  EXPECT_CALL(mock_handle(),
-              ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
-
-  {
-    auto params = ControlTransferParams::New();
-    params->type = ControlTransferType::STANDARD;
-    params->recipient = ControlTransferRecipient::INTERFACE;
-    params->request = 5;
-    params->value = 6;
-    params->index = 7;
-    base::RunLoop loop;
-    device->ControlTransferOut(
-        std::move(params), mojo::Array<uint8_t>::From(fake_data), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
-                   loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, GenericTransfer) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  std::string message1 = "say hello please";
-  std::vector<uint8_t> fake_outbound_data(message1.size());
-  std::copy(message1.begin(), message1.end(), fake_outbound_data.begin());
-
-  std::string message2 = "hello world!";
-  std::vector<uint8_t> fake_inbound_data(message2.size());
-  std::copy(message2.begin(), message2.end(), fake_inbound_data.begin());
-
-  AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
-  AddMockOutboundData(fake_outbound_data);
-  AddMockInboundData(fake_inbound_data);
-
-  EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_OUTBOUND, 0x01, _,
-                                             fake_outbound_data.size(), 0, _));
-
-  {
-    base::RunLoop loop;
-    device->GenericTransferOut(
-        1, mojo::Array<uint8_t>::From(fake_outbound_data), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
-                   loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_INBOUND, 0x81, _,
-                                             fake_inbound_data.size(), 0, _));
-
-  {
-    base::RunLoop loop;
-    device->GenericTransferIn(
-        1, static_cast<uint32_t>(fake_inbound_data.size()), 0,
-        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
-                   fake_inbound_data, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, IsochronousTransfer) {
-  DevicePtr device = GetMockDeviceProxy();
-
-  EXPECT_CALL(mock_device(), Open(_));
-
-  {
-    base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
-                            loop.QuitClosure()));
-    loop.Run();
-  }
-
-  std::vector<UsbDeviceHandle::IsochronousPacket> fake_packets(4);
-  for (size_t i = 0; i < fake_packets.size(); ++i) {
-    fake_packets[i].length = 8;
-    fake_packets[i].transferred_length = 8;
-    fake_packets[i].status = USB_TRANSFER_COMPLETED;
-  }
-  std::vector<uint32_t> fake_packet_lengths(4, 8);
-
-  std::vector<uint32_t> expected_transferred_lengths(4, 8);
-
-  std::string outbound_data = "aaaaaaaabbbbbbbbccccccccdddddddd";
-  std::vector<uint8_t> fake_outbound_data(outbound_data.size());
-  std::copy(outbound_data.begin(), outbound_data.end(),
-            fake_outbound_data.begin());
-
-  std::string inbound_data = "ddddddddccccccccbbbbbbbbaaaaaaaa";
-  std::vector<uint8_t> fake_inbound_data(inbound_data.size());
-  std::copy(inbound_data.begin(), inbound_data.end(),
-            fake_inbound_data.begin());
-
-  AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
-  AddMockOutboundPackets(fake_outbound_data, fake_packets);
-  AddMockInboundPackets(fake_inbound_data, fake_packets);
-
-  EXPECT_CALL(mock_handle(),
-              IsochronousTransferOut(0x01, _, fake_packet_lengths, 0, _));
-
-  {
-    base::RunLoop loop;
-    device->IsochronousTransferOut(
-        1, mojo::Array<uint8_t>::From(fake_outbound_data),
-        mojo::Array<uint32_t>::From(fake_packet_lengths), 0,
-        base::Bind(&ExpectPacketsOutAndThen, expected_transferred_lengths,
-                   loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(),
-              IsochronousTransferIn(0x81, fake_packet_lengths, 0, _));
-
-  {
-    base::RunLoop loop;
-    device->IsochronousTransferIn(
-        1, mojo::Array<uint32_t>::From(fake_packet_lengths), 0,
-        base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
-                   expected_transferred_lengths, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  EXPECT_CALL(mock_handle(), Close());
-}
-
-}  // namespace usb
-}  // namespace device
diff --git a/device/devices_app/usb/device_manager_impl.cc b/device/devices_app/usb/device_manager_impl.cc
deleted file mode 100644
index b3f7784..0000000
--- a/device/devices_app/usb/device_manager_impl.cc
+++ /dev/null
@@ -1,228 +0,0 @@
-// 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 "device/devices_app/usb/device_manager_impl.h"
-
-#include <stddef.h>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/stl_util.h"
-#include "device/core/device_client.h"
-#include "device/devices_app/usb/device_impl.h"
-#include "device/devices_app/usb/public/interfaces/device.mojom.h"
-#include "device/devices_app/usb/type_converters.h"
-#include "device/usb/usb_device.h"
-#include "device/usb/usb_device_filter.h"
-#include "device/usb/usb_service.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-
-namespace device {
-namespace usb {
-
-namespace {
-
-using DeviceList = DeviceManagerImpl::DeviceList;
-using DeviceMap = DeviceManagerImpl::DeviceMap;
-
-void FilterAndConvertDevicesAndThen(
-    const DeviceMap& devices,
-    const DeviceManagerImpl::GetDevicesCallback& callback,
-    mojo::Array<mojo::String> allowed_guids) {
-  mojo::Array<DeviceInfoPtr> allowed_devices(allowed_guids.size());
-  for (size_t i = 0; i < allowed_guids.size(); ++i) {
-    const auto it = devices.find(allowed_guids[i]);
-    DCHECK(it != devices.end());
-    allowed_devices[i] = DeviceInfo::From(*it->second);
-  }
-
-  callback.Run(std::move(allowed_devices));
-}
-
-}  // namespace
-
-// static
-void DeviceManagerImpl::Create(PermissionProviderPtr permission_provider,
-                               mojo::InterfaceRequest<DeviceManager> request) {
-  // The created object is owned by its binding.
-  new DeviceManagerImpl(std::move(permission_provider), std::move(request));
-}
-
-DeviceManagerImpl::DeviceManagerImpl(
-    PermissionProviderPtr permission_provider,
-    mojo::InterfaceRequest<DeviceManager> request)
-    : permission_provider_(std::move(permission_provider)),
-      observer_(this),
-      binding_(this, std::move(request)),
-      weak_factory_(this) {
-  // This object owns itself and will be destroyed if either the message pipe
-  // it is bound to is closed or the PermissionProvider it depends on is
-  // unavailable.
-  binding_.set_connection_error_handler([this]() { delete this; });
-  permission_provider_.set_connection_error_handler([this]() { delete this; });
-
-  DCHECK(DeviceClient::Get());
-  usb_service_ = DeviceClient::Get()->GetUsbService();
-  if (usb_service_)
-    observer_.Add(usb_service_);
-}
-
-DeviceManagerImpl::~DeviceManagerImpl() {
-  connection_error_handler_.Run();
-}
-
-void DeviceManagerImpl::GetDevices(EnumerationOptionsPtr options,
-                                   const GetDevicesCallback& callback) {
-  if (!usb_service_) {
-    mojo::Array<DeviceInfoPtr> no_devices;
-    callback.Run(std::move(no_devices));
-    return;
-  }
-
-  usb_service_->GetDevices(base::Bind(&DeviceManagerImpl::OnGetDevices,
-                                      weak_factory_.GetWeakPtr(),
-                                      base::Passed(&options), callback));
-}
-
-void DeviceManagerImpl::GetDeviceChanges(
-    const GetDeviceChangesCallback& callback) {
-  device_change_callbacks_.push(callback);
-  MaybeRunDeviceChangesCallback();
-}
-
-void DeviceManagerImpl::GetDevice(
-    const mojo::String& guid,
-    mojo::InterfaceRequest<Device> device_request) {
-  if (!usb_service_)
-    return;
-
-  scoped_refptr<UsbDevice> device = usb_service_->GetDevice(guid);
-  if (!device)
-    return;
-
-  mojo::Array<DeviceInfoPtr> requested_devices(1);
-  requested_devices[0] = DeviceInfo::From(*device);
-  permission_provider_->HasDevicePermission(
-      std::move(requested_devices),
-      base::Bind(&DeviceManagerImpl::OnGetDevicePermissionCheckComplete,
-                 base::Unretained(this), device,
-                 base::Passed(&device_request)));
-}
-
-void DeviceManagerImpl::OnGetDevicePermissionCheckComplete(
-    scoped_refptr<UsbDevice> device,
-    mojo::InterfaceRequest<Device> device_request,
-    mojo::Array<mojo::String> allowed_guids) {
-  if (allowed_guids.size() == 0)
-    return;
-
-  DCHECK(allowed_guids.size() == 1);
-  PermissionProviderPtr permission_provider;
-  permission_provider_->Bind(mojo::GetProxy(&permission_provider));
-  new DeviceImpl(device, std::move(permission_provider),
-                 std::move(device_request));
-}
-
-void DeviceManagerImpl::OnGetDevices(EnumerationOptionsPtr options,
-                                     const GetDevicesCallback& callback,
-                                     const DeviceList& devices) {
-  std::vector<UsbDeviceFilter> filters;
-  if (options)
-    filters = options->filters.To<std::vector<UsbDeviceFilter>>();
-
-  std::map<std::string, scoped_refptr<UsbDevice>> device_map;
-  mojo::Array<DeviceInfoPtr> requested_devices(0);
-  for (const auto& device : devices) {
-    if (filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) {
-      device_map[device->guid()] = device;
-      requested_devices.push_back(DeviceInfo::From(*device));
-    }
-  }
-
-  permission_provider_->HasDevicePermission(
-      std::move(requested_devices),
-      base::Bind(&FilterAndConvertDevicesAndThen, device_map, callback));
-}
-
-void DeviceManagerImpl::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
-  DCHECK(!ContainsKey(devices_removed_, device->guid()));
-  devices_added_[device->guid()] = device;
-  MaybeRunDeviceChangesCallback();
-}
-
-void DeviceManagerImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
-  if (devices_added_.erase(device->guid()) == 0)
-    devices_removed_[device->guid()] = device;
-  MaybeRunDeviceChangesCallback();
-}
-
-void DeviceManagerImpl::WillDestroyUsbService() {
-  observer_.RemoveAll();
-  usb_service_ = nullptr;
-}
-
-void DeviceManagerImpl::MaybeRunDeviceChangesCallback() {
-  if (!permission_request_pending_ && !device_change_callbacks_.empty()) {
-    DeviceMap devices_added;
-    devices_added.swap(devices_added_);
-    DeviceMap devices_removed;
-    devices_removed.swap(devices_removed_);
-
-    mojo::Array<DeviceInfoPtr> requested_devices(devices_added.size() +
-                                                 devices_removed.size());
-    {
-      size_t i = 0;
-      for (const auto& map_entry : devices_added)
-        requested_devices[i++] = DeviceInfo::From(*map_entry.second);
-      for (const auto& map_entry : devices_removed)
-        requested_devices[i++] = DeviceInfo::From(*map_entry.second);
-    }
-
-    permission_request_pending_ = true;
-    permission_provider_->HasDevicePermission(
-        std::move(requested_devices),
-        base::Bind(&DeviceManagerImpl::OnEnumerationPermissionCheckComplete,
-                   base::Unretained(this), devices_added, devices_removed));
-  }
-}
-
-void DeviceManagerImpl::OnEnumerationPermissionCheckComplete(
-    const DeviceMap& devices_added,
-    const DeviceMap& devices_removed,
-    mojo::Array<mojo::String> allowed_guids) {
-  permission_request_pending_ = false;
-
-  if (allowed_guids.size() > 0) {
-    DeviceChangeNotificationPtr notification = DeviceChangeNotification::New();
-    notification->devices_added.resize(0);
-    notification->devices_removed.resize(0);
-
-    for (size_t i = 0; i < allowed_guids.size(); ++i) {
-      const mojo::String& guid = allowed_guids[i];
-      auto it = devices_added.find(guid);
-      if (it != devices_added.end()) {
-        DCHECK(!ContainsKey(devices_removed, guid));
-        notification->devices_added.push_back(DeviceInfo::From(*it->second));
-      } else {
-        it = devices_removed.find(guid);
-        DCHECK(it != devices_removed.end());
-        notification->devices_removed.push_back(DeviceInfo::From(*it->second));
-      }
-    }
-
-    DCHECK(!device_change_callbacks_.empty());
-    const GetDeviceChangesCallback& callback = device_change_callbacks_.front();
-    callback.Run(std::move(notification));
-    device_change_callbacks_.pop();
-  }
-
-  if (devices_added_.size() > 0 || !devices_removed_.empty())
-    MaybeRunDeviceChangesCallback();
-}
-
-}  // namespace usb
-}  // namespace device
diff --git a/device/devices_app/usb/device_manager_impl.h b/device/devices_app/usb/device_manager_impl.h
deleted file mode 100644
index 4e9578d..0000000
--- a/device/devices_app/usb/device_manager_impl.h
+++ /dev/null
@@ -1,111 +0,0 @@
-// 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.
-
-#ifndef DEVICE_USB_DEVICE_MANAGER_IMPL_H_
-#define DEVICE_USB_DEVICE_MANAGER_IMPL_H_
-
-#include <queue>
-#include <set>
-
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "base/scoped_observer.h"
-#include "device/devices_app/usb/public/interfaces/device_manager.mojom.h"
-#include "device/devices_app/usb/public/interfaces/permission_provider.mojom.h"
-#include "device/usb/usb_service.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "mojo/public/cpp/bindings/binding.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-
-namespace base {
-class SequencedTaskRunner;
-}
-
-namespace device {
-
-class UsbDevice;
-class UsbDeviceFilter;
-class UsbDeviceHandle;
-
-namespace usb {
-
-class DeviceManagerDelegate;
-
-// Implementation of the public DeviceManager interface. This interface can be
-// requested from the devices app located at "mojo:devices", if available.
-class DeviceManagerImpl : public DeviceManager,
-                          public device::UsbService::Observer {
- public:
-  using DeviceList = std::vector<scoped_refptr<UsbDevice>>;
-  using DeviceMap = std::map<std::string, scoped_refptr<device::UsbDevice>>;
-
-  static void Create(PermissionProviderPtr permission_provider,
-                     mojo::InterfaceRequest<DeviceManager> request);
-
-  DeviceManagerImpl(PermissionProviderPtr permission_provider,
-                    mojo::InterfaceRequest<DeviceManager> request);
-  ~DeviceManagerImpl() override;
-
-  void set_connection_error_handler(const mojo::Closure& error_handler) {
-    connection_error_handler_ = error_handler;
-  }
-
- private:
-  // DeviceManager implementation:
-  void GetDevices(EnumerationOptionsPtr options,
-                  const GetDevicesCallback& callback) override;
-  void GetDeviceChanges(const GetDeviceChangesCallback& callback) override;
-  void GetDevice(const mojo::String& guid,
-                 mojo::InterfaceRequest<Device> device_request) override;
-
-  // Callbacks to handle the async responses from the underlying UsbService.
-  void OnGetDevicePermissionCheckComplete(
-      scoped_refptr<device::UsbDevice> device,
-      mojo::InterfaceRequest<Device> device_request,
-      mojo::Array<mojo::String> allowed_guids);
-  void OnGetDevices(EnumerationOptionsPtr options,
-                    const GetDevicesCallback& callback,
-                    const DeviceList& devices);
-
-  // UsbService::Observer implementation:
-  void OnDeviceAdded(scoped_refptr<device::UsbDevice> device) override;
-  void OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) override;
-  void WillDestroyUsbService() override;
-
-  void MaybeRunDeviceChangesCallback();
-  void OnEnumerationPermissionCheckComplete(
-      const DeviceMap& devices_added,
-      const DeviceMap& devices_removed,
-      mojo::Array<mojo::String> allowed_guids);
-
-  PermissionProviderPtr permission_provider_;
-
-  // If there are unfinished calls to GetDeviceChanges their callbacks
-  // are stored in |device_change_callbacks_|. Otherwise device changes
-  // are collected in |devices_added_| and |devices_removed_| until the
-  // next call to GetDeviceChanges.
-  std::queue<GetDeviceChangesCallback> device_change_callbacks_;
-  DeviceMap devices_added_;
-  DeviceMap devices_removed_;
-  // To ensure that GetDeviceChangesCallbacks are called in the correct order
-  // only perform a single request to |permission_provider_| at a time.
-  bool permission_request_pending_ = false;
-
-  UsbService* usb_service_;
-  ScopedObserver<device::UsbService, device::UsbService::Observer> observer_;
-
-  mojo::Closure connection_error_handler_;
-
-  mojo::Binding<DeviceManager> binding_;
-  base::WeakPtrFactory<DeviceManagerImpl> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeviceManagerImpl);
-};
-
-}  // namespace usb
-}  // namespace device
-
-#endif  // DEVICE_USB_DEVICE_MANAGER_IMPL_H_
diff --git a/device/devices_app/usb/device_manager_impl_unittest.cc b/device/devices_app/usb/device_manager_impl_unittest.cc
deleted file mode 100644
index 720c811..0000000
--- a/device/devices_app/usb/device_manager_impl_unittest.cc
+++ /dev/null
@@ -1,218 +0,0 @@
-// 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 "device/devices_app/usb/device_manager_impl.h"
-
-#include <stddef.h>
-#include <set>
-#include <string>
-#include <utility>
-
-#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/mock_device_client.h"
-#include "device/devices_app/usb/device_impl.h"
-#include "device/devices_app/usb/fake_permission_provider.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"
-
-using ::testing::Invoke;
-using ::testing::_;
-
-namespace device {
-namespace usb {
-
-namespace {
-
-class USBDeviceManagerImplTest : public testing::Test {
- public:
-  USBDeviceManagerImplTest() : message_loop_(new base::MessageLoop) {}
-  ~USBDeviceManagerImplTest() override {}
-
- protected:
-  DeviceManagerPtr ConnectToDeviceManager() {
-    PermissionProviderPtr permission_provider;
-    permission_provider_.Bind(mojo::GetProxy(&permission_provider));
-    DeviceManagerPtr device_manager;
-    DeviceManagerImpl::Create(std::move(permission_provider),
-                              mojo::GetProxy(&device_manager));
-    return device_manager;
-  }
-
-  MockDeviceClient device_client_;
-
- private:
-  FakePermissionProvider permission_provider_;
-  scoped_ptr<base::MessageLoop> message_loop_;
-};
-
-void ExpectDevicesAndThen(const std::set<std::string>& expected_guids,
-                          const base::Closure& continuation,
-                          mojo::Array<DeviceInfoPtr> results) {
-  EXPECT_EQ(expected_guids.size(), results.size());
-  std::set<std::string> actual_guids;
-  for (size_t i = 0; i < results.size(); ++i)
-    actual_guids.insert(results[i]->guid);
-  EXPECT_EQ(expected_guids, actual_guids);
-  continuation.Run();
-}
-
-void ExpectDeviceChangesAndThen(
-    const std::set<std::string>& expected_added_guids,
-    const std::set<std::string>& expected_removed_guids,
-    const base::Closure& continuation,
-    DeviceChangeNotificationPtr results) {
-  EXPECT_EQ(expected_added_guids.size(), results->devices_added.size());
-  std::set<std::string> actual_added_guids;
-  for (size_t i = 0; i < results->devices_added.size(); ++i)
-    actual_added_guids.insert(results->devices_added[i]->guid);
-  EXPECT_EQ(expected_added_guids, actual_added_guids);
-  EXPECT_EQ(expected_removed_guids.size(), results->devices_removed.size());
-  std::set<std::string> actual_removed_guids;
-  for (size_t i = 0; i < results->devices_removed.size(); ++i)
-    actual_removed_guids.insert(results->devices_removed[i]->guid);
-  EXPECT_EQ(expected_removed_guids, actual_removed_guids);
-  continuation.Run();
-}
-
-void ExpectDeviceInfoAndThen(const std::string& expected_guid,
-                             const base::Closure& continuation,
-                             DeviceInfoPtr device_info) {
-  ASSERT_TRUE(device_info);
-  EXPECT_EQ(expected_guid, device_info->guid);
-  continuation.Run();
-}
-
-}  // namespace
-
-// Test basic GetDevices functionality to ensure that all mock devices are
-// returned by the service.
-TEST_F(USBDeviceManagerImplTest, GetDevices) {
-  scoped_refptr<MockUsbDevice> device0 =
-      new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
-  scoped_refptr<MockUsbDevice> device1 =
-      new MockUsbDevice(0x1234, 0x5679, "ACME", "Frobinator+", "GHIJKL");
-  scoped_refptr<MockUsbDevice> device2 =
-      new MockUsbDevice(0x1234, 0x567a, "ACME", "Frobinator Mk II", "MNOPQR");
-
-  device_client_.usb_service()->AddDevice(device0);
-  device_client_.usb_service()->AddDevice(device1);
-  device_client_.usb_service()->AddDevice(device2);
-
-  DeviceManagerPtr device_manager = ConnectToDeviceManager();
-
-  EnumerationOptionsPtr options = EnumerationOptions::New();
-  options->filters = mojo::Array<DeviceFilterPtr>::New(1);
-  options->filters[0] = DeviceFilter::New();
-  options->filters[0]->has_vendor_id = true;
-  options->filters[0]->vendor_id = 0x1234;
-
-  std::set<std::string> guids;
-  guids.insert(device0->guid());
-  guids.insert(device1->guid());
-  guids.insert(device2->guid());
-
-  base::RunLoop loop;
-  device_manager->GetDevices(
-      std::move(options),
-      base::Bind(&ExpectDevicesAndThen, guids, loop.QuitClosure()));
-  loop.Run();
-}
-
-// Test requesting a single Device by GUID.
-TEST_F(USBDeviceManagerImplTest, GetDevice) {
-  scoped_refptr<MockUsbDevice> mock_device =
-      new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
-
-  device_client_.usb_service()->AddDevice(mock_device);
-
-  DeviceManagerPtr device_manager = ConnectToDeviceManager();
-
-  {
-    base::RunLoop loop;
-    DevicePtr device;
-    device_manager->GetDevice(mock_device->guid(), mojo::GetProxy(&device));
-    device->GetDeviceInfo(base::Bind(&ExpectDeviceInfoAndThen,
-                                     mock_device->guid(), loop.QuitClosure()));
-    loop.Run();
-  }
-
-  DevicePtr bad_device;
-  device_manager->GetDevice("not a real guid", mojo::GetProxy(&bad_device));
-
-  {
-    base::RunLoop loop;
-    bad_device.set_connection_error_handler(loop.QuitClosure());
-    loop.Run();
-  }
-}
-
-// Test requesting device enumeration updates with GetDeviceChanges.
-TEST_F(USBDeviceManagerImplTest, GetDeviceChanges) {
-  scoped_refptr<MockUsbDevice> device0 =
-      new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
-  scoped_refptr<MockUsbDevice> device1 =
-      new MockUsbDevice(0x1234, 0x5679, "ACME", "Frobinator+", "GHIJKL");
-  scoped_refptr<MockUsbDevice> device2 =
-      new MockUsbDevice(0x1234, 0x567a, "ACME", "Frobinator Mk II", "MNOPQR");
-  scoped_refptr<MockUsbDevice> device3 =
-      new MockUsbDevice(0x1234, 0x567b, "ACME", "Frobinator Xtreme", "STUVWX");
-
-  device_client_.usb_service()->AddDevice(device0);
-
-  DeviceManagerPtr device_manager = ConnectToDeviceManager();
-
-  {
-    // Call GetDevices once to make sure the device manager is up and running
-    // or else we could end up waiting forever for device changes as the next
-    // block races with the ServiceThreadHelper startup.
-    std::set<std::string> guids;
-    guids.insert(device0->guid());
-    base::RunLoop loop;
-    device_manager->GetDevices(
-        nullptr, base::Bind(&ExpectDevicesAndThen, guids, loop.QuitClosure()));
-    loop.Run();
-  }
-
-  device_client_.usb_service()->AddDevice(device1);
-  device_client_.usb_service()->AddDevice(device2);
-  device_client_.usb_service()->RemoveDevice(device1);
-
-  {
-    std::set<std::string> added_guids;
-    std::set<std::string> removed_guids;
-    added_guids.insert(device2->guid());
-    base::RunLoop loop;
-    device_manager->GetDeviceChanges(base::Bind(&ExpectDeviceChangesAndThen,
-                                                added_guids, removed_guids,
-                                                loop.QuitClosure()));
-    loop.Run();
-  }
-
-  device_client_.usb_service()->RemoveDevice(device0);
-  device_client_.usb_service()->RemoveDevice(device2);
-  device_client_.usb_service()->AddDevice(device3);
-
-  {
-    std::set<std::string> added_guids;
-    std::set<std::string> removed_guids;
-    added_guids.insert(device3->guid());
-    removed_guids.insert(device0->guid());
-    removed_guids.insert(device2->guid());
-    base::RunLoop loop;
-    device_manager->GetDeviceChanges(base::Bind(&ExpectDeviceChangesAndThen,
-                                                added_guids, removed_guids,
-                                                loop.QuitClosure()));
-    loop.Run();
-  }
-}
-
-}  // namespace usb
-}  // namespace device
diff --git a/device/devices_app/usb/fake_permission_provider.cc b/device/devices_app/usb/fake_permission_provider.cc
deleted file mode 100644
index 3a774a8..0000000
--- a/device/devices_app/usb/fake_permission_provider.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// 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 "device/devices_app/usb/fake_permission_provider.h"
-
-#include <stddef.h>
-#include <utility>
-
-namespace device {
-namespace usb {
-
-FakePermissionProvider::FakePermissionProvider() {}
-
-FakePermissionProvider::~FakePermissionProvider() {}
-
-void FakePermissionProvider::HasDevicePermission(
-    mojo::Array<DeviceInfoPtr> requested_devices,
-    const HasDevicePermissionCallback& callback) {
-  mojo::Array<mojo::String> allowed_guids(requested_devices.size());
-  for (size_t i = 0; i < requested_devices.size(); ++i)
-    allowed_guids[i] = requested_devices[i]->guid;
-  callback.Run(std::move(allowed_guids));
-}
-
-void FakePermissionProvider::HasConfigurationPermission(
-    uint8_t requested_configuration,
-    device::usb::DeviceInfoPtr device,
-    const HasInterfacePermissionCallback& callback) {
-  callback.Run(true);
-}
-void FakePermissionProvider::HasInterfacePermission(
-    uint8_t requested_interface,
-    uint8_t configuration_value,
-    device::usb::DeviceInfoPtr device,
-    const HasInterfacePermissionCallback& callback) {
-  callback.Run(true);
-}
-
-void FakePermissionProvider::Bind(
-    mojo::InterfaceRequest<PermissionProvider> request) {
-  bindings_.AddBinding(this, std::move(request));
-}
-
-}  // namespace usb
-}  // namespace device
diff --git a/device/devices_app/usb/fake_permission_provider.h b/device/devices_app/usb/fake_permission_provider.h
deleted file mode 100644
index 62947b4..0000000
--- a/device/devices_app/usb/fake_permission_provider.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// 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.
-
-#ifndef DEVICE_USB_FAKE_PERMISSION_PROVIDER_H_
-#define DEVICE_USB_FAKE_PERMISSION_PROVIDER_H_
-
-#include <stdint.h>
-
-#include "device/devices_app/usb/public/interfaces/permission_provider.mojom.h"
-#include "mojo/common/weak_binding_set.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-
-namespace device {
-namespace usb {
-
-class FakePermissionProvider : public PermissionProvider {
- public:
-  FakePermissionProvider();
-  ~FakePermissionProvider() override;
-
-  void HasDevicePermission(
-      mojo::Array<DeviceInfoPtr> requested_devices,
-      const HasDevicePermissionCallback& callback) override;
-  void HasConfigurationPermission(
-      uint8_t requested_configuration,
-      device::usb::DeviceInfoPtr device,
-      const HasInterfacePermissionCallback& callback) override;
-  void HasInterfacePermission(
-      uint8_t requested_interface,
-      uint8_t configuration_value,
-      device::usb::DeviceInfoPtr device,
-      const HasInterfacePermissionCallback& callback) override;
-  void Bind(mojo::InterfaceRequest<PermissionProvider> request) override;
-
- private:
-  mojo::WeakBindingSet<PermissionProvider> bindings_;
-};
-
-}  // namespace usb
-}  // namespace device
-
-#endif  // DEVICE_USB_FAKE_PERMISSION_PROVIDER_H_
diff --git a/device/devices_app/usb/public/interfaces/BUILD.gn b/device/devices_app/usb/public/interfaces/BUILD.gn
deleted file mode 100644
index f9d6e0c..0000000
--- a/device/devices_app/usb/public/interfaces/BUILD.gn
+++ /dev/null
@@ -1,13 +0,0 @@
-# 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.
-
-import("//mojo/public/tools/bindings/mojom.gni")
-
-mojom("interfaces") {
-  sources = [
-    "device.mojom",
-    "device_manager.mojom",
-    "permission_provider.mojom",
-  ]
-}
diff --git a/device/devices_app/usb/public/interfaces/device.mojom b/device/devices_app/usb/public/interfaces/device.mojom
deleted file mode 100644
index 25addb2..0000000
--- a/device/devices_app/usb/public/interfaces/device.mojom
+++ /dev/null
@@ -1,285 +0,0 @@
-// 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.
-
-module device.usb;
-
-enum OpenDeviceError {
-  // Opening the device succeeded.
-  OK,
-
-  // The operating system denied access to the device.
-  ACCESS_DENIED,
-};
-
-enum TransferDirection {
-  INBOUND,
-  OUTBOUND,
-};
-
-enum ControlTransferType {
-  STANDARD,
-  CLASS,
-  VENDOR,
-  RESERVED
-};
-
-enum ControlTransferRecipient {
-  DEVICE,
-  INTERFACE,
-  ENDPOINT,
-  OTHER
-};
-
-enum EndpointType {
-  BULK,
-  INTERRUPT,
-  ISOCHRONOUS,
-};
-
-struct EndpointInfo {
-  uint8 endpoint_number;
-  TransferDirection direction;
-  EndpointType type;
-  uint32 packet_size;
-};
-
-struct AlternateInterfaceInfo {
-  uint8 alternate_setting;
-  uint8 class_code;
-  uint8 subclass_code;
-  uint8 protocol_code;
-  string? interface_name;
-  array<EndpointInfo> endpoints;
-};
-
-struct InterfaceInfo {
-  uint8 interface_number;
-  array<AlternateInterfaceInfo> alternates;
-};
-
-struct ConfigurationInfo {
-  uint8 configuration_value;
-  string? configuration_name;
-  array<InterfaceInfo> interfaces;
-};
-
-struct WebUsbFunctionSubset {
-  uint8 first_interface;
-  array<string> origins;
-};
-
-struct WebUsbConfigurationSubset {
-  uint8 configuration_value;
-  array<string> origins;
-  array<WebUsbFunctionSubset> functions;
-};
-
-struct WebUsbDescriptorSet {
-  array<string> origins;
-  array<WebUsbConfigurationSubset> configurations;
-};
-
-struct DeviceInfo {
-  string guid;
-  uint8 usb_version_major;
-  uint8 usb_version_minor;
-  uint8 usb_version_subminor;
-  uint8 class_code;
-  uint8 subclass_code;
-  uint8 protocol_code;
-  uint16 vendor_id;
-  uint16 product_id;
-  uint8 device_version_major;
-  uint8 device_version_minor;
-  uint8 device_version_subminor;
-  string? manufacturer_name;
-  string? product_name;
-  string? serial_number;
-  array<ConfigurationInfo> configurations;
-  WebUsbDescriptorSet? webusb_allowed_origins;
-};
-
-struct ControlTransferParams {
-  ControlTransferType type;
-  ControlTransferRecipient recipient;
-  uint8 request;
-  uint16 value;
-  uint16 index;
-};
-
-enum TransferStatus {
-  // The transfer completed successfully.
-  COMPLETED,
-
-  // The transfer failed due to a non-specific error.
-  TRANSFER_ERROR,
-
-  // The transfer was not allowed.
-  PERMISSION_DENIED,
-
-  // The transfer timed out.
-  TIMEOUT,
-
-  // The transfer was cancelled.
-  CANCELLED,
-
-  // The transfer stalled.
-  STALLED,
-
-  // The transfer failed because the device was disconnected from the host.
-  DISCONNECT,
-
-  // The transfer succeeded, but the device sent more data than was requested.
-  // This applies only to inbound transfers.
-  BABBLE,
-
-  // The transfer succeeded, but the device sent less data than was requested.
-  // This applies only to inbound transfers.
-  SHORT_PACKET,
-};
-
-struct IsochronousPacket {
-  uint32 length;
-  uint32 transferred_length;
-  TransferStatus status;
-};
-
-interface Device {
-  // Retrieve a DeviceInfo struct containing metadata about the device,
-  // including the set of all available device configurations.
-  GetDeviceInfo() => (DeviceInfo? info);
-
-  // Retrieves the |configuration_value| of the device's currently active
-  // configuration. Will return 0 if the device is unconfigured.
-  GetConfiguration() => (uint8 value);
-
-  // Opens the device. Methods below require the device be opened first.
-  Open() => (OpenDeviceError error);
-
-  // Closes the device.
-  Close() => ();
-
-  // Initiates a device control transfer to set the device's configuration to
-  // one with the configuration value |value|.
-  SetConfiguration(uint8 value) => (bool success);
-
-  // Claims a single interface in the current device configuration.
-  ClaimInterface(uint8 interface_number) => (bool success);
-
-  // Releases a claimed interface in the current device configuration.
-  ReleaseInterface(uint8 interface_number) => (bool success);
-
-  // Selects an alternate setting for a given claimed interface.
-  SetInterfaceAlternateSetting(uint8 interface_number, uint8 alternate_setting)
-      => (bool success);
-
-  // Resets the device.
-  Reset() => (bool success);
-
-  // Clear the halt/stall condition for an endpoint.
-  ClearHalt(uint8 endpoint) => (bool success);
-
-  // Initiates an inbound control transfer request. |params| determine the
-  // details of the request. Transfers to recipients other than DEVICE require a
-  // corresponding interface to be claimed.
-  //
-  // |length| specifies the expected number of bytes to receive for this
-  // transfer. The size of |data| will never exceed |length|, and |data| will be
-  // null if |status| is neither COMPLETED, BABBLE, or SHORT_PACKET.
-  //
-  // |timeout| specifies the request timeout in milliseconds. A timeout of 0
-  // indicates no timeout: the request will remain pending indefinitely until
-  // completed or otherwise terminated.
-  ControlTransferIn(ControlTransferParams params, uint32 length, uint32 timeout)
-      => (TransferStatus status, array<uint8>? data);
-
-  // Initiates an inbound control transfer request. |params| determine the
-  // details of the request. Transfers to recipients other than DEVICE require a
-  // corresponding interface to be claimed.
-  //
-  // |data| specifies the bytes to send the device in the body of the request.
-  //
-  // |timeout| specifies the request timeout in milliseconds. A timeout of 0
-  // indicates no timeout: the request will remain pending indefinitely until
-  // completed or otherwise terminated.
-  ControlTransferOut(ControlTransferParams params,
-                     array<uint8> data,
-                     uint32 timeout)
-      => (TransferStatus status);
-
-  // Initiates an inbound generic transfer request on a specific endpoint. The
-  // interface to which |endpoint_number| belongs must be claimed, and the
-  // appropriate alternate setting must be set on that interface before
-  // transfers can be initiated on the endpoint. The endpoint must be of type
-  // BULK or INTERRUPT.
-  //
-  // |length| specifies the expected number of bytes to receive for this
-  // transfer. The size of |data| will never exceed |length|, and |data| will be
-  // null if |status| is neither COMPLETED, BABBLE, or SHORT_PACKET.
-  //
-  // |timeout| specifies the request timeout in milliseconds. A timeout of 0
-  // indicates no timeout: the request will remain pending indefinitely until
-  // completed or otherwise terminated.
-  GenericTransferIn(uint8 endpoint_number, uint32 length, uint32 timeout)
-      => (TransferStatus status, array<uint8>? data);
-
-  // Initiates an outbound generic transfer request on a specific endpoint. The
-  // interface to which |endpoint_number| belongs must be claimed, and the
-  // appropriate alternate setting must be set on that interface before
-  // transfers can be initiated on the endpoint. The endpoint must be of type
-  // BULK or INTERRUPT.
-  //
-  // |data| specifies the bytes to send the device in the body of the request.
-  //
-  // |timeout| specifies the request timeout in milliseconds. A timeout of 0
-  // indicates no timeout: the request will remain pending indefinitely until
-  // completed or otherwise terminated.
-  GenericTransferOut(uint8 endpoint_number, array<uint8> data, uint32 timeout)
-      => (TransferStatus status);
-
-  // Initiates an inbound isochronous transfer request on a specific endpoint.
-  // The interface to which |endpoint_number| belongs must be claimed, and the
-  // appropriate alternate setting must be set on that interface before
-  // transfers can be initiated on the endpoint. The endpoint must be of type
-  // ISOCHRONOUS.
-  //
-  // |packet_lengths| specifies the maximum expected number of bytes to receive
-  // for each packet in this transfer.
-  //
-  // |timeout| specifies the request timeout in milliseconds. A timeout of 0
-  // indicates no timeout: the request will remain pending indefinitely until
-  // completed or otherwise terminated.
-  //
-  // |data| contains the data received from the device, if any. |packets|
-  // contains the status of each packet received from the device, in order. The
-  // length of the packet indicates its position in |data| while it's
-  // transferred length gives the amount of data actually received from the
-  // device.
-  IsochronousTransferIn(uint8 endpoint_number,
-                        array<uint32> packet_lengths,
-                        uint32 timeout)
-      => (array<uint8>? data, array<IsochronousPacket> packets);
-
-  // Initiates an outbound isochronous transfer request on a specific endpoint.
-  // The interface to which |endpoint_number| belongs must be claimed, and the
-  // appropriate alternate setting must be set on that interface before
-  // transfers can be initiated on the endpoint. The endpoint must be of type
-  // ISOCHRONOUS.
-  //
-  // |data| specifies the bytes to send to the device.
-  //
-  // |packet_lengths| specifies how |data| should be separated into packets when
-  // it is sent to the device.
-  //
-  // |timeout| specifies the request timeout in milliseconds. A timeout of 0
-  // indicates no timeout: the request will remain pending indefinitely until
-  // completed or otherwise terminated.
-
-  // |packets| contains the status of each packet sent to the device, in order.
-  IsochronousTransferOut(uint8 endpoint_number,
-                         array<uint8> data,
-                         array<uint32> packet_lengths,
-                         uint32 timeout)
-      => (array<IsochronousPacket> packets);
-};
diff --git a/device/devices_app/usb/public/interfaces/device_manager.mojom b/device/devices_app/usb/public/interfaces/device_manager.mojom
deleted file mode 100644
index fa8bb75..0000000
--- a/device/devices_app/usb/public/interfaces/device_manager.mojom
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-
-module device.usb;
-
-import "device.mojom";
-
-struct DeviceFilter {
-  bool has_vendor_id;
-  uint16 vendor_id;
-
-  bool has_product_id;
-  uint16 product_id;
-
-  bool has_class_code;
-  uint8 class_code;
-
-  bool has_subclass_code;
-  uint8 subclass_code;
-
-  bool has_protocol_code;
-  uint8 protocol_code;
-};
-
-struct EnumerationOptions {
-  array<DeviceFilter>? filters;
-};
-
-struct DeviceChangeNotification {
-  array<DeviceInfo> devices_added;
-  array<DeviceInfo> devices_removed;
-};
-
-interface DeviceManager {
-  // Retrieves information about all devices available to the DeviceManager
-  // implementation.
-  GetDevices(EnumerationOptions? options) => (array<DeviceInfo> results);
-
-  // Retrieves information about changes to the set of devices available to the
-  // DeviceManager since the last call to this method. A device that is added
-  // and removed between calls will not be included.
-  GetDeviceChanges() => (DeviceChangeNotification changes);
-
-  // Requests a device by guid.
-  GetDevice(string guid, Device& device_request);
-};
diff --git a/device/devices_app/usb/public/interfaces/permission_provider.mojom b/device/devices_app/usb/public/interfaces/permission_provider.mojom
deleted file mode 100644
index f5d7111..0000000
--- a/device/devices_app/usb/public/interfaces/permission_provider.mojom
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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.
-
-module device.usb;
-
-import "device.mojom";
-
-interface PermissionProvider {
-  // Filters a set of |requested_devices| down to the set of |allowed_guids|
-  // that should be accessible to clients of the DeviceManager instance.
-  HasDevicePermission(array<DeviceInfo> requested_devices)
-      => (array<string> allowed_guids);
-
-  // Returns whether or not the client has permission to access
-  // |requested_configuration| on |device|.
-  HasConfigurationPermission(uint8 requested_configuration,
-                             DeviceInfo device) => (bool allowed);
-
-  // Returns whether or not the client has permission to access
-  // |requested_interface| on |device| when it is in configuration
-  // |configuration_value|.
-  HasInterfacePermission(uint8 requested_interface,
-                         uint8 configuration_value,
-                         DeviceInfo device) => (bool allowed);
-
-  // Requests a new binding to this service.
-  Bind(PermissionProvider& request);
-};
diff --git a/device/devices_app/usb/type_converters.cc b/device/devices_app/usb/type_converters.cc
deleted file mode 100644
index 709b0ca..0000000
--- a/device/devices_app/usb/type_converters.cc
+++ /dev/null
@@ -1,283 +0,0 @@
-// 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 "device/devices_app/usb/type_converters.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <utility>
-
-#include "base/logging.h"
-#include "base/strings/utf_string_conversions.h"
-#include "device/usb/usb_device.h"
-#include "mojo/common/url_type_converters.h"
-#include "mojo/public/cpp/bindings/array.h"
-
-namespace mojo {
-
-// static
-device::UsbDeviceFilter
-TypeConverter<device::UsbDeviceFilter, device::usb::DeviceFilterPtr>::Convert(
-    const device::usb::DeviceFilterPtr& mojo_filter) {
-  device::UsbDeviceFilter filter;
-  if (mojo_filter->has_vendor_id)
-    filter.SetVendorId(mojo_filter->vendor_id);
-  if (mojo_filter->has_product_id)
-    filter.SetProductId(mojo_filter->product_id);
-  if (mojo_filter->has_class_code)
-    filter.SetInterfaceClass(mojo_filter->class_code);
-  if (mojo_filter->has_subclass_code)
-    filter.SetInterfaceSubclass(mojo_filter->subclass_code);
-  if (mojo_filter->has_protocol_code)
-    filter.SetInterfaceProtocol(mojo_filter->protocol_code);
-  return filter;
-}
-
-// static
-device::usb::TransferDirection
-TypeConverter<device::usb::TransferDirection, device::UsbEndpointDirection>::
-    Convert(const device::UsbEndpointDirection& direction) {
-  if (direction == device::USB_DIRECTION_INBOUND)
-    return device::usb::TransferDirection::INBOUND;
-  DCHECK(direction == device::USB_DIRECTION_OUTBOUND);
-  return device::usb::TransferDirection::OUTBOUND;
-}
-
-// static
-device::usb::TransferStatus
-TypeConverter<device::usb::TransferStatus, device::UsbTransferStatus>::Convert(
-    const device::UsbTransferStatus& status) {
-  switch (status) {
-    case device::USB_TRANSFER_COMPLETED:
-      return device::usb::TransferStatus::COMPLETED;
-    case device::USB_TRANSFER_ERROR:
-      return device::usb::TransferStatus::TRANSFER_ERROR;
-    case device::USB_TRANSFER_TIMEOUT:
-      return device::usb::TransferStatus::TIMEOUT;
-    case device::USB_TRANSFER_CANCELLED:
-      return device::usb::TransferStatus::CANCELLED;
-    case device::USB_TRANSFER_STALLED:
-      return device::usb::TransferStatus::STALLED;
-    case device::USB_TRANSFER_DISCONNECT:
-      return device::usb::TransferStatus::DISCONNECT;
-    case device::USB_TRANSFER_OVERFLOW:
-      return device::usb::TransferStatus::BABBLE;
-    case device::USB_TRANSFER_LENGTH_SHORT:
-      return device::usb::TransferStatus::SHORT_PACKET;
-    default:
-      NOTREACHED();
-      return device::usb::TransferStatus::TRANSFER_ERROR;
-  }
-}
-
-// static
-device::UsbDeviceHandle::TransferRequestType
-TypeConverter<device::UsbDeviceHandle::TransferRequestType,
-              device::usb::ControlTransferType>::
-    Convert(const device::usb::ControlTransferType& type) {
-  switch (type) {
-    case device::usb::ControlTransferType::STANDARD:
-      return device::UsbDeviceHandle::STANDARD;
-    case device::usb::ControlTransferType::CLASS:
-      return device::UsbDeviceHandle::CLASS;
-    case device::usb::ControlTransferType::VENDOR:
-      return device::UsbDeviceHandle::VENDOR;
-    case device::usb::ControlTransferType::RESERVED:
-      return device::UsbDeviceHandle::RESERVED;
-    default:
-      NOTREACHED();
-      return device::UsbDeviceHandle::RESERVED;
-  }
-}
-
-// static
-device::UsbDeviceHandle::TransferRecipient
-TypeConverter<device::UsbDeviceHandle::TransferRecipient,
-              device::usb::ControlTransferRecipient>::
-    Convert(const device::usb::ControlTransferRecipient& recipient) {
-  switch (recipient) {
-    case device::usb::ControlTransferRecipient::DEVICE:
-      return device::UsbDeviceHandle::DEVICE;
-    case device::usb::ControlTransferRecipient::INTERFACE:
-      return device::UsbDeviceHandle::INTERFACE;
-    case device::usb::ControlTransferRecipient::ENDPOINT:
-      return device::UsbDeviceHandle::ENDPOINT;
-    case device::usb::ControlTransferRecipient::OTHER:
-      return device::UsbDeviceHandle::OTHER;
-    default:
-      NOTREACHED();
-      return device::UsbDeviceHandle::OTHER;
-  }
-}
-
-// static
-device::usb::EndpointType
-TypeConverter<device::usb::EndpointType, device::UsbTransferType>::Convert(
-    const device::UsbTransferType& type) {
-  switch (type) {
-    case device::USB_TRANSFER_ISOCHRONOUS:
-      return device::usb::EndpointType::ISOCHRONOUS;
-    case device::USB_TRANSFER_BULK:
-      return device::usb::EndpointType::BULK;
-    case device::USB_TRANSFER_INTERRUPT:
-      return device::usb::EndpointType::INTERRUPT;
-    // Note that we do not expose control transfer in the public interface
-    // because control endpoints are implied rather than explicitly enumerated
-    // there.
-    default:
-      NOTREACHED();
-      return device::usb::EndpointType::BULK;
-  }
-}
-
-// static
-device::usb::EndpointInfoPtr
-TypeConverter<device::usb::EndpointInfoPtr, device::UsbEndpointDescriptor>::
-    Convert(const device::UsbEndpointDescriptor& endpoint) {
-  device::usb::EndpointInfoPtr info = device::usb::EndpointInfo::New();
-  info->endpoint_number = endpoint.address;
-  info->direction =
-      ConvertTo<device::usb::TransferDirection>(endpoint.direction);
-  info->type = ConvertTo<device::usb::EndpointType>(endpoint.transfer_type);
-  info->packet_size = static_cast<uint32_t>(endpoint.maximum_packet_size);
-  return info;
-}
-
-// static
-device::usb::AlternateInterfaceInfoPtr
-TypeConverter<device::usb::AlternateInterfaceInfoPtr,
-              device::UsbInterfaceDescriptor>::
-    Convert(const device::UsbInterfaceDescriptor& interface) {
-  device::usb::AlternateInterfaceInfoPtr info =
-      device::usb::AlternateInterfaceInfo::New();
-  info->alternate_setting = interface.alternate_setting;
-  info->class_code = interface.interface_class;
-  info->subclass_code = interface.interface_subclass;
-  info->protocol_code = interface.interface_protocol;
-
-  // Filter out control endpoints for the public interface.
-  info->endpoints = mojo::Array<device::usb::EndpointInfoPtr>::New(0);
-  for (const auto& endpoint : interface.endpoints) {
-    if (endpoint.transfer_type != device::USB_TRANSFER_CONTROL)
-      info->endpoints.push_back(device::usb::EndpointInfo::From(endpoint));
-  }
-
-  return info;
-}
-
-// static
-mojo::Array<device::usb::InterfaceInfoPtr>
-TypeConverter<mojo::Array<device::usb::InterfaceInfoPtr>,
-              std::vector<device::UsbInterfaceDescriptor>>::
-    Convert(const std::vector<device::UsbInterfaceDescriptor>& interfaces) {
-  auto infos = mojo::Array<device::usb::InterfaceInfoPtr>::New(0);
-
-  // Aggregate each alternate setting into an InterfaceInfo corresponding to its
-  // interface number.
-  std::map<uint8_t, device::usb::InterfaceInfo*> interface_map;
-  for (size_t i = 0; i < interfaces.size(); ++i) {
-    auto alternate = device::usb::AlternateInterfaceInfo::From(interfaces[i]);
-    auto iter = interface_map.find(interfaces[i].interface_number);
-    if (iter == interface_map.end()) {
-      // This is the first time we're seeing an alternate with this interface
-      // number, so add a new InterfaceInfo to the array and map the number.
-      auto info = device::usb::InterfaceInfo::New();
-      iter = interface_map.insert(std::make_pair(interfaces[i].interface_number,
-                                                 info.get())).first;
-      infos.push_back(std::move(info));
-    }
-    iter->second->alternates.push_back(std::move(alternate));
-  }
-
-  return infos;
-}
-
-// static
-device::usb::ConfigurationInfoPtr
-TypeConverter<device::usb::ConfigurationInfoPtr, device::UsbConfigDescriptor>::
-    Convert(const device::UsbConfigDescriptor& config) {
-  device::usb::ConfigurationInfoPtr info =
-      device::usb::ConfigurationInfo::New();
-  info->configuration_value = config.configuration_value;
-  info->interfaces =
-      mojo::Array<device::usb::InterfaceInfoPtr>::From(config.interfaces);
-  return info;
-}
-
-// static
-device::usb::WebUsbFunctionSubsetPtr TypeConverter<
-    device::usb::WebUsbFunctionSubsetPtr,
-    device::WebUsbFunctionSubset>::Convert(const device::WebUsbFunctionSubset&
-                                               function) {
-  device::usb::WebUsbFunctionSubsetPtr info =
-      device::usb::WebUsbFunctionSubset::New();
-  info->first_interface = function.first_interface;
-  info->origins = mojo::Array<mojo::String>::From(function.origins);
-  return info;
-}
-
-// static
-device::usb::WebUsbConfigurationSubsetPtr
-TypeConverter<device::usb::WebUsbConfigurationSubsetPtr,
-              device::WebUsbConfigurationSubset>::
-    Convert(const device::WebUsbConfigurationSubset& config) {
-  device::usb::WebUsbConfigurationSubsetPtr info =
-      device::usb::WebUsbConfigurationSubset::New();
-  info->configuration_value = config.configuration_value;
-  info->origins = mojo::Array<mojo::String>::From(config.origins);
-  info->functions =
-      mojo::Array<device::usb::WebUsbFunctionSubsetPtr>::From(config.functions);
-  return info;
-}
-
-// static
-device::usb::WebUsbDescriptorSetPtr TypeConverter<
-    device::usb::WebUsbDescriptorSetPtr,
-    device::WebUsbAllowedOrigins>::Convert(const device::WebUsbAllowedOrigins&
-                                               allowed_origins) {
-  device::usb::WebUsbDescriptorSetPtr info =
-      device::usb::WebUsbDescriptorSet::New();
-  info->origins = mojo::Array<mojo::String>::From(allowed_origins.origins);
-  info->configurations =
-      mojo::Array<device::usb::WebUsbConfigurationSubsetPtr>::From(
-          allowed_origins.configurations);
-  return info;
-}
-
-// static
-device::usb::DeviceInfoPtr
-TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice>::Convert(
-    const device::UsbDevice& device) {
-  device::usb::DeviceInfoPtr info = device::usb::DeviceInfo::New();
-  info->guid = device.guid();
-  info->vendor_id = device.vendor_id();
-  info->product_id = device.product_id();
-  info->manufacturer_name = base::UTF16ToUTF8(device.manufacturer_string());
-  info->product_name = base::UTF16ToUTF8(device.product_string());
-  info->serial_number = base::UTF16ToUTF8(device.serial_number());
-  info->configurations = mojo::Array<device::usb::ConfigurationInfoPtr>::From(
-      device.configurations());
-  if (device.webusb_allowed_origins()) {
-    info->webusb_allowed_origins = device::usb::WebUsbDescriptorSet::From(
-        *device.webusb_allowed_origins());
-  }
-  return info;
-}
-
-// static
-device::usb::IsochronousPacketPtr
-TypeConverter<device::usb::IsochronousPacketPtr,
-              device::UsbDeviceHandle::IsochronousPacket>::
-    Convert(const device::UsbDeviceHandle::IsochronousPacket& packet) {
-  device::usb::IsochronousPacketPtr info =
-      device::usb::IsochronousPacket::New();
-  info->length = packet.length;
-  info->transferred_length = packet.transferred_length;
-  info->status = mojo::ConvertTo<device::usb::TransferStatus>(packet.status);
-  return info;
-}
-
-}  // namespace mojo
diff --git a/device/devices_app/usb/type_converters.h b/device/devices_app/usb/type_converters.h
deleted file mode 100644
index 15484ea..0000000
--- a/device/devices_app/usb/type_converters.h
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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.
-
-#ifndef DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_
-#define DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_
-
-#include <vector>
-
-#include "device/devices_app/usb/public/interfaces/device.mojom.h"
-#include "device/devices_app/usb/public/interfaces/device_manager.mojom.h"
-#include "device/usb/usb_descriptors.h"
-#include "device/usb/usb_device_filter.h"
-#include "device/usb/usb_device_handle.h"
-#include "device/usb/webusb_descriptors.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "mojo/public/cpp/bindings/type_converter.h"
-
-// Type converters to translate between internal device/usb data types and
-// public Mojo interface data types. This must be included by any source file
-// that uses these conversions explicitly or implicitly.
-
-namespace device {
-class UsbDevice;
-}
-
-namespace mojo {
-
-template <>
-struct TypeConverter<device::UsbDeviceFilter, device::usb::DeviceFilterPtr> {
-  static device::UsbDeviceFilter Convert(
-      const device::usb::DeviceFilterPtr& mojo_filter);
-};
-
-template <>
-struct TypeConverter<device::usb::TransferDirection,
-                     device::UsbEndpointDirection> {
-  static device::usb::TransferDirection Convert(
-      const device::UsbEndpointDirection& direction);
-};
-
-template <>
-struct TypeConverter<device::usb::TransferStatus, device::UsbTransferStatus> {
-  static device::usb::TransferStatus Convert(
-      const device::UsbTransferStatus& status);
-};
-
-template <>
-struct TypeConverter<device::UsbDeviceHandle::TransferRequestType,
-                     device::usb::ControlTransferType> {
-  static device::UsbDeviceHandle::TransferRequestType Convert(
-      const device::usb::ControlTransferType& type);
-};
-
-template <>
-struct TypeConverter<device::UsbDeviceHandle::TransferRecipient,
-                     device::usb::ControlTransferRecipient> {
-  static device::UsbDeviceHandle::TransferRecipient Convert(
-      const device::usb::ControlTransferRecipient& recipient);
-};
-
-template <>
-struct TypeConverter<device::usb::EndpointType, device::UsbTransferType> {
-  static device::usb::EndpointType Convert(const device::UsbTransferType& type);
-};
-
-template <>
-struct TypeConverter<device::usb::EndpointInfoPtr,
-                     device::UsbEndpointDescriptor> {
-  static device::usb::EndpointInfoPtr Convert(
-      const device::UsbEndpointDescriptor& endpoint);
-};
-
-template <>
-struct TypeConverter<device::usb::AlternateInterfaceInfoPtr,
-                     device::UsbInterfaceDescriptor> {
-  static device::usb::AlternateInterfaceInfoPtr Convert(
-      const device::UsbInterfaceDescriptor& interface);
-};
-
-// Note that this is an explicit vector-to-array conversion, as
-// UsbInterfaceDescriptor collections are flattened to contain all alternate
-// settings, whereas InterfaceInfos contain their own sets of alternates with
-// a different structure type.
-template <>
-struct TypeConverter<mojo::Array<device::usb::InterfaceInfoPtr>,
-                     std::vector<device::UsbInterfaceDescriptor>> {
-  static mojo::Array<device::usb::InterfaceInfoPtr> Convert(
-      const std::vector<device::UsbInterfaceDescriptor>& interfaces);
-};
-
-template <>
-struct TypeConverter<device::usb::ConfigurationInfoPtr,
-                     device::UsbConfigDescriptor> {
-  static device::usb::ConfigurationInfoPtr Convert(
-      const device::UsbConfigDescriptor& config);
-};
-
-template <>
-struct TypeConverter<device::usb::WebUsbFunctionSubsetPtr,
-                     device::WebUsbFunctionSubset> {
-  static device::usb::WebUsbFunctionSubsetPtr Convert(
-      const device::WebUsbFunctionSubset& function);
-};
-
-template <>
-struct TypeConverter<device::usb::WebUsbConfigurationSubsetPtr,
-                     device::WebUsbConfigurationSubset> {
-  static device::usb::WebUsbConfigurationSubsetPtr Convert(
-      const device::WebUsbConfigurationSubset& config);
-};
-
-template <>
-struct TypeConverter<device::usb::WebUsbDescriptorSetPtr,
-                     device::WebUsbAllowedOrigins> {
-  static device::usb::WebUsbDescriptorSetPtr Convert(
-      const device::WebUsbAllowedOrigins& allowed_origins);
-};
-
-template <>
-struct TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice> {
-  static device::usb::DeviceInfoPtr Convert(const device::UsbDevice& device);
-};
-
-template <>
-struct TypeConverter<device::usb::IsochronousPacketPtr,
-                     device::UsbDeviceHandle::IsochronousPacket> {
-  static device::usb::IsochronousPacketPtr Convert(
-      const device::UsbDeviceHandle::IsochronousPacket& packet);
-};
-
-}  // namespace mojo
-
-#endif  // DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_