Relands Android perf tests: kill adbd on the device after running a test.

tools/android/forwarder2/host_forwarder_main.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
@@ skipping 157 matching lines @@
     }
     if (device_port < 0) {
       // Remove the previously created host controller.
       const std::string controller_key = MakeHostControllerMapKey(
           adb_port, -device_port);
       const HostControllerMap::size_type removed_elements = controllers_->erase(
           controller_key);
       SendMessage(
           !removed_elements ? "ERROR: could not unmap port" : "OK",
           client_socket.get());
+
+      RemoveAdbPortForDeviceIfNeeded(device_serial);
       return;
     }
     if (host_port < 0) {
       SendMessage("ERROR: missing host port", client_socket.get());
       return;
     }
     const bool use_dynamic_port_allocation = device_port == 0;
     if (!use_dynamic_port_allocation) {
       const std::string controller_key = MakeHostControllerMapKey(
           adb_port, device_port);
@@ skipping 22 matching lines @@
               << host_port;
     const std::string msg = base::StringPrintf("%d:%d", device_port, host_port);
     if (!SendMessage(msg, client_socket.get()))
       return;
     host_controller->Start();
     controllers_->insert(
         std::make_pair(MakeHostControllerMapKey(adb_port, device_port),
                        linked_ptr<HostController>(host_controller.release())));
   }
 
+  void RemoveAdbPortForDeviceIfNeeded(const std::string& device_serial) {
+    base::hash_map<std::string, int>::const_iterator it =
+        device_serial_to_adb_port_map_.find(device_serial);
+    if (it == device_serial_to_adb_port_map_.end())
+      return;
+
+    int port = it->second;
+    const std::string prefix = base::StringPrintf("%d:", port);
+    for (HostControllerMap::const_iterator others = controllers_->begin();
+         others != controllers_->end(); ++others) {
+      if (others->first.find(prefix) == 0U)
+        return;
+    }
+    // No other port is being forwarded to this device:
+    // - Remove it from our internal serial -> adb port map.
+    // - Remove from "adb forward" command.
+    device_serial_to_adb_port_map_.erase(device_serial);
+    const std::string serial_part = device_serial.empty() ?
+        std::string() : std::string("-s ") + device_serial;
+    const std::string command = base::StringPrintf(
+        "adb %s forward --remove tcp:%d",
+        serial_part.c_str(),
+        port);
+    LOG(INFO) << command;
+    const int ret = system(command.c_str());
+    DCHECK(ret == 0);
+  }
+
   int GetAdbPortForDevice(const std::string& device_serial) {
     base::hash_map<std::string, int>::const_iterator it =
         device_serial_to_adb_port_map_.find(device_serial);
     if (it != device_serial_to_adb_port_map_.end())
       return it->second;
     Socket bind_socket;
     CHECK(bind_socket.BindTcp("127.0.0.1", 0));
     const int port = bind_socket.GetPort();
     bind_socket.Close();
     const std::string serial_part = device_serial.empty() ?
         std::string() : std::string("-s ") + device_serial;
     const std::string command = base::StringPrintf(
         "adb %s forward tcp:%d localabstract:chrome_device_forwarder",
-        device_serial.empty() ? "" : serial_part.c_str(),
+        serial_part.c_str(),
         port);
     LOG(INFO) << command;
     const int ret = system(command.c_str());
     if (ret < 0 || !WIFEXITED(ret) || WEXITSTATUS(ret) != 0)
       return -1;
     device_serial_to_adb_port_map_[device_serial] = port;
     return port;
   }
 
   bool SendMessage(const std::string& msg, Socket* client_socket) {
@@ skipping 161 matching lines @@
 
   return client_delegate.has_failed() || daemon_delegate.has_failed();
 }
 
 }  // namespace
 }  // namespace forwarder2
 
 int main(int argc, char** argv) {
   return forwarder2::RunHostForwarder(argc, argv);
 }