diff --git a/host/commands/assemble_cvd/flags.cc b/host/commands/assemble_cvd/flags.cc
index f776042..400a686 100644
--- a/host/commands/assemble_cvd/flags.cc
+++ b/host/commands/assemble_cvd/flags.cc
@@ -98,17 +98,15 @@
 DEFINE_int32(vnc_server_port, GetPerInstanceDefault(6444),
              "The port on which the vnc server should listen");
 DEFINE_string(adb_mode, "vsock_half_tunnel",
-              "Mode for ADB connection. Can be 'usb' for USB forwarding, "
-              "'tunnel' for a TCP connection tunneled through VSoC, "
+              "Mode for ADB connection."
               "'vsock_tunnel' for a TCP connection tunneled through vsock, "
               "'native_vsock' for a  direct connection to the guest ADB over "
               "vsock, 'vsock_half_tunnel' for a TCP connection forwarded to "
               "the guest ADB server, or a comma separated list of types as in "
-              "'usb,tunnel'");
+              "'native_vsock,vsock_half_tunnel'");
 DEFINE_bool(run_adb_connector, true,
             "Maintain adb connection by sending 'adb connect' commands to the "
             "server. Only relevant with -adb_mode=tunnel or vsock_tunnel");
-DEFINE_int32(vhci_port, GetPerInstanceDefault(0), "VHCI port to use for usb");
 DEFINE_string(wifi_tap_name, GetPerInstanceDefault("cvd-wtap-"),
               "The name of the tap interface to use for wifi");
 DEFINE_int32(vsock_guest_cid,
@@ -291,14 +289,6 @@
     }
   }
 
-  if (tmp_config_obj.adb_mode().count(vsoc::AdbMode::Usb) > 0) {
-    tmp_config_obj.set_usb_v1_socket_name(
-        tmp_config_obj.PerInstanceInternalPath("usb-v1"));
-    tmp_config_obj.set_vhci_port(FLAGS_vhci_port);
-    tmp_config_obj.set_usb_ip_socket_name(
-        tmp_config_obj.PerInstanceInternalPath("usb-ip"));
-  }
-
   tmp_config_obj.set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
   tmp_config_obj.set_logcat_receiver_binary(
       vsoc::DefaultHostArtifactsPath("bin/logcat_receiver"));
@@ -330,8 +320,6 @@
   tmp_config_obj.set_run_adb_connector(FLAGS_run_adb_connector);
   tmp_config_obj.set_adb_connector_binary(
       vsoc::DefaultHostArtifactsPath("bin/adb_connector"));
-  tmp_config_obj.set_virtual_usb_manager_binary(
-      vsoc::DefaultHostArtifactsPath("bin/virtual_usb_manager"));
   tmp_config_obj.set_socket_vsock_proxy_binary(
       vsoc::DefaultHostArtifactsPath("bin/socket_vsock_proxy"));
   tmp_config_obj.set_run_as_daemon(FLAGS_daemon);
@@ -340,10 +328,6 @@
   tmp_config_obj.set_blank_data_image_mb(FLAGS_blank_data_image_mb);
   tmp_config_obj.set_blank_data_image_fmt(FLAGS_blank_data_image_fmt);
 
-  if(tmp_config_obj.adb_mode().count(vsoc::AdbMode::Usb) == 0) {
-    tmp_config_obj.disable_usb_adb();
-  }
-
   tmp_config_obj.set_logcat_mode(FLAGS_logcat_mode);
 
   tmp_config_obj.set_enable_tombstone_receiver(FLAGS_enable_tombstone_receiver);
diff --git a/host/commands/run_cvd/launch.cc b/host/commands/run_cvd/launch.cc
index 227984d..44e32fa 100644
--- a/host/commands/run_cvd/launch.cc
+++ b/host/commands/run_cvd/launch.cc
@@ -53,10 +53,6 @@
       && AdbModeEnabled(config, vsoc::AdbMode::NativeVsock);
 }
 
-bool AdbUsbEnabled(const vsoc::CuttlefishConfig& config) {
-  return AdbModeEnabled(config, vsoc::AdbMode::Usb);
-}
-
 cvd::OnSocketReadyCb GetOnSubprocessExitCallback(
     const vsoc::CuttlefishConfig& config) {
   if (config.restart_subprocesses()) {
@@ -183,25 +179,6 @@
   return { socket->VsockServerPort() };
 }
 
-void LaunchUsbServerIfEnabled(const vsoc::CuttlefishConfig& config,
-                              cvd::ProcessMonitor* process_monitor) {
-  if (!AdbUsbEnabled(config)) {
-    return;
-  }
-  auto socket_name = config.usb_v1_socket_name();
-  auto usb_v1_server = cvd::SharedFD::SocketLocalServer(
-      socket_name.c_str(), false, SOCK_STREAM, 0666);
-  if (!usb_v1_server->IsOpen()) {
-    LOG(ERROR) << "Unable to create USB v1 server socket: "
-               << usb_v1_server->StrError();
-    std::exit(cvd::RunnerExitCodes::kUsbV1SocketError);
-  }
-  cvd::Command usb_server(config.virtual_usb_manager_binary());
-  usb_server.AddParameter("-usb_v1_fd=", usb_v1_server);
-  process_monitor->StartSubprocess(std::move(usb_server),
-                                   GetOnSubprocessExitCallback(config));
-}
-
 cvd::SharedFD CreateUnixVncInputServer(const std::string& path) {
   auto server = cvd::SharedFD::SocketLocalServer(path.c_str(), false, SOCK_STREAM, 0666);
   if (!server->IsOpen()) {
diff --git a/host/commands/run_cvd/launch.h b/host/commands/run_cvd/launch.h
index efd4966..95455ef 100644
--- a/host/commands/run_cvd/launch.h
+++ b/host/commands/run_cvd/launch.h
@@ -13,8 +13,6 @@
     const vsoc::CuttlefishConfig& config,
     cvd::ProcessMonitor* process_monitor,
     unsigned int number_of_event_pipes);
-void LaunchUsbServerIfEnabled(const vsoc::CuttlefishConfig& config,
-                              cvd::ProcessMonitor* process_monitor);
 void LaunchAdbConnectorIfEnabled(cvd::ProcessMonitor* process_monitor,
                                  const vsoc::CuttlefishConfig& config,
                                  cvd::SharedFD adbd_events_pipe);
diff --git a/host/commands/run_cvd/main.cc b/host/commands/run_cvd/main.cc
index c4972bc..e352393 100644
--- a/host/commands/run_cvd/main.cc
+++ b/host/commands/run_cvd/main.cc
@@ -159,13 +159,7 @@
   }
   std::string config_env = "export CUTTLEFISH_PER_INSTANCE_PATH=\"" +
                            config.PerInstancePath(".") + "\"\n";
-  config_env += "export ANDROID_SERIAL=";
-  if (config.adb_mode().count(vsoc::AdbMode::Usb) > 0) {
-    config_env += config.serial_number();
-  } else {
-    config_env += config.adb_ip_and_port();
-  }
-  config_env += "\n";
+  config_env += "export ANDROID_SERIAL=" + config.adb_ip_and_port() + "\n";
   env->Write(config_env.c_str(), config_env.size());
   return true;
 }
@@ -413,8 +407,6 @@
   auto tombstone_server = LaunchTombstoneReceiverIfEnabled(*config, &process_monitor);
   auto tombstone_kernel_args = KernelCommandLineFromTombstone(tombstone_server);
 
-  LaunchUsbServerIfEnabled(*config, &process_monitor);
-
   // The vnc server needs to be launched after the ivserver because it connects
   // to it when using qemu. It needs to launch before the VMM because it serves
   // on several sockets (input devices, vsock frame server) when using crosvm.
diff --git a/host/commands/virtual_usb_manager/Android.bp b/host/commands/virtual_usb_manager/Android.bp
deleted file mode 100644
index 6669b8c..0000000
--- a/host/commands/virtual_usb_manager/Android.bp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright (C) 2017 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-cc_binary_host {
-    name: "virtual_usb_manager",
-    srcs: [
-        "main.cc",
-        "vadb/usb_cmd_attach.cpp",
-        "vadb/usb_cmd_control_transfer.cpp",
-        "vadb/usb_cmd_data_transfer.cpp",
-        "vadb/usb_cmd_device_list.cpp",
-        "vadb/usb_cmd_heartbeat.cpp",
-        "vadb/virtual_adb_client.cpp",
-        "vadb/virtual_adb_server.cpp",
-        "usbip/client.cpp",
-        "usbip/device_pool.cpp",
-        "usbip/messages.cpp",
-        "usbip/server.cpp",
-        "usbip/vhci_instrument.cpp",
-    ],
-    header_libs: [
-        "cuttlefish_glog",
-    ],
-    shared_libs: [
-        "libcuttlefish_fs",
-        "libcuttlefish_utils",
-        "libbase",
-    ],
-    static_libs: [
-        "libcuttlefish_host_config",
-        "libgflags",
-        "libjsoncpp",
-    ],
-    defaults: ["cuttlefish_host_only"],
-}
diff --git a/host/commands/virtual_usb_manager/main.cc b/host/commands/virtual_usb_manager/main.cc
deleted file mode 100644
index 39fd556..0000000
--- a/host/commands/virtual_usb_manager/main.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <string>
-#include <thread>
-
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-
-#include "common/libs/fs/shared_fd.h"
-#include "common/libs/fs/shared_select.h"
-#include "host/libs/config/cuttlefish_config.h"
-#include "host/commands/virtual_usb_manager/usbip/server.h"
-#include "host/commands/virtual_usb_manager/vadb/virtual_adb_server.h"
-
-DEFINE_int32(
-    usb_v1_fd, -1,
-    "A file descriptor pointing to the USB v1 open socket or -1 to create it");
-
-int main(int argc, char** argv) {
-  ::android::base::InitLogging(argv, android::base::StderrLogger);
-  google::ParseCommandLineFlags(&argc, &argv, true);
-
-  auto config = vsoc::CuttlefishConfig::Get();
-  if (!config) {
-    LOG(ERROR) << "Unable to get config object";
-    return 1;
-  }
-
-  cvd::SharedFD usb_v1_server;
-
-  if (FLAGS_usb_v1_fd < 0) {
-    auto socket_name = config->usb_v1_socket_name();
-    LOG(INFO) << "Starting server at " << socket_name;
-    usb_v1_server = cvd::SharedFD::SocketLocalServer(socket_name.c_str(), false,
-                                                     SOCK_STREAM, 0666);
-  } else {
-    usb_v1_server = cvd::SharedFD::Dup(FLAGS_usb_v1_fd);
-  }
-
-  if (!usb_v1_server->IsOpen()) {
-    LOG(ERROR) << "Error openning USB v1 server: " << usb_v1_server->StrError();
-    return 2;
-  }
-
-  vadb::VirtualADBServer adb_{usb_v1_server, config->vhci_port(),
-                              config->usb_ip_socket_name()};
-  vadb::usbip::Server usbip_{config->usb_ip_socket_name(), adb_.Pool()};
-
-  CHECK(usbip_.Init()) << "Could not start USB/IP server";
-
-  for (;;) {
-    cvd::SharedFDSet fd_read;
-    fd_read.Zero();
-
-    adb_.BeforeSelect(&fd_read);
-    usbip_.BeforeSelect(&fd_read);
-
-    int ret = cvd::Select(&fd_read, nullptr, nullptr, nullptr);
-    if (ret <= 0) continue;
-
-    adb_.AfterSelect(fd_read);
-    usbip_.AfterSelect(fd_read);
-  }
-
-  return 0;
-}
diff --git a/host/commands/virtual_usb_manager/usbip/Android.bp b/host/commands/virtual_usb_manager/usbip/Android.bp
deleted file mode 100644
index 8a52b90..0000000
--- a/host/commands/virtual_usb_manager/usbip/Android.bp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// Copyright (C) 2017 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-cc_library_host_static {
-    name: "libusbip",
-    srcs: [
-        "client.cpp",
-        "device_pool.cpp",
-        "messages.cpp",
-        "server.cpp",
-        "vhci_instrument.cpp",
-    ],
-    header_libs: [
-        "cuttlefish_glog",
-    ],
-    shared_libs: [
-        "libcuttlefish_fs",
-        "libbase",
-    ],
-    static_libs: [
-        "libgflags",
-    ],
-    defaults: ["cuttlefish_host_only"],
-}
diff --git a/host/commands/virtual_usb_manager/usbip/README.md b/host/commands/virtual_usb_manager/usbip/README.md
deleted file mode 100644
index e652352..0000000
--- a/host/commands/virtual_usb_manager/usbip/README.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# USB/IP server library
-
-This folder contains set of classes and structures that constitute basic USB/IP 
-server.
-
-Protocol used in this library is defined as part of
-[Linux kernel documentation](https://www.kernel.org/doc/Documentation/usb/usbip_protocol.txt).
-
-## Structure
-
-### [`vadb::usbip::Device`](./device.h)[](#Device)
-
-Structure describing individual device accessible over USB/IP protocol.
-
-### [`vadb::usbip::DevicePool`](./device_pool.h)[](#DevicePool)
-
-DevicePool holds a set of [Devices](#Device) that can be enumerated and
-accessed by clients of this Server.
-
-### [`vadb::usbip::Server`](./server.h)
-
-Purpose of this class is to start a new listening socket and accept incoming
-USB/IP connections & requests.
-
-### [`vadb::usbip::Client`](./client.h)
-
-Client class represents individual USB/IP connection. Client enables remote
-USB/IP client to enumerate and access devices registered in
-[DevicePool](#DevicePool).
-
-### [`USB/IP Messages`](./messages.h)
-
-This file contains structures and enum values defined by the USB/IP protocol.
-All definitions found there have been collected from
-[Linux kernel documentation](https://www.kernel.org/doc/Documentation/usb/usbip_protocol.txt)
-.
diff --git a/host/commands/virtual_usb_manager/usbip/client.cpp b/host/commands/virtual_usb_manager/usbip/client.cpp
deleted file mode 100644
index 50ea9f8..0000000
--- a/host/commands/virtual_usb_manager/usbip/client.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "host/commands/virtual_usb_manager/usbip/client.h"
-
-#include <arpa/inet.h>
-
-#include <glog/logging.h>
-#include <iostream>
-
-#include "host/commands/virtual_usb_manager/usbip/device.h"
-#include "host/commands/virtual_usb_manager/usbip/messages.h"
-
-namespace vadb {
-namespace usbip {
-
-// NetToHost and HostToNet are used to reduce risk of copy/paste errors and to
-// provide uniform method of converting messages between different endian types.
-namespace {
-
-uint32_t NetToHost(uint32_t t) { return ntohl(t); }
-
-Command NetToHost(Command t) { return static_cast<Command>(ntohl(t)); }
-
-Direction NetToHost(Direction t) { return static_cast<Direction>(ntohl(t)); }
-
-uint32_t NetToHost(uint16_t t) { return ntohs(t); }
-
-CmdHeader NetToHost(const CmdHeader& t) {
-  CmdHeader rval = t;
-  rval.command = NetToHost(t.command);
-  rval.seq_num = NetToHost(t.seq_num);
-  rval.bus_num = NetToHost(t.bus_num);
-  rval.dev_num = NetToHost(t.dev_num);
-  rval.direction = NetToHost(t.direction);
-  rval.endpoint = NetToHost(t.endpoint);
-  return rval;
-}
-
-CmdReqSubmit NetToHost(const CmdReqSubmit& t) {
-  CmdReqSubmit rval = t;
-  rval.transfer_flags = NetToHost(t.transfer_flags);
-  rval.transfer_buffer_length = NetToHost(t.transfer_buffer_length);
-  rval.start_frame = NetToHost(t.start_frame);
-  rval.number_of_packets = NetToHost(t.number_of_packets);
-  rval.deadline_interval = NetToHost(t.deadline_interval);
-  return rval;
-}
-
-CmdReqUnlink NetToHost(const CmdReqUnlink& t) {
-  CmdReqUnlink rval = t;
-  rval.seq_num = NetToHost(t.seq_num);
-  return rval;
-}
-
-uint32_t HostToNet(uint32_t t) { return htonl(t); }
-
-Command HostToNet(const Command t) { return static_cast<Command>(htonl(t)); }
-
-Direction HostToNet(Direction t) { return static_cast<Direction>(htonl(t)); }
-
-uint16_t HostToNet(uint16_t t) { return htons(t); }
-
-CmdHeader HostToNet(const CmdHeader& t) {
-  CmdHeader rval = t;
-  rval.command = HostToNet(t.command);
-  rval.seq_num = HostToNet(t.seq_num);
-  rval.bus_num = HostToNet(t.bus_num);
-  rval.dev_num = HostToNet(t.dev_num);
-  rval.direction = HostToNet(t.direction);
-  rval.endpoint = HostToNet(t.endpoint);
-  return rval;
-}
-
-CmdRepSubmit HostToNet(const CmdRepSubmit& t) {
-  CmdRepSubmit rval = t;
-  rval.status = HostToNet(t.status);
-  rval.actual_length = HostToNet(t.actual_length);
-  rval.start_frame = HostToNet(t.start_frame);
-  rval.number_of_packets = HostToNet(t.number_of_packets);
-  rval.error_count = HostToNet(t.error_count);
-  return rval;
-}
-
-CmdRepUnlink HostToNet(const CmdRepUnlink& t) {
-  CmdRepUnlink rval = t;
-  rval.status = HostToNet(t.status);
-  return rval;
-}
-
-// Converts data to network order and sends it to the USB/IP client.
-// Returns true, if message was sent successfully.
-template <typename T>
-bool SendUSBIPMsg(const cvd::SharedFD& fd, const T& data) {
-  T net = HostToNet(data);
-  return fd->Send(&net, sizeof(T), MSG_NOSIGNAL) == sizeof(T);
-}
-
-// Receive message from USB/IP client.
-// After message is received, it's updated to match host endian.
-// Returns true, if message was received successfully.
-template <typename T>
-bool RecvUSBIPMsg(const cvd::SharedFD& fd, T* data) {
-  T net;
-  bool res = fd->Recv(&net, sizeof(T), MSG_NOSIGNAL) == sizeof(T);
-  if (res) {
-    *data = NetToHost(net);
-  }
-  return res;
-}
-
-}  // namespace
-
-void Client::BeforeSelect(cvd::SharedFDSet* fd_read) const {
-  fd_read->Set(fd_);
-}
-
-bool Client::AfterSelect(const cvd::SharedFDSet& fd_read) {
-  if (fd_read.IsSet(fd_)) return HandleIncomingMessage();
-  return true;
-}
-
-// Handle incoming COMMAND.
-//
-// Read next CMD from client channel.
-// Returns false, if connection should be dropped.
-bool Client::HandleIncomingMessage() {
-  CmdHeader hdr;
-  if (!RecvUSBIPMsg(fd_, &hdr)) {
-    LOG(ERROR) << "Could not read command header: " << fd_->StrError();
-    return false;
-  }
-
-  // And the protocol, again.
-  switch (hdr.command) {
-    case kUsbIpCmdReqSubmit:
-      return HandleSubmitCmd(hdr);
-
-    case kUsbIpCmdReqUnlink:
-      return HandleUnlinkCmd(hdr);
-
-    default:
-      LOG(ERROR) << "Unsupported command requested: " << hdr.command;
-      return false;
-  }
-}
-
-// Handle incoming SUBMIT COMMAND.
-//
-// Execute command on specified USB device.
-// Returns false, if connection should be dropped.
-bool Client::HandleSubmitCmd(const CmdHeader& cmd) {
-  CmdReqSubmit req;
-  if (!RecvUSBIPMsg(fd_, &req)) {
-    LOG(ERROR) << "Could not read submit command: " << fd_->StrError();
-    return false;
-  }
-
-  uint32_t seq_num = cmd.seq_num;
-
-  // Reserve buffer for data in or out.
-  std::vector<uint8_t> payload;
-  int payload_length = req.transfer_buffer_length;
-  payload.resize(payload_length);
-
-  bool is_host_to_device = cmd.direction == kUsbIpDirectionOut;
-  // Control requests are quite easy to detect; if setup is all '0's, then we're
-  // doing a data transfer, otherwise it's a control transfer.
-  // We only check for cmd and type fields here, as combination 0/0 of these
-  // fields is already invalid (cmd == GET_STATUS, type = WRITE).
-  bool is_control_request = !(req.setup.cmd == 0 && req.setup.type == 0);
-
-  // Find requested device and execute command.
-  auto device = pool_.GetDevice({cmd.bus_num, cmd.dev_num});
-  if (device) {
-    // Read data to be sent to device, if specified.
-    if (is_host_to_device && payload_length) {
-      size_t got = 0;
-      // Make sure we read everything.
-      while (got < payload.size()) {
-        auto read =
-            fd_->Recv(&payload[got], payload.size() - got, MSG_NOSIGNAL);
-        if (fd_->GetErrno() != 0) {
-          LOG(ERROR) << "Client disconnected: " << fd_->StrError();
-          return false;
-        } else if (!read) {
-          LOG(ERROR) << "Short read; client likely disconnected.";
-          return false;
-        }
-        got += read;
-      }
-    }
-
-    // If setup structure of request is initialized then we need to execute
-    // control transfer. Otherwise, this is a plain data exchange.
-    bool send_success = false;
-    if (is_control_request) {
-      send_success = device->handle_control_transfer(
-          req.setup, req.deadline_interval, std::move(payload),
-          [this, seq_num, is_host_to_device](bool is_success,
-                                             std::vector<uint8_t> data) {
-            HandleAsyncDataReady(seq_num, is_success, is_host_to_device,
-                                 std::move(data));
-          });
-    } else {
-      send_success = device->handle_data_transfer(
-          cmd.endpoint, is_host_to_device, req.deadline_interval,
-          std::move(payload),
-          [this, seq_num, is_host_to_device](bool is_success,
-                                             std::vector<uint8_t> data) {
-            HandleAsyncDataReady(seq_num, is_success, is_host_to_device,
-                                 std::move(data));
-          });
-    }
-
-    // Simply fail if couldn't execute command.
-    if (!send_success) {
-      HandleAsyncDataReady(seq_num, false, is_host_to_device,
-                           std::vector<uint8_t>());
-    }
-  }
-  return true;
-}
-
-void Client::HandleAsyncDataReady(uint32_t seq_num, bool is_success,
-                                  bool is_host_to_device,
-                                  std::vector<uint8_t> data) {
-  // Response template.
-  // - in header, host doesn't care about anything else except for command type
-  //   and sequence number.
-  // - in body, report status == !OK unless we completed everything
-  //   successfully.
-  CmdHeader rephdr{};
-  rephdr.command = kUsbIpCmdRepSubmit;
-  rephdr.seq_num = seq_num;
-
-  CmdRepSubmit rep{};
-  rep.status = is_success ? 0 : 1;
-  rep.actual_length = data.size();
-
-  // Data out.
-  if (!SendUSBIPMsg(fd_, rephdr)) {
-    LOG(ERROR) << "Failed to send response header: " << fd_->StrError();
-    return;
-  }
-
-  if (!SendUSBIPMsg(fd_, rep)) {
-    LOG(ERROR) << "Failed to send response body: " << fd_->StrError();
-    return;
-  }
-
-  if (!is_host_to_device && data.size() > 0) {
-    if (static_cast<size_t>(
-            fd_->Send(data.data(), data.size(), MSG_NOSIGNAL)) != data.size()) {
-      LOG(ERROR) << "Failed to send response payload: " << fd_->StrError();
-      return;
-    }
-  }
-}
-
-// Handle incoming UNLINK COMMAND.
-//
-// Unlink removes command specified via seq_num from a list of commands to be
-// executed.
-// We don't schedule commands for execution, so technically every UNLINK will
-// come in late.
-// Returns false, if connection should be dropped.
-bool Client::HandleUnlinkCmd(const CmdHeader& cmd) {
-  CmdReqUnlink req;
-  if (!RecvUSBIPMsg(fd_, &req)) {
-    LOG(ERROR) << "Could not read unlink command: " << fd_->StrError();
-    return false;
-  }
-  LOG(INFO) << "Client requested to unlink previously submitted command: "
-            << req.seq_num;
-
-  CmdHeader rephdr{};
-  rephdr.command = kUsbIpCmdRepUnlink;
-  rephdr.seq_num = cmd.seq_num;
-
-  // Technically we do not schedule commands for execution, so we cannot
-  // de-queue commands, either. Indicate this by sending status != ok.
-  CmdRepUnlink rep;
-  rep.status = 1;
-
-  if (!SendUSBIPMsg(fd_, rephdr)) {
-    LOG(ERROR) << "Could not send unlink command header: " << fd_->StrError();
-    return false;
-  }
-
-  if (!SendUSBIPMsg(fd_, rep)) {
-    LOG(ERROR) << "Could not send unlink command data: " << fd_->StrError();
-    return false;
-  }
-  return true;
-}
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/client.h b/host/commands/virtual_usb_manager/usbip/client.h
deleted file mode 100644
index 5e48f21..0000000
--- a/host/commands/virtual_usb_manager/usbip/client.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "common/libs/fs/shared_fd.h"
-#include "common/libs/fs/shared_select.h"
-#include "host/commands/virtual_usb_manager/usbip/device_pool.h"
-#include "host/commands/virtual_usb_manager/usbip/messages.h"
-
-namespace vadb {
-namespace usbip {
-
-// Represents USB/IP client, or individual connection to our USB/IP server.
-// Multiple clients are allowed, even if practically we anticipate only one
-// connection at the time.
-class Client final {
- public:
-  Client(const DevicePool& pool, const cvd::SharedFD& fd)
-      : pool_(pool), fd_(fd) {}
-
-  ~Client() {}
-
-  // BeforeSelect is Called right before Select() to populate interesting
-  // SharedFDs.
-  void BeforeSelect(cvd::SharedFDSet* fd_read) const;
-
-  // AfterSelect is Called right after Select() to detect and respond to changes
-  // on affected SharedFDs.
-  // Return value indicates whether this client is still valid.
-  bool AfterSelect(const cvd::SharedFDSet& fd_read);
-
- private:
-  // Respond to message from remote client.
-  // Returns false, if client violated protocol or disconnected, indicating,
-  // that this instance should no longer be used.
-  bool HandleIncomingMessage();
-
-  // Execute command on USB device.
-  // Returns false, if connection should be dropped.
-  bool HandleSubmitCmd(const CmdHeader& hdr);
-
-  // HandleAsyncDataReady is called asynchronously once previously submitted
-  // data transfer (control or bulk) has completed (or failed).
-  void HandleAsyncDataReady(uint32_t seq_num, bool is_success,
-                            bool is_host_to_device, std::vector<uint8_t> data);
-
-  // Unlink previously submitted message from device queue.
-  // Returns false, if connection should be dropped.
-  bool HandleUnlinkCmd(const CmdHeader& hdr);
-
-  const DevicePool& pool_;
-  cvd::SharedFD fd_;
-
-  Client(const Client&) = delete;
-  Client& operator=(const Client&) = delete;
-};
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/device.h b/host/commands/virtual_usb_manager/usbip/device.h
deleted file mode 100644
index 7af1ccc..0000000
--- a/host/commands/virtual_usb_manager/usbip/device.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <vector>
-
-#include "host/commands/virtual_usb_manager/usbip/messages.h"
-
-namespace vadb {
-namespace usbip {
-
-// The device descriptor of a USB device represents a USB device that is
-// available for import.
-class Device {
- public:
-  // AsyncTransferReadyCB specifies a signature of a function that will be
-  // called upon transfer completion (whether successful or failed). Parameters
-  // supplied to the function are:
-  // - operation status, indicated by boolean flag (true = success),
-  // - vector containing transferred data (and actual size).
-  using AsyncTransferReadyCB = std::function<void(bool, std::vector<uint8_t>)>;
-
-  // Interface provides minimal description of device's interface.
-  struct Interface {
-    uint8_t iface_class;
-    uint8_t iface_subclass;
-    uint8_t iface_protocol;
-  };
-
-  // vendor_id and product_id identify device manufacturer and type.
-  // dev_version describes device version (as BCD).
-  uint16_t vendor_id;
-  uint16_t product_id;
-  uint16_t dev_version;
-
-  // Class, Subclass and Protocol define device type.
-  uint8_t dev_class;
-  uint8_t dev_subclass;
-  uint8_t dev_protocol;
-
-  // Speed indicates device speed (see libusb_speed).
-  uint8_t speed;
-
-  // ConfigurationsCount and ConfigurationNumber describe total number of device
-  // configurations and currently activated device configuration.
-  size_t configurations_count;
-  size_t configuration_number;
-
-  // Interfaces returns a collection of device interfaces.
-  std::vector<Interface> interfaces;
-
-  // Attach request handler.
-  std::function<bool()> handle_attach;
-
-  // Device control request dispatcher.
-  std::function<bool(const CmdRequest& request, uint32_t deadline,
-                     std::vector<uint8_t> data, AsyncTransferReadyCB callback)>
-      handle_control_transfer;
-
-  // Device  data request dispatcher.
-  std::function<bool(uint8_t endpoint, bool is_host_to_device,
-                     uint32_t deadline, std::vector<uint8_t> data,
-                     AsyncTransferReadyCB callback)>
-      handle_data_transfer;
-};
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/device_pool.cpp b/host/commands/virtual_usb_manager/usbip/device_pool.cpp
deleted file mode 100644
index ecd3e8e..0000000
--- a/host/commands/virtual_usb_manager/usbip/device_pool.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "host/commands/virtual_usb_manager/usbip/device_pool.h"
-
-#include <glog/logging.h>
-
-namespace vadb {
-namespace usbip {
-
-void DevicePool::AddDevice(BusDevNumber bdn, std::unique_ptr<Device> device) {
-  devices_[bdn] = std::move(device);
-}
-
-Device* DevicePool::GetDevice(BusDevNumber bus_id) const {
-  auto iter = devices_.find(bus_id);
-  if (iter == devices_.end()) return nullptr;
-  return iter->second.get();
-}
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/device_pool.h b/host/commands/virtual_usb_manager/usbip/device_pool.h
deleted file mode 100644
index f6988c4..0000000
--- a/host/commands/virtual_usb_manager/usbip/device_pool.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <map>
-#include <string>
-
-#include "host/commands/virtual_usb_manager/usbip/device.h"
-
-namespace vadb {
-namespace usbip {
-// Container for all virtual USB/IP devices.
-// Stores devices by virtual BUS ID.
-class DevicePool {
- public:
-  // BusDevNumber is a pair uniquely identifying bus and device.
-  struct BusDevNumber {
-    uint16_t bus_number;
-    uint16_t dev_number;
-
-    bool operator<(BusDevNumber other) const {
-      return (bus_number << 16 | dev_number) <
-             (other.bus_number << 16 | other.dev_number);
-    }
-  };
-
-  // Internal container type.
-  using MapType = std::map<BusDevNumber, std::unique_ptr<Device>>;
-
-  DevicePool() = default;
-  virtual ~DevicePool() = default;
-
-  // Add new device associated with virtual BUS ID.
-  void AddDevice(BusDevNumber bus_id, std::unique_ptr<Device> device);
-
-  // Get device associated with supplied virtual bus/device number.
-  Device* GetDevice(BusDevNumber bus_dev_num) const;
-
-  // Get total number of USB/IP devices.
-  size_t Size() const { return devices_.size(); }
-
-  MapType::const_iterator begin() const { return devices_.cbegin(); }
-  MapType::const_iterator end() const { return devices_.cend(); }
-
- private:
-  MapType devices_;
-
-  DevicePool(const DevicePool&) = delete;
-  DevicePool& operator=(const DevicePool&) = delete;
-};
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/messages.cpp b/host/commands/virtual_usb_manager/usbip/messages.cpp
deleted file mode 100644
index 9de7c26..0000000
--- a/host/commands/virtual_usb_manager/usbip/messages.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "host/commands/virtual_usb_manager/usbip/messages.h"
-
-#include <netinet/in.h>
-#include <iostream>
-
-#include <glog/logging.h>
-
-namespace vadb {
-namespace usbip {
-namespace {
-// Basic sanity checking.
-// We're using CmdHeader + CmdReq/Rep in case any of the fields is moved between
-// structures.
-constexpr int kUsbIpCmdLength = 48;
-
-static_assert(sizeof(CmdHeader) + sizeof(CmdReqSubmit) == kUsbIpCmdLength,
-              "USB/IP command + header must be exactly 48 bytes.");
-static_assert(sizeof(CmdHeader) + sizeof(CmdRepSubmit) == kUsbIpCmdLength,
-              "USB/IP command + header must be exactly 48 bytes.");
-static_assert(sizeof(CmdHeader) + sizeof(CmdReqUnlink) == kUsbIpCmdLength,
-              "USB/IP command + header must be exactly 48 bytes.");
-static_assert(sizeof(CmdHeader) + sizeof(CmdRepUnlink) == kUsbIpCmdLength,
-              "USB/IP command + header must be exactly 48 bytes.");
-}  // namespace
-
-std::ostream& operator<<(std::ostream& out, const CmdHeader& header) {
-  out << "CmdHeader\n";
-  out << "\t\tcmd:\t" << header.command << '\n';
-  out << "\t\tseq#:\t" << header.seq_num << '\n';
-  out << "\t\tbus#:\t0x" << header.bus_num << '\n';
-  out << "\t\tdev#:\t0x" << header.dev_num << '\n';
-  out << "\t\tdir:\t" << (header.direction ? "in" : "out") << '\n';
-  out << "\t\tendpt:\t" << header.endpoint << "\n";
-  return out;
-}
-
-std::ostream& operator<<(std::ostream& out, const CmdRequest& setup) {
-  out << "Request\n";
-  out << "\t\t\ttype:\t" << std::hex << int(setup.type) << '\n';
-  out << "\t\t\treq:\t" << int(setup.cmd) << std::dec << '\n';
-  out << "\t\t\tval:\t" << setup.value << '\n';
-  out << "\t\t\tidx:\t" << setup.index << '\n';
-  out << "\t\t\tlen:\t" << setup.length << '\n';
-  return out;
-}
-
-std::ostream& operator<<(std::ostream& out, const CmdReqSubmit& submit) {
-  out << "CmdReqSubmit\n";
-  out << "\t\ttr_flg:\t" << std::hex << submit.transfer_flags << std::dec
-      << '\n';
-  out << "\t\ttr_len:\t" << submit.transfer_buffer_length << '\n';
-  out << "\t\tstart:\t" << submit.start_frame << '\n';
-  out << "\t\tpktcnt:\t" << submit.number_of_packets << '\n';
-  out << "\t\tttl:\t" << submit.deadline_interval << '\n';
-  out << "\t\tsetup:\t" << submit.setup << '\n';
-  return out;
-}
-
-std::ostream& operator<<(std::ostream& out, const CmdRepSubmit& submit) {
-  out << "CmdRepSubmit\n";
-  out << "\t\tstatus:\t" << submit.status << '\n';
-  out << "\t\tlen:\t" << submit.actual_length << '\n';
-  out << "\t\tstart:\t" << submit.start_frame << '\n';
-  out << "\t\tpktcnt:\t" << submit.number_of_packets << '\n';
-  out << "\t\terrors:\t" << submit.error_count << '\n';
-  out << "\t\tsetup:\t" << submit.setup << '\n';
-  return out;
-}
-
-std::ostream& operator<<(std::ostream& out, const CmdReqUnlink& unlink) {
-  out << "CmdReqUnlink\n";
-  out << "\t\tseq#:\t" << unlink.seq_num << '\n';
-  return out;
-}
-
-std::ostream& operator<<(std::ostream& out, const CmdRepUnlink& unlink) {
-  out << "CmdRepUnlink\n";
-  out << "\t\tstatus:\t" << unlink.status << '\n';
-  return out;
-}
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/messages.h b/host/commands/virtual_usb_manager/usbip/messages.h
deleted file mode 100644
index 8594465..0000000
--- a/host/commands/virtual_usb_manager/usbip/messages.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <glog/logging.h>
-#include <stdint.h>
-
-#include "common/libs/fs/shared_fd.h"
-
-// Requests and constants below are defined in kernel documentation file:
-// https://www.kernel.org/doc/Documentation/usb/usbip_protocol.txt
-namespace vadb {
-namespace usbip {
-
-////////////////////////////////////////////////////////////////////////////////
-// COMMANDS
-////////////////////////////////////////////////////////////////////////////////
-
-// Command numbers. Commands are valid only once USB device is attached.
-enum Command : uint32_t {
-  kUsbIpCmdReqSubmit = 1,  // Submit request
-  kUsbIpCmdReqUnlink = 2,  // Unlink request
-  kUsbIpCmdRepSubmit = 3,  // Submit response
-  kUsbIpCmdRepUnlink = 4,  // Unlink response
-};
-
-// Direction of data flow.
-enum Direction : uint32_t {
-  kUsbIpDirectionOut = 0,
-  kUsbIpDirectionIn = 1,
-};
-
-// Setup structure is explained in great detail here:
-// - http://www.beyondlogic.org/usbnutshell/usb6.shtml
-// - http://www.usbmadesimple.co.uk/ums_4.htm
-struct CmdRequest {
-  uint8_t type;
-  uint8_t cmd;
-  uint16_t value;
-  uint16_t index;
-  uint16_t length;
-} __attribute__((packed));
-
-// CmdHeader precedes any command request or response body.
-struct CmdHeader {
-  Command command;
-  uint32_t seq_num;
-  uint16_t bus_num;
-  uint16_t dev_num;
-  Direction direction;
-  uint32_t endpoint;  // valid values: 0-15
-} __attribute__((packed));
-
-// Command data for submitting an USB request.
-struct CmdReqSubmit {
-  uint32_t transfer_flags;
-  uint32_t transfer_buffer_length;
-  uint32_t start_frame;
-  uint32_t number_of_packets;
-  uint32_t deadline_interval;
-  CmdRequest setup;
-} __attribute__((packed));
-
-// Command response for submitting an USB request.
-struct CmdRepSubmit {
-  uint32_t status;  // 0 = success.
-  uint32_t actual_length;
-  uint32_t start_frame;
-  uint32_t number_of_packets;
-  uint32_t error_count;
-  CmdRequest setup;
-} __attribute__((packed));
-
-// Unlink USB request.
-struct CmdReqUnlink {
-  uint32_t seq_num;
-  uint32_t reserved[6];
-} __attribute__((packed));
-
-// Unlink USB response.
-struct CmdRepUnlink {
-  uint32_t status;
-  uint32_t reserved[6];
-} __attribute__((packed));
-
-// Diagnostics.
-std::ostream& operator<<(std::ostream& out, const CmdHeader& header);
-std::ostream& operator<<(std::ostream& out, const CmdReqSubmit& data);
-std::ostream& operator<<(std::ostream& out, const CmdRepSubmit& data);
-std::ostream& operator<<(std::ostream& out, const CmdReqUnlink& data);
-std::ostream& operator<<(std::ostream& out, const CmdRepUnlink& data);
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/server.cpp b/host/commands/virtual_usb_manager/usbip/server.cpp
deleted file mode 100644
index ef71b72..0000000
--- a/host/commands/virtual_usb_manager/usbip/server.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "host/commands/virtual_usb_manager/usbip/server.h"
-
-#include <glog/logging.h>
-#include <netinet/in.h>
-#include "common/libs/fs/shared_select.h"
-
-using cvd::SharedFD;
-
-namespace vadb {
-namespace usbip {
-Server::Server(const std::string& name, const DevicePool& devices)
-    : name_{name}, device_pool_{devices} {}
-
-bool Server::Init() { return CreateServerSocket(); }
-
-// Open new listening server socket.
-// Returns false, if listening socket could not be created.
-bool Server::CreateServerSocket() {
-  LOG(INFO) << "Starting server socket: " << name_;
-
-  server_ = SharedFD::SocketLocalServer(name_.c_str(), true, SOCK_STREAM, 0700);
-  if (!server_->IsOpen()) {
-    LOG(ERROR) << "Could not create socket: " << server_->StrError();
-    return false;
-  }
-  return true;
-}
-
-void Server::BeforeSelect(cvd::SharedFDSet* fd_read) const {
-  fd_read->Set(server_);
-  for (const auto& client : clients_) client.BeforeSelect(fd_read);
-}
-
-void Server::AfterSelect(const cvd::SharedFDSet& fd_read) {
-  if (fd_read.IsSet(server_)) HandleIncomingConnection();
-
-  for (auto iter = clients_.begin(); iter != clients_.end();) {
-    if (!iter->AfterSelect(fd_read)) {
-      // If client conversation failed, hang up.
-      iter = clients_.erase(iter);
-      continue;
-    }
-    ++iter;
-  }
-}
-
-// Accept new USB/IP connection. Add it to client pool.
-void Server::HandleIncomingConnection() {
-  SharedFD client = SharedFD::Accept(*server_, nullptr, nullptr);
-  if (!client->IsOpen()) {
-    LOG(ERROR) << "Client connection failed: " << client->StrError();
-    return;
-  }
-
-  clients_.emplace_back(device_pool_, client);
-}
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/server.h b/host/commands/virtual_usb_manager/usbip/server.h
deleted file mode 100644
index 5c574f7..0000000
--- a/host/commands/virtual_usb_manager/usbip/server.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <list>
-#include <string>
-
-#include "common/libs/fs/shared_fd.h"
-#include "host/commands/virtual_usb_manager/usbip/client.h"
-#include "host/commands/virtual_usb_manager/usbip/device_pool.h"
-
-namespace vadb {
-namespace usbip {
-
-class Server final {
- public:
-  Server(const std::string& name, const DevicePool& device_pool);
-  ~Server() = default;
-
-  // Initialize this instance of Server.
-  // Returns true, if initialization was successful.
-  bool Init();
-
-  // BeforeSelect is Called right before Select() to populate interesting
-  // SharedFDs.
-  void BeforeSelect(cvd::SharedFDSet* fd_read) const;
-
-  // AfterSelect is Called right after Select() to detect and respond to changes
-  // on affected SharedFDs.
-  void AfterSelect(const cvd::SharedFDSet& fd_read);
-
- private:
-  // Create USBIP server socket.
-  // Returns true, if socket was successfully created.
-  bool CreateServerSocket();
-
-  // Handle new client connection.
-  // New clients will be appended to clients_ list.
-  void HandleIncomingConnection();
-
-  std::string name_;
-  cvd::SharedFD server_;
-  std::list<Client> clients_;
-
-  const DevicePool& device_pool_;
-
-  Server(const Server&) = delete;
-  Server& operator=(const Server&) = delete;
-};
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/vhci_instrument.cpp b/host/commands/virtual_usb_manager/usbip/vhci_instrument.cpp
deleted file mode 100644
index 9df09ad..0000000
--- a/host/commands/virtual_usb_manager/usbip/vhci_instrument.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <errno.h>
-#include <string.h>
-
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <sys/socket.h>
-
-#include <glog/logging.h>
-#include <fstream>
-#include <limits>
-#include <sstream>
-#include "common/libs/fs/shared_select.h"
-
-#include "common/libs/fs/shared_fd.h"
-#include "host/commands/virtual_usb_manager/usbip/vhci_instrument.h"
-
-namespace vadb {
-namespace usbip {
-namespace {
-// Device ID is specified as a concatenated pair of BUS and DEVICE id.
-// Since we only export one device and our server doesn't care much about
-// its number, we use the default value of BUS=1 and DEVICE=1.
-// This can be set to something else and should still work, as long as
-// numbers are valid in USB sense.
-constexpr uint32_t kDefaultDeviceID = (1 << 16) | 1;
-
-// Request Highspeed configuration. Superspeed isn't supported by vhci.
-// Supported configurations are:
-//  4 -> wireless
-//  3 -> highspeed
-//  2 -> full speed
-//  1 -> low speed
-//  Please refer to the Kernel source tree in the following locations:
-//     include/uapi/linux/usb/ch9.h
-//     drivers/usb/usbip/vhci_sysfs.c
-constexpr uint32_t kDefaultDeviceSpeed = 3;
-
-// Subsystem and device type where VHCI driver is located.
-const char* const kVHCIPlatformPaths[] = {
-    "/sys/devices/platform/vhci_hcd",
-    "/sys/devices/platform/vhci_hcd.1",
-};
-
-// Control messages.
-// Attach tells thread to attach remote device.
-// Detach tells thread to detach remote device.
-using ControlMsgType = uint8_t;
-constexpr ControlMsgType kControlAttach = 'A';
-constexpr ControlMsgType kControlDetach = 'D';
-constexpr ControlMsgType kControlExit = 'E';
-
-// Used with EPOLL as epoll_data to determine event type.
-enum EpollEventType {
-  kControlEvent,
-  kVHCIEvent,
-};
-
-}  // anonymous namespace
-
-VHCIInstrument::VHCIInstrument(int port, const std::string& name)
-    : name_(name), port_{port} {}
-
-VHCIInstrument::~VHCIInstrument() {
-  control_write_end_->Write(&kControlExit, sizeof(kControlExit));
-  attach_thread_.join();
-}
-
-bool VHCIInstrument::Init() {
-  cvd::SharedFD::Pipe(&control_read_end_, &control_write_end_);
-
-  struct stat buf;
-  for (const auto* path : kVHCIPlatformPaths) {
-    if (stat(path, &buf) == 0) {
-      syspath_ = path;
-      break;
-    }
-  }
-
-  if (syspath_.empty()) {
-    LOG(ERROR) << "VHCI not available. Is the driver loaded?";
-    LOG(ERROR) << "Try: sudo modprobe vhci_hcd";
-    LOG(ERROR) << "The driver is part of linux-image-extra-`uname -r` package";
-    return false;
-  }
-
-  if (!VerifyPortIsFree()) {
-    LOG(ERROR) << "Trying to use VHCI port " << port_ << " but it is already in"
-               << " use.";
-    return false;
-  }
-
-  LOG(INFO) << "Using VHCI port " << port_;
-  attach_thread_ = std::thread([this] { AttachThread(); });
-  return true;
-}
-
-bool VHCIInstrument::VerifyPortIsFree() const {
-  std::ifstream status_file(syspath_ + "/status");
-
-  if (!status_file.good()) {
-    LOG(ERROR) << "Could not open usb-ip status file.";
-    return false;
-  }
-
-  // Skip past the header line.
-  status_file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-
-  while (true) {
-    // Port status values deducted from /sys/devices/platform/vhci_hcd/status
-    // kVHCIPortFree indicates the port is not currently in use.
-    constexpr static int kVHCIStatusPortFree = 4;
-
-    int port{};
-    int status{};
-    status_file >> port >> status;
-    if (!status_file.good()) {
-      break;
-    }
-
-    status_file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-    if (port_ == port) {
-      return status == kVHCIStatusPortFree;
-    }
-  }
-  LOG(ERROR) << "Couldn't find status for VHCI port " << port_;
-  return false;
-}
-
-void VHCIInstrument::TriggerAttach() {
-  control_write_end_->Write(&kControlAttach, sizeof(kControlAttach));
-}
-
-void VHCIInstrument::TriggerDetach() {
-  control_write_end_->Write(&kControlDetach, sizeof(kControlDetach));
-}
-
-void VHCIInstrument::AttachThread() {
-  cvd::SharedFD epoll = cvd::SharedFD::Epoll();
-  // Trigger attach upon start.
-  bool want_attach = true;
-  // Operation is pending on read.
-  bool is_pending = false;
-
-  epoll_event control_event;
-  control_event.events = EPOLLIN;
-  control_event.data.u64 = kControlEvent;
-  epoll_event vhci_event;
-  vhci_event.events = EPOLLRDHUP | EPOLLONESHOT;
-  vhci_event.data.u64 = kVHCIEvent;
-
-  epoll->EpollCtl(EPOLL_CTL_ADD, control_read_end_, &control_event);
-  while (true) {
-    if (vhci_socket_->IsOpen()) {
-      epoll->EpollCtl(EPOLL_CTL_ADD, vhci_socket_, &vhci_event);
-    }
-
-    epoll_event found_event{};
-    ControlMsgType request_type;
-
-    if (epoll->EpollWait(&found_event, 1, 1000)) {
-      switch (found_event.data.u64) {
-        case kControlEvent:
-          control_read_end_->Read(&request_type, sizeof(request_type));
-          is_pending = true;
-          want_attach = request_type == kControlAttach;
-          LOG(INFO) << (want_attach ? "Attach" : "Detach") << " triggered.";
-          break;
-        case kVHCIEvent:
-          vhci_socket_ = cvd::SharedFD();
-          // Only re-establish VHCI if it was already established before.
-          is_pending = want_attach;
-          // Do not immediately fall into attach cycle. It will likely complete
-          // before VHCI finishes deregistering this callback.
-          continue;
-      }
-    }
-
-    // Make an attempt to re-attach. If successful, clear pending attach flag.
-    if (is_pending) {
-      if (want_attach && Attach()) {
-        is_pending = false;
-      } else if (!want_attach && Detach()) {
-        is_pending = false;
-      } else {
-        LOG(INFO) << (want_attach ? "Attach" : "Detach") << " unsuccessful. "
-                  << "Will re-try.";
-        sleep(1);
-      }
-    }
-  }
-}
-
-bool VHCIInstrument::Detach() {
-  std::stringstream result;
-  result << port_;
-  std::ofstream detach(syspath_ + "/detach");
-
-  if (!detach.is_open()) {
-    LOG(WARNING) << "Could not open VHCI detach file.";
-    return false;
-  }
-  detach << result.str();
-  return detach.rdstate() == std::ios_base::goodbit;
-}
-
-bool VHCIInstrument::Attach() {
-  if (!vhci_socket_->IsOpen()) {
-    vhci_socket_ =
-        cvd::SharedFD::SocketLocalClient(name_.c_str(), true, SOCK_STREAM);
-    if (!vhci_socket_->IsOpen()) return false;
-  }
-
-  int sys_fd = vhci_socket_->UNMANAGED_Dup();
-  bool success = false;
-
-  {
-    std::stringstream result;
-    result << port_ << ' ' << sys_fd << ' ' << kDefaultDeviceID << ' '
-           << kDefaultDeviceSpeed;
-    std::string path = syspath_ + "/attach";
-    std::ofstream attach(path);
-
-    if (!attach.is_open()) {
-      LOG(WARNING) << "Could not open VHCI attach file " << path << " ("
-                   << strerror(errno) << ")";
-      close(sys_fd);
-      return false;
-    }
-    attach << result.str();
-
-    // It is unclear whether duplicate FD should remain open or not. There are
-    // cases supporting both assumptions, likely related to kernel version.
-    // Kernel 4.10 is having problems communicating with USB/IP server if the
-    // socket is closed after it's passed to kernel. It is a clear indication
-    // that the kernel requires the socket to be kept open.
-    success = attach.rdstate() == std::ios_base::goodbit;
-    // Make sure everything was written and flushed. This happens when we close
-    // the ofstream attach.
-  }
-
-  close(sys_fd);
-  return success;
-}
-
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/usbip/vhci_instrument.h b/host/commands/virtual_usb_manager/usbip/vhci_instrument.h
deleted file mode 100644
index aa2f5d4..0000000
--- a/host/commands/virtual_usb_manager/usbip/vhci_instrument.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <string>
-#include <thread>
-
-#include "common/libs/fs/shared_fd.h"
-
-namespace vadb {
-namespace usbip {
-// VHCIInstrument class configures VHCI-HCD on local kernel.
-class VHCIInstrument {
- public:
-  VHCIInstrument(int port, const std::string& name);
-  virtual ~VHCIInstrument();
-
-  // Init opens vhci-hcd driver and allocates port to which remote USB device
-  // will be attached.
-  // Returns false, if vhci-hcd driver could not be opened, or if no free port
-  // was found.
-  bool Init();
-
-  // TriggerAttach tells underlying thread to make attempt to re-attach USB
-  // device.
-  void TriggerAttach();
-
-  // TriggerDetach tells underlying thread to disconnect remote USB device.
-  void TriggerDetach();
-
- private:
-  // Attach makes an attempt to configure VHCI to enable virtual USB device.
-  // Returns true, if configuration attempt was successful.
-  bool Attach();
-
-  // Detach disconnects virtual USB device.
-  // Returns true, if attempt was successful.
-  bool Detach();
-
-  // AttachThread is a background thread that responds to configuration
-  // requests.
-  void AttachThread();
-  bool VerifyPortIsFree() const;
-
- private:
-  std::string name_;
-  std::thread attach_thread_;
-  std::string syspath_;
-  cvd::SharedFD control_write_end_;
-  cvd::SharedFD control_read_end_;
-  cvd::SharedFD vhci_socket_;
-  int port_{};
-
-  VHCIInstrument(const VHCIInstrument& other) = delete;
-  VHCIInstrument& operator=(const VHCIInstrument& other) = delete;
-};
-}  // namespace usbip
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd.h b/host/commands/virtual_usb_manager/vadb/usb_cmd.h
deleted file mode 100644
index 7039fbe..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "common/libs/fs/shared_fd.h"
-#include "common/libs/usbforward/protocol.h"
-
-namespace vadb {
-// USBCommand is an abstraction of a proxied USB command.
-// Instances of this object all share the following life cycle:
-// 1) A specific instance (COMMAND) is being created.
-// 2) Instance owner (OWNER) sends RequestHeader.
-// 3) OWNER calls COMMAND.OnRequest() to send any relevant, additional
-//    information.
-// 4) OWNER queues COMMAND until response arrives.
-//
-// At this point instance owner can process next command in queue. Then,
-// eventually:
-//
-// 5) OWNER receives matching ResponseHeader.
-// 6) OWNER calls COMMAND.OnResponse(), supplying FD that carries additional
-//    data.
-// 7) OWNER dequeues and deletes COMMAND.
-class USBCommand {
- public:
-  USBCommand() = default;
-  virtual ~USBCommand() = default;
-
-  // Command returns a specific usbforward command ID associated with this
-  // request.
-  virtual usb_forward::Command Command() = 0;
-
-  // OnRequest is called whenever additional data relevant to this command
-  // (other than RequestHeader) should be sent.
-  // Returns false, if communication with remote host failed (and should be
-  // terminated).
-  virtual bool OnRequest(const cvd::SharedFD& data) = 0;
-
-  // OnResponse is called whenever additional data relevant to this command
-  // (other than ResponseHeader) should be received.
-  // Returns false, if communication with remote host failed (and should be
-  // terminated).
-  virtual bool OnResponse(bool is_success, const cvd::SharedFD& data) = 0;
-
- private:
-  USBCommand(const USBCommand& other) = delete;
-  USBCommand& operator=(const USBCommand& other) = delete;
-};
-
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_attach.cpp b/host/commands/virtual_usb_manager/vadb/usb_cmd_attach.cpp
deleted file mode 100644
index 8418236..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_attach.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <glog/logging.h>
-
-#include "common/libs/usbforward/protocol.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_attach.h"
-
-namespace vadb {
-bool USBCmdAttach::OnRequest(const cvd::SharedFD& fd) {
-  if (fd->Write(&req_, sizeof(req_)) != sizeof(req_)) {
-    LOG(ERROR) << "Short write: " << fd->StrError();
-    return false;
-  }
-  return true;
-}
-
-bool USBCmdAttach::OnResponse(bool is_success, const cvd::SharedFD& /*data*/) {
-  if (!is_success) return false;
-  LOG(INFO) << "Attach successful.";
-  return true;
-}
-
-USBCmdAttach::USBCmdAttach(uint8_t bus_id, uint8_t dev_id) {
-  req_.bus_id = bus_id;
-  req_.dev_id = dev_id;
-}
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_attach.h b/host/commands/virtual_usb_manager/vadb/usb_cmd_attach.h
deleted file mode 100644
index 368deca..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_attach.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd.h"
-
-namespace vadb {
-// Request remote device attach (~open).
-class USBCmdAttach : public USBCommand {
- public:
-  USBCmdAttach(uint8_t bus_id, uint8_t dev_id);
-  ~USBCmdAttach() override = default;
-
-  // Return usbforward command this instance is executing.
-  usb_forward::Command Command() override { return usb_forward::CmdAttach; }
-
-  // Send request body to the server.
-  // Return false, if communication failed.
-  bool OnRequest(const cvd::SharedFD& data) override;
-
-  // Receive response data from the server.
-  // Return false, if communication failed.
-  bool OnResponse(bool is_success, const cvd::SharedFD& data) override;
-
- private:
-  usb_forward::AttachRequest req_;
-
-  USBCmdAttach(const USBCmdAttach& other) = delete;
-  USBCmdAttach& operator=(const USBCmdAttach& other) = delete;
-};
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.cpp b/host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.cpp
deleted file mode 100644
index 16fec69..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <glog/logging.h>
-
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.h"
-
-namespace vadb {
-USBCmdControlTransfer::USBCmdControlTransfer(
-    uint8_t bus_id, uint8_t dev_id, uint8_t type, uint8_t request,
-    uint16_t value, uint16_t index, uint32_t timeout, std::vector<uint8_t> data,
-    usbip::Device::AsyncTransferReadyCB callback)
-    : data_(std::move(data)), callback_(std::move(callback)) {
-  req_.bus_id = bus_id;
-  req_.dev_id = dev_id;
-  req_.type = type;
-  req_.cmd = request;
-  req_.value = value;
-  req_.index = index;
-  req_.length = data_.size();
-  req_.timeout = timeout;
-}
-
-bool USBCmdControlTransfer::OnRequest(const cvd::SharedFD& fd) {
-  if (fd->Write(&req_, sizeof(req_)) != sizeof(req_)) {
-    LOG(ERROR) << "Short write: " << fd->StrError();
-    return false;
-  }
-
-  if ((req_.type & 0x80) == 0) {
-    if (data_.size() > 0) {
-      if (static_cast<size_t>(fd->Write(data_.data(), data_.size())) !=
-          data_.size()) {
-        LOG(ERROR) << "Short write: " << fd->StrError();
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-bool USBCmdControlTransfer::OnResponse(bool is_success,
-                                       const cvd::SharedFD& fd) {
-  if (!is_success) {
-    callback_(false, std::move(data_));
-    return true;
-  }
-
-  if (req_.type & 0x80) {
-    int32_t len;
-    if (fd->Read(&len, sizeof(len)) != sizeof(len)) {
-      LOG(ERROR) << "Short read: " << fd->StrError();
-      callback_(false, std::move(data_));
-      return false;
-    }
-
-    if (len > 0) {
-      data_.resize(len);
-      if (fd->Read(data_.data(), len) != len) {
-        LOG(ERROR) << "Short read: " << fd->StrError();
-        callback_(false, std::move(data_));
-        return false;
-      }
-    }
-  }
-
-  callback_(true, std::move(data_));
-  return true;
-}
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.h b/host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.h
deleted file mode 100644
index 08aa159..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-
-#include <stdint.h>
-
-#include "common/libs/usbforward/protocol.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd.h"
-#include "host/commands/virtual_usb_manager/usbip/device.h"
-
-namespace vadb {
-// Execute control transfer.
-class USBCmdControlTransfer : public USBCommand {
- public:
-  USBCmdControlTransfer(uint8_t bus_id, uint8_t dev_id, uint8_t type,
-                        uint8_t request, uint16_t value, uint16_t index,
-                        uint32_t timeout, std::vector<uint8_t> data,
-                        usbip::Device::AsyncTransferReadyCB callback);
-
-  ~USBCmdControlTransfer() override = default;
-
-  // Return usbforward command this instance is executing.
-  usb_forward::Command Command() override {
-    return usb_forward::CmdControlTransfer;
-  }
-
-  // Send request body to the server.
-  // Return false, if communication failed.
-  bool OnRequest(const cvd::SharedFD& data) override;
-
-  // Receive response data from the server.
-  // Return false, if communication failed.
-  bool OnResponse(bool is_success, const cvd::SharedFD& data) override;
-
- private:
-  usb_forward::ControlTransfer req_;
-  std::vector<uint8_t> data_;
-  usbip::Device::AsyncTransferReadyCB callback_;
-
-  USBCmdControlTransfer(const USBCmdControlTransfer& other) = delete;
-  USBCmdControlTransfer& operator=(const USBCmdControlTransfer& other) = delete;
-};
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.cpp b/host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.cpp
deleted file mode 100644
index 8de468f..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <glog/logging.h>
-
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.h"
-
-namespace vadb {
-USBCmdDataTransfer::USBCmdDataTransfer(
-    uint8_t bus_id, uint8_t dev_id, uint8_t endpoint, bool is_host_to_device,
-    uint32_t deadline, std::vector<uint8_t> data,
-    usbip::Device::AsyncTransferReadyCB callback)
-    : data_(std::move(data)), callback_(std::move(callback)) {
-  req_.bus_id = bus_id;
-  req_.dev_id = dev_id;
-  req_.endpoint_id = endpoint;
-  req_.is_host_to_device = is_host_to_device;
-  req_.length = data_.size();
-  req_.timeout = deadline;
-}
-
-bool USBCmdDataTransfer::OnRequest(const cvd::SharedFD& fd) {
-  if (fd->Write(&req_, sizeof(req_)) != sizeof(req_)) {
-    LOG(ERROR) << "Short write: " << fd->StrError();
-    return false;
-  }
-
-  if (req_.is_host_to_device && data_.size() > 0) {
-    if (static_cast<size_t>(fd->Write(data_.data(), data_.size())) !=
-        data_.size()) {
-      LOG(ERROR) << "Short write: " << fd->StrError();
-      return false;
-    }
-  }
-
-  return true;
-}
-
-bool USBCmdDataTransfer::OnResponse(bool is_success, const cvd::SharedFD& fd) {
-  if (!is_success) {
-    callback_(false, std::move(data_));
-    return true;
-  }
-
-  if (!req_.is_host_to_device) {
-    int32_t len;
-    if (fd->Read(&len, sizeof(len)) != sizeof(len)) {
-      LOG(ERROR) << "Short read: " << fd->StrError();
-      callback_(false, std::move(data_));
-      return false;
-    }
-
-    if (len > 0) {
-      data_.resize(len);
-      int32_t got = 0;
-      // Virtio sends data in 32k packets. We may have to do a few reads.
-      while (got < len) {
-        auto packetsize = fd->Read(&data_[got], len - got);
-        got += packetsize;
-
-        if (fd->GetErrno() != 0) {
-          // This could, technically, also be a disconnect.
-          LOG(ERROR) << "Read failed: " << fd->StrError();
-          return false;
-        } else if (packetsize == 0) {
-          LOG(ERROR) << "Short read; remote end disconnected.";
-          return false;
-        }
-      }
-    }
-  }
-
-  callback_(true, std::move(data_));
-  return true;
-}
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.h b/host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.h
deleted file mode 100644
index 3c4b64f..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <stdint.h>
-
-#include "common/libs/usbforward/protocol.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd.h"
-#include "host/commands/virtual_usb_manager/usbip/device.h"
-
-namespace vadb {
-// Execute control transfer.
-class USBCmdDataTransfer : public USBCommand {
- public:
-  USBCmdDataTransfer(uint8_t bus_id, uint8_t dev_id, uint8_t endpoint,
-                     bool is_host_to_device, uint32_t timeout,
-                     std::vector<uint8_t> data,
-                     usbip::Device::AsyncTransferReadyCB callback);
-
-  ~USBCmdDataTransfer() override = default;
-
-  // Return usbforward command this instance is executing.
-  usb_forward::Command Command() override {
-    return usb_forward::CmdDataTransfer;
-  }
-
-  // Send request body to the server.
-  // Return false, if communication failed.
-  bool OnRequest(const cvd::SharedFD& data) override;
-
-  // Receive response data from the server.
-  // Return false, if communication failed.
-  bool OnResponse(bool is_success, const cvd::SharedFD& data) override;
-
- private:
-  usb_forward::DataTransfer req_;
-  std::vector<uint8_t> data_;
-  usbip::Device::AsyncTransferReadyCB callback_;
-
-  USBCmdDataTransfer(const USBCmdDataTransfer& other) = delete;
-  USBCmdDataTransfer& operator=(const USBCmdDataTransfer& other) = delete;
-};
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.cpp b/host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.cpp
deleted file mode 100644
index b74efdd..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <glog/logging.h>
-
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.h"
-
-namespace vadb {
-bool USBCmdDeviceList::OnRequest(const cvd::SharedFD& /*data*/) {
-  LOG(INFO) << "Requesting device list from Cuttlefish...";
-  // No action required.
-  return true;
-}
-
-bool USBCmdDeviceList::OnResponse(bool is_success, const cvd::SharedFD& fd) {
-  // This should never happen. If this command fails, something is very wrong.
-  if (!is_success) return false;
-
-  int32_t count;
-  if (fd->Read(&count, sizeof(count)) != sizeof(count)) {
-    LOG(ERROR) << "Short read: " << fd->StrError();
-    return false;
-  }
-
-  LOG(INFO) << "Device list completed with " << count << " devices.";
-
-  while (count-- > 0) {
-    usb_forward::DeviceInfo dev;
-    std::vector<usb_forward::InterfaceInfo> ifaces;
-
-    if (fd->Read(&dev, sizeof(dev)) != sizeof(dev)) {
-      LOG(ERROR) << "Short read: " << fd->StrError();
-      return false;
-    }
-
-    ifaces.resize(dev.num_interfaces);
-    if (static_cast<size_t>(
-            fd->Read(ifaces.data(),
-                     ifaces.size() * sizeof(usb_forward::InterfaceInfo))) !=
-        ifaces.size() * sizeof(usb_forward::InterfaceInfo)) {
-      LOG(ERROR) << "Short read: " << fd->StrError();
-      return false;
-    }
-
-    LOG(INFO) << "Found remote device 0x" << std::hex << dev.vendor_id << ":"
-              << dev.product_id;
-
-    on_device_discovered_(dev, ifaces);
-  }
-
-  return true;
-}
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.h b/host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.h
deleted file mode 100644
index 4d9ebbc..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <functional>
-#include <vector>
-#include "common/libs/usbforward/protocol.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd.h"
-
-namespace vadb {
-// Request device list from remote host.
-class USBCmdDeviceList : public USBCommand {
- public:
-  // DeviceDiscoveredCB is a callback function invoked for every new discovered
-  // device.
-  using DeviceDiscoveredCB =
-      std::function<void(const usb_forward::DeviceInfo&,
-                         const std::vector<usb_forward::InterfaceInfo>&)>;
-
-  USBCmdDeviceList(DeviceDiscoveredCB cb)
-      : on_device_discovered_(std::move(cb)) {}
-
-  ~USBCmdDeviceList() override = default;
-
-  // Return usbforward command this instance is executing.
-  usb_forward::Command Command() override { return usb_forward::CmdDeviceList; }
-
-  // Send request body to the server.
-  // Return false, if communication failed.
-  bool OnRequest(const cvd::SharedFD& data) override;
-
-  // Receive response data from the server.
-  // Return false, if communication failed.
-  bool OnResponse(bool is_success, const cvd::SharedFD& data) override;
-
- private:
-  DeviceDiscoveredCB on_device_discovered_;
-  USBCmdDeviceList(const USBCmdDeviceList& other) = delete;
-  USBCmdDeviceList& operator=(const USBCmdDeviceList& other) = delete;
-};
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.cpp b/host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.cpp
deleted file mode 100644
index cc80caa..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <glog/logging.h>
-
-#include "common/libs/usbforward/protocol.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.h"
-
-namespace vadb {
-bool USBCmdHeartbeat::OnRequest(const cvd::SharedFD& /*fd*/) { return true; }
-
-bool USBCmdHeartbeat::OnResponse(bool is_success,
-                                 const cvd::SharedFD& /*data*/) {
-  callback_(is_success);
-  return true;
-}
-
-USBCmdHeartbeat::USBCmdHeartbeat(USBCmdHeartbeat::HeartbeatResultCB callback)
-    : callback_(callback) {}
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.h b/host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.h
deleted file mode 100644
index 552165b..0000000
--- a/host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd.h"
-
-namespace vadb {
-// Request remote device attach (~open).
-class USBCmdHeartbeat : public USBCommand {
- public:
-  // Heartbeat result callback receives a boolean argument indicating whether
-  // remote device is ready to be attached.
-  using HeartbeatResultCB = std::function<void(bool)>;
-
-  USBCmdHeartbeat(HeartbeatResultCB callback);
-  ~USBCmdHeartbeat() override = default;
-
-  // Return usbforward command this instance is executing.
-  usb_forward::Command Command() override { return usb_forward::CmdHeartbeat; }
-
-  // Send request body to the server.
-  // Return false, if communication failed.
-  bool OnRequest(const cvd::SharedFD& data) override;
-
-  // Receive response data from the server.
-  // Return false, if communication failed.
-  bool OnResponse(bool is_success, const cvd::SharedFD& data) override;
-
- private:
-  HeartbeatResultCB callback_;
-
-  USBCmdHeartbeat(const USBCmdHeartbeat& other) = delete;
-  USBCmdHeartbeat& operator=(const USBCmdHeartbeat& other) = delete;
-};
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/virtual_adb_client.cpp b/host/commands/virtual_usb_manager/vadb/virtual_adb_client.cpp
deleted file mode 100644
index 34ee5b4..0000000
--- a/host/commands/virtual_usb_manager/vadb/virtual_adb_client.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <algorithm>
-#include <memory>
-#include <gflags/gflags.h>
-
-#include "common/libs/fs/shared_select.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_attach.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_control_transfer.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_data_transfer.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_device_list.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd_heartbeat.h"
-#include "host/commands/virtual_usb_manager/vadb/virtual_adb_client.h"
-
-DEFINE_bool(debug_adb_client, false, "Turn on verbose logging in the virtual_adb_client.cpp");
-
-#define VLOG(X) if (FLAGS_debug_adb_client) LOG(VERBOSE)
-
-namespace vadb {
-namespace {
-constexpr int kHeartbeatTimeoutSeconds = 3;
-}  // namespace
-
-VirtualADBClient::VirtualADBClient(usbip::DevicePool* pool, cvd::SharedFD fd,
-                                   int vhci_port,
-                                   const std::string& usbip_socket_name)
-    : pool_{pool}, fd_{fd}, vhci_{vhci_port, usbip_socket_name} {
-  CHECK(vhci_.Init());
-  timer_ = cvd::SharedFD::TimerFD(CLOCK_MONOTONIC, 0);
-  SendHeartbeat();
-}
-
-void VirtualADBClient::RegisterDevice(
-    const usb_forward::DeviceInfo& dev,
-    const std::vector<usb_forward::InterfaceInfo>& ifaces) {
-  auto d = std::unique_ptr<usbip::Device>(new usbip::Device);
-  d->vendor_id = dev.vendor_id;
-  d->product_id = dev.product_id;
-  d->dev_version = dev.dev_version;
-  d->dev_class = dev.dev_class;
-  d->dev_subclass = dev.dev_subclass;
-  d->dev_protocol = dev.dev_protocol;
-  d->speed = dev.speed;
-  d->configurations_count = dev.num_configurations;
-  d->configuration_number = dev.cur_configuration;
-
-  for (const auto& iface : ifaces) {
-    d->interfaces.push_back(usbip::Device::Interface{
-        iface.if_class, iface.if_subclass, iface.if_protocol});
-  }
-
-  uint8_t bus_id = dev.bus_id;
-  uint8_t dev_id = dev.dev_id;
-
-  d->handle_attach = [this, bus_id, dev_id]() -> bool {
-    return HandleAttach(bus_id, dev_id);
-  };
-
-  d->handle_control_transfer =
-      [this, bus_id, dev_id](
-          const usbip::CmdRequest& r, uint32_t deadline,
-          std::vector<uint8_t> data,
-          usbip::Device::AsyncTransferReadyCB callback) -> bool {
-    return HandleDeviceControlRequest(bus_id, dev_id, r, deadline,
-                                      std::move(data), std::move(callback));
-  };
-
-  d->handle_data_transfer =
-      [this, bus_id, dev_id](
-          uint8_t endpoint, bool is_host_to_device, uint32_t deadline,
-          std::vector<uint8_t> data,
-          usbip::Device::AsyncTransferReadyCB callback) -> bool {
-    return HandleDeviceDataRequest(bus_id, dev_id, endpoint, is_host_to_device,
-                                   deadline, std::move(data),
-                                   std::move(callback));
-  };
-
-  pool_->AddDevice(usbip::DevicePool::BusDevNumber{bus_id, dev_id},
-                   std::move(d));
-
-  // Attach this device.
-  HandleAttach(bus_id, dev_id);
-}
-
-bool VirtualADBClient::PopulateRemoteDevices() {
-  return ExecuteCommand(std::unique_ptr<USBCommand>(new USBCmdDeviceList(
-      [this](const usb_forward::DeviceInfo& info,
-             const std::vector<usb_forward::InterfaceInfo>& ifaces) {
-        RegisterDevice(info, ifaces);
-      })));
-}
-
-bool VirtualADBClient::HandleDeviceControlRequest(
-    uint8_t bus_id, uint8_t dev_id, const usbip::CmdRequest& r,
-    uint32_t timeout, std::vector<uint8_t> data,
-    usbip::Device::AsyncTransferReadyCB callback) {
-  return ExecuteCommand(std::unique_ptr<USBCommand>(new USBCmdControlTransfer(
-      bus_id, dev_id, r.type, r.cmd, r.value, r.index, timeout, std::move(data),
-      std::move(callback))));
-}
-
-bool VirtualADBClient::HandleDeviceDataRequest(
-    uint8_t bus_id, uint8_t dev_id, uint8_t endpoint, bool is_host_to_device,
-    uint32_t deadline, std::vector<uint8_t> data,
-    usbip::Device::AsyncTransferReadyCB callback) {
-  return ExecuteCommand(std::unique_ptr<USBCommand>(
-      new USBCmdDataTransfer(bus_id, dev_id, endpoint, is_host_to_device,
-                             deadline, std::move(data), std::move(callback))));
-}
-
-bool VirtualADBClient::HandleAttach(uint8_t bus_id, uint8_t dev_id) {
-  return ExecuteCommand(
-      std::unique_ptr<USBCommand>(new USBCmdAttach(bus_id, dev_id)));
-}
-
-bool VirtualADBClient::SendHeartbeat() {
-  VLOG(1) << "Sending heartbeat...";
-  struct itimerspec spec {};
-  spec.it_value.tv_sec = kHeartbeatTimeoutSeconds;
-  timer_->TimerSet(0, &spec, nullptr);
-
-  heartbeat_tag_ = tag_;
-
-  return ExecuteCommand(std::unique_ptr<USBCommand>(
-      new USBCmdHeartbeat([this](bool success) { HandleHeartbeat(success); })));
-}
-
-void VirtualADBClient::HandleHeartbeat(bool is_ready) {
-  VLOG(1) << "Remote server status: " << is_ready;
-  if (is_ready && !is_remote_server_ready_) {
-    LOG(INFO) << "Remote server is now ready.";
-    PopulateRemoteDevices();
-    vhci_.TriggerAttach();
-  } else if (is_remote_server_ready_ && !is_ready) {
-    vhci_.TriggerDetach();
-    LOG(WARNING) << "Remote server connection lost.";
-    // It makes perfect sense to cancel all outstanding USB requests, as device
-    // is not going to answer any of these anyway.
-    for (const auto& pair : commands_) {
-      pair.second->OnResponse(false, fd_);
-    }
-    commands_.clear();
-  }
-  is_remote_server_ready_ = is_ready;
-}
-
-bool VirtualADBClient::HandleHeartbeatTimeout() {
-  uint64_t timer_result;
-  timer_->Read(&timer_result, sizeof(timer_result));
-
-  auto iter = commands_.find(heartbeat_tag_);
-  if (iter != commands_.end()) {
-    // Make sure to erase the value from list of commands prior to running
-    // callback. Particularly important for heartbeat, which cancels all
-    // outstanding USB commands (including self, if found), if device goes
-    // away (eg. reboots).
-    auto command = std::move(iter->second);
-    commands_.erase(iter);
-    command->OnResponse(false, fd_);
-  }
-
-  return SendHeartbeat();
-}
-
-bool VirtualADBClient::ExecuteCommand(std::unique_ptr<USBCommand> cmd) {
-  uint32_t this_tag = tag_;
-  tag_++;
-  usb_forward::RequestHeader hdr{cmd->Command(), this_tag};
-  if (fd_->Write(&hdr, sizeof(hdr)) != sizeof(hdr)) {
-    LOG(ERROR) << "Could not contact USB Forwarder: " << fd_->StrError();
-    return false;
-  }
-
-  if (!cmd->OnRequest(fd_)) return false;
-
-  commands_[this_tag] = std::move(cmd);
-  return true;
-}
-
-// BeforeSelect is Called right before Select() to populate interesting
-// SharedFDs.
-void VirtualADBClient::BeforeSelect(cvd::SharedFDSet* fd_read) const {
-  fd_read->Set(fd_);
-  fd_read->Set(timer_);
-}
-
-// AfterSelect is Called right after Select() to detect and respond to changes
-// on affected SharedFDs.
-// Return value indicates whether this client is still valid.
-bool VirtualADBClient::AfterSelect(const cvd::SharedFDSet& fd_read) {
-  if (fd_read.IsSet(timer_)) {
-    HandleHeartbeatTimeout();
-  }
-  if (fd_read.IsSet(fd_)) {
-    usb_forward::ResponseHeader rhdr;
-    if (fd_->Read(&rhdr, sizeof(rhdr)) != sizeof(rhdr)) {
-      LOG(ERROR) << "Could not read from USB Forwarder: " << fd_->StrError();
-      // TODO(ender): it is very likely the connection has been dropped by QEmu.
-      // Should we cancel all pending commands now?
-      return false;
-    }
-
-    auto iter = commands_.find(rhdr.tag);
-    if (iter == commands_.end()) {
-      // This is likely a late heartbeat response, but could very well be any of
-      // the remaining commands.
-      LOG(INFO) << "Received response for discarded tag " << rhdr.tag;
-    } else {
-      // Make sure to erase the value from list of commands prior to running
-      // callback. Particularly important for heartbeat, which cancels all
-      // outstanding USB commands (including self, if found), if device goes
-      // away (eg. reboots).
-      auto command = std::move(iter->second);
-      commands_.erase(iter);
-      command->OnResponse(rhdr.status == usb_forward::StatusSuccess, fd_);
-    }
-  }
-
-  return true;
-}
-
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/virtual_adb_client.h b/host/commands/virtual_usb_manager/vadb/virtual_adb_client.h
deleted file mode 100644
index 9c503ab..0000000
--- a/host/commands/virtual_usb_manager/vadb/virtual_adb_client.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <string>
-
-#include "common/libs/fs/shared_fd.h"
-#include "common/libs/fs/shared_select.h"
-#include "common/libs/usbforward/protocol.h"
-#include "host/commands/virtual_usb_manager/vadb/usb_cmd.h"
-#include "host/commands/virtual_usb_manager/usbip/device.h"
-#include "host/commands/virtual_usb_manager/usbip/device_pool.h"
-#include "host/commands/virtual_usb_manager/usbip/messages.h"
-#include "host/commands/virtual_usb_manager/usbip/vhci_instrument.h"
-
-namespace vadb {
-// VirtualADBClient is a companion class for USBForwarder, running on
-// Cuttlefish. VirtualADBClient collects list of available USB devices from
-// Cuttlefish and makes them available to USB/IP.
-//
-// Purpose of this class is to connect to USBForwarder and make access to
-// remote USB devices possible with help of USB/IP protocol.
-class VirtualADBClient {
- public:
-  VirtualADBClient(usbip::DevicePool* pool, cvd::SharedFD fd, int vhci_port,
-                   const std::string& usbip_socket_name);
-
-  virtual ~VirtualADBClient() = default;
-
-  // Query remote server; populate available USB devices.
-  bool PopulateRemoteDevices();
-
-  // BeforeSelect is Called right before Select() to populate interesting
-  // SharedFDs.
-  void BeforeSelect(cvd::SharedFDSet* fd_read) const;
-
-  // AfterSelect is Called right after Select() to detect and respond to changes
-  // on affected SharedFDs.
-  // Return value indicates whether this client is still valid.
-  bool AfterSelect(const cvd::SharedFDSet& fd_read);
-
- private:
-  // Register new device in a device pool.
-  void RegisterDevice(const usb_forward::DeviceInfo& dev,
-                      const std::vector<usb_forward::InterfaceInfo>& ifaces);
-
-  // Request attach remote USB device.
-  bool HandleAttach(uint8_t bus_id, uint8_t dev_id);
-
-  // Execute control request on remote device.
-  bool HandleDeviceControlRequest(uint8_t bus_id, uint8_t dev_id,
-                                  const usbip::CmdRequest& r, uint32_t deadline,
-                                  std::vector<uint8_t> data,
-                                  usbip::Device::AsyncTransferReadyCB callback);
-
-  // Execute data request on remote device.
-  bool HandleDeviceDataRequest(uint8_t bus_id, uint8_t dev_id, uint8_t endpoint,
-                               bool is_host_to_device, uint32_t deadline,
-                               std::vector<uint8_t> data,
-                               usbip::Device::AsyncTransferReadyCB callback);
-
-  // Send new heartbeat request and arm the heartbeat timer.
-  bool SendHeartbeat();
-
-  // Heartbeat handler receives response to heartbeat request.
-  // Supplied argument indicates, whether remote server is ready to export USB
-  // gadget.
-  void HandleHeartbeat(bool is_ready);
-
-  // Heartbeat timeout detects situation where heartbeat did not receive
-  // matching response. This could be a direct result of device reset.
-  bool HandleHeartbeatTimeout();
-
-  // ExecuteCommand creates command header and executes supplied USBCommand.
-  // If execution was successful, command will be stored internally until
-  // response arrives.
-  bool ExecuteCommand(std::unique_ptr<USBCommand> cmd);
-
-  usbip::DevicePool* pool_;
-  cvd::SharedFD fd_;
-  cvd::SharedFD timer_;
-  usbip::VHCIInstrument vhci_;
-  bool is_remote_server_ready_ = false;
-
-  uint32_t tag_ = 0;
-  // Assign an 'invalid' tag as previously sent heartbeat command. This will
-  // prevent heartbeat timeout handler from finding a command if none was sent.
-  uint32_t heartbeat_tag_ = ~0;
-  std::map<uint32_t, std::unique_ptr<USBCommand>> commands_;
-
-  VirtualADBClient(const VirtualADBClient& other) = delete;
-  VirtualADBClient& operator=(const VirtualADBClient& other) = delete;
-};
-
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/virtual_adb_server.cpp b/host/commands/virtual_usb_manager/vadb/virtual_adb_server.cpp
deleted file mode 100644
index 43dae75..0000000
--- a/host/commands/virtual_usb_manager/vadb/virtual_adb_server.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "host/commands/virtual_usb_manager/vadb/virtual_adb_server.h"
-
-namespace vadb {
-
-void VirtualADBServer::BeforeSelect(cvd::SharedFDSet* fd_read) const {
-  fd_read->Set(server_);
-  for (const auto& client : clients_) {
-    client.BeforeSelect(fd_read);
-  }
-}
-
-void VirtualADBServer::AfterSelect(const cvd::SharedFDSet& fd_read) {
-  if (fd_read.IsSet(server_)) HandleIncomingConnection();
-
-  for (auto iter = clients_.begin(); iter != clients_.end();) {
-    if (!iter->AfterSelect(fd_read)) {
-      // If client conversation failed, hang up.
-      iter = clients_.erase(iter);
-      continue;
-    }
-    ++iter;
-  }
-}
-
-// Accept new QEmu connection. Add it to client pool.
-// Typically we will have no more than one QEmu connection, but the nature
-// of server requires proper handling nonetheless.
-void VirtualADBServer::HandleIncomingConnection() {
-  cvd::SharedFD client = cvd::SharedFD::Accept(*server_, nullptr, nullptr);
-  if (!client->IsOpen()) {
-    LOG(ERROR) << "Client connection failed: " << client->StrError();
-    return;
-  }
-
-  clients_.emplace_back(&pool_, client, vhci_port_, usbip_name_);
-}
-
-}  // namespace vadb
diff --git a/host/commands/virtual_usb_manager/vadb/virtual_adb_server.h b/host/commands/virtual_usb_manager/vadb/virtual_adb_server.h
deleted file mode 100644
index d4aaf79..0000000
--- a/host/commands/virtual_usb_manager/vadb/virtual_adb_server.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <list>
-#include <string>
-
-#include "common/libs/fs/shared_fd.h"
-#include "host/commands/virtual_usb_manager/usbip/device_pool.h"
-#include "host/commands/virtual_usb_manager/vadb/virtual_adb_client.h"
-
-namespace vadb {
-// VirtualADBServer manages incoming VirtualUSB/ADB connections from QEmu.
-class VirtualADBServer {
- public:
-  VirtualADBServer(cvd::SharedFD usb_v1_socket, int vhci_port,
-                   const std::string& usbip_socket_name)
-      : vhci_port_{vhci_port},
-        usbip_name_(usbip_socket_name),
-        server_(usb_v1_socket) {}
-
-  ~VirtualADBServer() = default;
-
-  // Pool of USB devices available to export.
-  const usbip::DevicePool& Pool() const { return pool_; };
-
-  // BeforeSelect is Called right before Select() to populate interesting
-  // SharedFDs.
-  void BeforeSelect(cvd::SharedFDSet* fd_read) const;
-
-  // AfterSelect is Called right after Select() to detect and respond to changes
-  // on affected SharedFDs.
-  void AfterSelect(const cvd::SharedFDSet& fd_read);
-
- private:
-  void HandleIncomingConnection();
-
-  usbip::DevicePool pool_;
-  int vhci_port_{};
-  std::string usbip_name_;
-  cvd::SharedFD server_;
-  std::list<VirtualADBClient> clients_;
-
-  VirtualADBServer(const VirtualADBServer&) = delete;
-  VirtualADBServer& operator=(const VirtualADBServer&) = delete;
-};
-
-}  // namespace vadb
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
index ae89a21..1820ee4 100644
--- a/host/libs/config/cuttlefish_config.cpp
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -93,9 +93,6 @@
 const char* kVendorRamdiskImagePath = "vendor_ramdisk_image_path";
 
 const char* kVirtualDiskPaths = "virtual_disk_paths";
-const char* kUsbV1SocketName = "usb_v1_socket_name";
-const char* kVhciPort = "vhci_port";
-const char* kUsbIpSocketName = "usb_ip_socket_name";
 const char* kDeprecatedBootCompleted = "deprecated_boot_completed";
 
 const char* kMobileBridgeName = "mobile_bridge_name";
@@ -123,7 +120,6 @@
 const char* kRestartSubprocesses = "restart_subprocesses";
 const char* kRunAdbConnector = "run_adb_connector";
 const char* kAdbConnectorBinary = "adb_connector_binary";
-const char* kVirtualUsbManagerBinary = "virtual_usb_manager_binary";
 const char* kSocketVsockProxyBinary = "socket_vsock_proxy_binary";
 
 const char* kRunAsDaemon = "run_as_daemon";
@@ -331,29 +327,6 @@
   (*dictionary_)[kVirtualDiskPaths] = virtual_disks_json_obj;
 }
 
-std::string CuttlefishConfig::usb_v1_socket_name() const {
-  return (*dictionary_)[kUsbV1SocketName].asString();
-}
-void CuttlefishConfig::set_usb_v1_socket_name(
-    const std::string& usb_v1_socket_name) {
-  (*dictionary_)[kUsbV1SocketName] = usb_v1_socket_name;
-}
-
-int CuttlefishConfig::vhci_port() const {
-  return (*dictionary_)[kVhciPort].asInt();
-}
-void CuttlefishConfig::set_vhci_port(int vhci_port) {
-  (*dictionary_)[kVhciPort] = vhci_port;
-}
-
-std::string CuttlefishConfig::usb_ip_socket_name() const {
-  return (*dictionary_)[kUsbIpSocketName].asString();
-}
-void CuttlefishConfig::set_usb_ip_socket_name(
-    const std::string& usb_ip_socket_name) {
-  (*dictionary_)[kUsbIpSocketName] = usb_ip_socket_name;
-}
-
 std::string CuttlefishConfig::kernel_log_pipe_name() const {
   return cvd::AbsolutePath(PerInstanceInternalPath("kernel-log-pipe"));
 }
@@ -438,8 +411,6 @@
     return AdbMode::VsockHalfTunnel;
   } else if (mode == "native_vsock") {
     return AdbMode::NativeVsock;
-  } else if (mode == "usb") {
-    return AdbMode::Usb;
   } else {
     return AdbMode::Unknown;
   }
@@ -484,8 +455,6 @@
   bool nativeVsock = adb_mode().count(AdbMode::NativeVsock) > 0;
   if (vsockTunnel || vsockHalfProxy || nativeVsock) {
     return adb_ip_and_port();
-  } else if (adb_mode().count(AdbMode::Usb) > 0) {
-    return serial_number();
   }
   LOG(ERROR) << "no adb_mode found, returning bad device name";
   return "NO_ADB_MODE_SET_NO_VALID_DEVICE_NAME";
@@ -591,15 +560,6 @@
   (*dictionary_)[kAdbConnectorBinary] = adb_connector_binary;
 }
 
-std::string CuttlefishConfig::virtual_usb_manager_binary() const {
-  return (*dictionary_)[kVirtualUsbManagerBinary].asString();
-}
-
-void CuttlefishConfig::set_virtual_usb_manager_binary(
-    const std::string& virtual_usb_manager_binary) {
-  (*dictionary_)[kVirtualUsbManagerBinary] = virtual_usb_manager_binary;
-}
-
 std::string CuttlefishConfig::socket_vsock_proxy_binary() const {
   return (*dictionary_)[kSocketVsockProxyBinary].asString();
 }
diff --git a/host/libs/config/cuttlefish_config.h b/host/libs/config/cuttlefish_config.h
index aea9055..656f84f 100644
--- a/host/libs/config/cuttlefish_config.h
+++ b/host/libs/config/cuttlefish_config.h
@@ -42,7 +42,6 @@
   VsockTunnel,
   VsockHalfTunnel,
   NativeVsock,
-  Usb,
   Unknown,
 };
 
@@ -64,11 +63,6 @@
 
   std::string instance_name() const;
 
-  void disable_usb_adb() {
-    // This seems to be the way usb is being disbled in the launcher
-    set_usb_v1_socket_name("");
-  }
-
   std::string instance_dir() const;
   void set_instance_dir(const std::string& instance_dir);
 
@@ -150,17 +144,6 @@
   std::vector<std::string> virtual_disk_paths() const;
   void set_virtual_disk_paths(const std::vector<std::string>& disk_paths);
 
-  // The name of the socket that will be used to forward access to USB gadget.
-  // This is for V1 of the USB bus.
-  std::string usb_v1_socket_name() const;
-  void set_usb_v1_socket_name(const std::string& usb_v1_socket_name);
-
-  int vhci_port() const;
-  void set_vhci_port(int vhci_port);
-
-  std::string usb_ip_socket_name() const;
-  void set_usb_ip_socket_name(const std::string& usb_ip_socket_name);
-
   std::string kernel_log_pipe_name() const;
 
   std::string console_pipe_name() const;
@@ -248,9 +231,6 @@
   void set_adb_connector_binary(const std::string& adb_connector_binary);
   std::string adb_connector_binary() const;
 
-  void set_virtual_usb_manager_binary(const std::string& binary);
-  std::string virtual_usb_manager_binary() const;
-
   void set_socket_vsock_proxy_binary(const std::string& binary);
   std::string socket_vsock_proxy_binary() const;
 
diff --git a/host/libs/vm_manager/cf_qemu.sh b/host/libs/vm_manager/cf_qemu.sh
index 969332d..5d88b3f 100755
--- a/host/libs/vm_manager/cf_qemu.sh
+++ b/host/libs/vm_manager/cf_qemu.sh
@@ -159,13 +159,6 @@
   args+=(-initrd "${ramdisk_image_path}")
 fi
 
-if [[ -n "${usb_v1_socket_name}" ]]; then
-  args+=(
-      -chardev "socket,id=charchannel1,path=${usb_v1_socket_name:-${default_internal_dir}/usb-v1}"
-      -device "virtserialport,bus=virtio-serial0.0,nr=2,chardev=charchannel1,id=channel1,name=cf-gadget-usb-v1"
-  )
-fi
-
 if [[ ${vsock_guest_cid:-0} -gt 2 ]]; then
   args+=(-device "vhost-vsock-pci,guest-cid=${vsock_guest_cid}")
 fi
diff --git a/host/libs/vm_manager/qemu_manager.cpp b/host/libs/vm_manager/qemu_manager.cpp
index 45e3003..c5345c1 100644
--- a/host/libs/vm_manager/qemu_manager.cpp
+++ b/host/libs/vm_manager/qemu_manager.cpp
@@ -146,7 +146,6 @@
                config_->kernel_log_pipe_name());
   LogAndSetEnv("console_path", config_->console_path());
   LogAndSetEnv("logcat_path", config_->logcat_path());
-  LogAndSetEnv("usb_v1_socket_name", config_->usb_v1_socket_name());
   LogAndSetEnv("vsock_guest_cid", std::to_string(config_->vsock_guest_cid()));
   LogAndSetEnv("logcat_mode", config_->logcat_mode());
   LogAndSetEnv("use_bootloader", config_->use_bootloader() ? "true" : "false");
diff --git a/host_package.mk b/host_package.mk
index 1eac968..66246f2 100644
--- a/host_package.mk
+++ b/host_package.mk
@@ -27,7 +27,6 @@
     vnc_server \
     cf_qemu.sh \
     cf_bpttool \
-    virtual_usb_manager \
     kernel_log_monitor \
     extract-vmlinux \
     crosvm \