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

chrome/browser/devtools/device/adb/mock_adb_server.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/devtools/device/adb/mock_adb_server.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/location.h"
@@ skipping 409 matching lines @@
     }
     return 0;
   }
 
   void ProcessCommand(const std::string& command) {
     CHECK(CalledOnValidThread());
     if (command == "host:devices") {
       SendSuccess(base::StringPrintf("%s\tdevice\n%s\toffline",
                                      kSerialOnline,
                                      kSerialOffline));
-    } else if (command.find(kHostTransportPrefix) == 0) {
+    } else if (base::StartsWith(command, kHostTransportPrefix,
+                                base::CompareCase::SENSITIVE)) {
       serial_ = command.substr(strlen(kHostTransportPrefix));
       SendSuccess(std::string());
     } else if (serial_ != kSerialOnline) {
       Send("FAIL", "device offline (x)");
     } else {
       mock_connection_ =
           base::WrapUnique(new MockAndroidConnection(this, serial_, command));
     }
   }
 
@@ skipping 92 matching lines @@
       SendHTTPResponse(kSampleChromePages);
     else
       NOTREACHED() << "Unknown command " << request;
   } else if (socket_name_ == "chrome_devtools_remote_1002") {
     if (path == kJsonVersionPath)
       SendHTTPResponse(kSampleChromeBetaVersion);
     else if (path == kJsonListPath)
       SendHTTPResponse(kSampleChromeBetaPages);
     else
       NOTREACHED() << "Unknown command " << request;
-  } else if (socket_name_.find("noprocess_devtools_remote") == 0) {
+  } else if (base::StartsWith(socket_name_, "noprocess_devtools_remote",
+                              base::CompareCase::SENSITIVE)) {
     if (path == kJsonVersionPath)
       SendHTTPResponse("{}");
     else if (path == kJsonListPath)
       SendHTTPResponse("[]");
     else
       NOTREACHED() << "Unknown command " << request;
   } else if (socket_name_ == "webview_devtools_remote_2425") {
     if (path == kJsonVersionPath)
       SendHTTPResponse(kSampleWebViewVersion);
     else if (path == kJsonListPath)
       SendHTTPResponse(kSampleWebViewPages);
     else
       NOTREACHED() << "Unknown command " << request;
   } else {
     NOTREACHED() << "Unknown socket " << socket_name_;
   }
 }
 
 void MockAndroidConnection::ProcessCommand(const std::string& command) {
-  if (command.find(kLocalAbstractPrefix) == 0) {
+  if (base::StartsWith(command, kLocalAbstractPrefix,
+                       base::CompareCase::SENSITIVE)) {
     socket_name_ = command.substr(strlen(kLocalAbstractPrefix));
     delegate_->SendSuccess(std::string());
+    return;
+  }
+
+  if (base::StartsWith(command, kShellPrefix, base::CompareCase::SENSITIVE)) {
+    std::string result;
+    for (const auto& line :
+         base::SplitString(command.substr(strlen(kShellPrefix)), "\n",

[lazyboy, 2016/07/11 20:34:54]

Tangential: Do you not prefer using sizeof(kShellPrefix)-1 instead of strlen()?

[Lei Zhang, 2016/07/11 21:01:47]

Done. Ya, I got lazy. The 2007 era answer I found for "Can I portably assume
that strlen("foo") will be evaluated at compile time?" is no, and I imagine it's
still true.

+                           base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
+      if (line == kDeviceModelCommand) {
+        result += kDeviceModel;
+        result += "\r\n";
+      } else if (line == kOpenedUnixSocketsCommand) {
+        result += kSampleOpenedUnixSockets;
+      } else if (line == kDumpsysCommand) {
+        result += kSampleDumpsys;
+      } else if (line == kListProcessesCommand) {
+        result += kSampleListProcesses;
+      } else if (line == kListUsersCommand) {
+        result += kSampleListUsers;
+      } else if (base::StartsWith(line, kEchoCommandPrefix,
+                                  base::CompareCase::SENSITIVE)) {
+        result += line.substr(strlen(kEchoCommandPrefix));
+        result += "\r\n";
+      } else {
+        NOTREACHED() << "Unknown shell command - " << command;
+      }
+    }
+    delegate_->SendSuccess(result);
   } else {
-    if (command.find(kShellPrefix) == 0) {
-      std::string result;
-      for (const auto& line :
-           base::SplitString(command.substr(strlen(kShellPrefix)), "\n",
-                             base::KEEP_WHITESPACE,
-                             base::SPLIT_WANT_NONEMPTY)) {
-        if (line == kDeviceModelCommand) {
-          result += kDeviceModel;
-          result += "\r\n";
-        } else if (line == kOpenedUnixSocketsCommand) {
-          result += kSampleOpenedUnixSockets;
-        } else if (line == kDumpsysCommand) {
-          result += kSampleDumpsys;
-        } else if (line == kListProcessesCommand) {
-          result += kSampleListProcesses;
-        } else if (line == kListUsersCommand) {
-          result += kSampleListUsers;
-        } else if (line.find(kEchoCommandPrefix) == 0) {
-          result += line.substr(strlen(kEchoCommandPrefix));
-          result += "\r\n";
-        } else {
-          NOTREACHED() << "Unknown shell command - " << command;
-        }
-      }
-      delegate_->SendSuccess(result);
-    } else {
-      NOTREACHED() << "Unknown command - " << command;
-    }
-    delegate_->Close();
+    NOTREACHED() << "Unknown command - " << command;
   }
+  delegate_->Close();
 }
 
 void MockAndroidConnection::SendHTTPResponse(const std::string& body) {
   std::string response_data(base::StringPrintf(kHttpResponse,
                                                static_cast<int>(body.size()),
                                                body.c_str()));
   delegate_->SendRaw(response_data);
 }
 
 void StartMockAdbServer(FlushMode flush_mode) {
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&StartMockAdbServerOnIOThread, flush_mode),
       base::MessageLoop::QuitWhenIdleClosure());
   content::RunMessageLoop();
 }
 
 void StopMockAdbServer() {
   BrowserThread::PostTaskAndReply(BrowserThread::IO, FROM_HERE,
                                   base::Bind(&StopMockAdbServerOnIOThread),
                                   base::MessageLoop::QuitWhenIdleClosure());
   content::RunMessageLoop();
 }