Use base::StartWith() in more places when appropriate.

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 222 matching lines @@
                                       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)
+      if (base::StartsWith(others->first, prefix, base::CompareCase::SENSITIVE))
         return;
     }
     // No other port is being forwarded to this device:
     // - Remove it from our internal serial -> adb port map.
     // - Remove from "adb forward" command.
     LOG(INFO) << "Device " << device_serial << " has no more ports.";
     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(
@@ skipping 57 matching lines @@
   std::unique_ptr<HostControllerMap> controllers_;
   bool has_failed_;
   std::unique_ptr<base::AtExitManager>
       at_exit_manager_;  // Needed by base::Thread.
   std::unique_ptr<base::Thread> thread_;
   base::WeakPtrFactory<HostControllersManager> weak_ptr_factory_;
 };
 
 class ServerDelegate : public Daemon::ServerDelegate {
  public:
-  ServerDelegate(const std::string& adb_path)
+  explicit ServerDelegate(const std::string& adb_path)
       : adb_path_(adb_path), has_failed_(false) {}
 
   bool has_failed() const {
     return has_failed_ || controllers_manager_.has_failed();
   }
 
   // Daemon::ServerDelegate:
   void Init() override {
     LOG(INFO) << "Starting host process daemon (pid=" << getpid() << ")";
     DCHECK(!g_notifier);
@@ skipping 31 matching lines @@
  private:
   std::string adb_path_;
   bool has_failed_;
   HostControllersManager controllers_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerDelegate);
 };
 
 class ClientDelegate : public Daemon::ClientDelegate {
  public:
-  ClientDelegate(const base::Pickle& command_pickle)
+  explicit ClientDelegate(const base::Pickle& command_pickle)
       : command_pickle_(command_pickle), has_failed_(false) {}
 
   bool has_failed() const { return has_failed_; }
 
   // Daemon::ClientDelegate:
   void OnDaemonReady(Socket* daemon_socket) override {
     // Send the forward command to the daemon.
     CHECK_EQ(static_cast<long>(command_pickle_.size()),
              daemon_socket->WriteNumBytes(command_pickle_.data(),
                                           command_pickle_.size()));
@@ skipping 87 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);
 }