[Android] Switch adb_reverse_forwarder to argparse.

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 <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ skipping 143 matching lines @@
 
   void HandleRequestOnInternalThread(const std::string& adb_path,
                                      const std::string& device_serial,
                                      int device_port,
                                      int host_port,
                                      std::unique_ptr<Socket> client_socket) {
     const int adb_port = GetAdbPortForDevice(adb_path, device_serial);
     if (adb_port < 0) {
       SendMessage(
           "ERROR: could not get adb port for device. You might need to add "
-          "'adb' to your PATH or provide the device serial id.",
+          "'adb' to your PATH or provide the device serial id.\n",
           client_socket.get());
       return;
     }
     if (device_port < 0) {
       // Remove the previously created host controller.
       const std::string controller_key = MakeHostControllerMapKey(
           adb_port, -device_port);
       const bool controller_did_exist = DeleteRefCountedValueInMap(
           controller_key, controllers_.get());
       if (!controller_did_exist) {
-        SendMessage("ERROR: could not unmap port.", client_socket.get());
+        SendMessage("ERROR: could not unmap port.\n", client_socket.get());
         LogExistingControllers(client_socket);
       } else {
         SendMessage("OK", client_socket.get());
       }
 
       RemoveAdbPortForDeviceIfNeeded(adb_path, device_serial);
       return;
     }
     if (host_port < 0) {
-      SendMessage("ERROR: missing host port", client_socket.get());
+      SendMessage("ERROR: missing host port\n", 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);
       if (controllers_->find(controller_key) != controllers_->end()) {
         LOG(INFO) << "Already forwarding device port " << device_port
                   << " to host port " << host_port;
         SendMessage(base::StringPrintf("%d:%d", device_port, host_port),
                     client_socket.get());
         return;
       }
     }
     // Create a new host controller.
     std::unique_ptr<HostController> host_controller(HostController::Create(
         device_port, host_port, adb_port, GetExitNotifierFD(),
         base::Bind(&HostControllersManager::DeleteHostController,
                    weak_ptr_factory_.GetWeakPtr())));
     if (!host_controller.get()) {
       has_failed_ = true;
-      SendMessage("ERROR: Connection to device failed.", client_socket.get());
+      SendMessage("ERROR: Connection to device failed.\n", client_socket.get());
       LogExistingControllers(client_socket);
       return;
     }
     // Get the current allocated port.
     device_port = host_controller->device_port();
     LOG(INFO) << "Forwarding device port " << device_port << " to host port "
               << 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 LogExistingControllers(const std::unique_ptr<Socket>& client_socket) {
-    SendMessage("ERROR: Existing controllers:", client_socket.get());
+    SendMessage("ERROR: Existing controllers:\n", client_socket.get());
     for (const auto& controller : *controllers_) {
-      SendMessage(base::StringPrintf("ERROR:   %s", controller.first.c_str()),
+      SendMessage(base::StringPrintf("ERROR: %s\n", controller.first.c_str()),
           client_socket.get());
     }
   }
 
   void RemoveAdbPortForDeviceIfNeeded(const std::string& adb_path,
                                       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;
@@ skipping 105 matching lines @@
       PError("Read()");
       has_failed_ = true;
       return;
     }
     const base::Pickle command_pickle(buf, bytes_read);
     base::PickleIterator pickle_it(command_pickle);
     std::string device_serial;
     CHECK(pickle_it.ReadString(&device_serial));
     int device_port;
     if (!pickle_it.ReadInt(&device_port)) {
-      client_socket->WriteString("ERROR: missing device port");
+      client_socket->WriteString("ERROR: missing device port\n");
       return;
     }
     int host_port;
     if (!pickle_it.ReadInt(&host_port))
       host_port = -1;
     controllers_manager_.HandleRequest(adb_path_, device_serial, device_port,
                                        host_port, std::move(client_socket));
   }
 
  private:
@@ skipping 107 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);
 }