Replace string::find(prefix) == 0 pattern with base::StartsWith().

components/devtools_http_handler/devtools_http_handler.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
@@ skipping 377 matching lines @@
              << filename
              << " text/plain will be returned";
   NOTREACHED();
   return "text/plain";
 }
 
 void ServerWrapper::OnHttpRequest(int connection_id,
                                   const net::HttpServerRequestInfo& info) {
   server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
 
-  if (info.path.find("/json") == 0) {
+  if (base::StartsWith(info.path, "/json", base::CompareCase::SENSITIVE)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandler::OnJsonRequest,
                    handler_,
                    connection_id,
                    info));
     return;
   }
 
-  if (info.path.find(kThumbUrlPrefix) == 0) {
+  if (base::StartsWith(info.path, kThumbUrlPrefix,
+                       base::CompareCase::SENSITIVE)) {
     // Thumbnail request.
     const std::string target_id = info.path.substr(strlen(kThumbUrlPrefix));
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandler::OnThumbnailRequest,
                    handler_,
                    connection_id,
                    target_id));
     return;
   }
 
   if (info.path.empty() || info.path == "/") {
     // Discovery page request.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandler::OnDiscoveryPageRequest,
                    handler_,
                    connection_id));
     return;
   }
 
-  if (info.path.find("/devtools/") != 0) {
+  if (!base::StartsWith(info.path, "/devtools/",
+                        base::CompareCase::SENSITIVE)) {
     server_->Send404(connection_id);
     return;
   }
 
   std::string filename = PathWithoutParams(info.path.substr(10));
   std::string mime_type = GetMimeType(filename);
 
   if (!frontend_dir_.empty()) {
     base::FilePath path = frontend_dir_.AppendASCII(filename);
     std::string data;
@@ skipping 66 matching lines @@
     const std::string& path,
     std::string* command,
     std::string* target_id) {
 
   // Fall back to list in case of empty query.
   if (path.empty()) {
     *command = "list";
     return true;
   }
 
-  if (path.find("/") != 0) {
+  if (!base::StartsWith(path, "/", base::CompareCase::SENSITIVE)) {
     // Malformed command.
     return false;
   }
   *command = path.substr(1);
 
   size_t separator_pos = command->find("/");
   if (separator_pos != std::string::npos) {
     *target_id = command->substr(separator_pos + 1);
     *command = command->substr(0, separator_pos);
   }
@@ skipping 158 matching lines @@
           GetMimeType(path));
 }
 
 void DevToolsHttpHandler::OnWebSocketRequest(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
 
   std::string browser_prefix = "/devtools/browser";
-  size_t browser_pos = request.path.find(browser_prefix);
-  if (browser_pos == 0) {
+  if (base::StartsWith(request.path, browser_prefix,
+                       base::CompareCase::SENSITIVE)) {
     scoped_refptr<DevToolsAgentHost> browser_agent =
         DevToolsAgentHost::CreateForBrowser(
             thread_->task_runner(),
             base::Bind(&ServerSocketFactory::CreateForTethering,
                        base::Unretained(socket_factory_)));
     connection_to_client_[connection_id] = new DevToolsAgentHostClientImpl(
         thread_->message_loop(), server_wrapper_, connection_id, browser_agent);
     AcceptWebSocket(connection_id, request);
     return;
   }
 
   // Handle external connections (such as frontend api) on the embedder level.
   content::DevToolsExternalAgentProxyDelegate* external_delegate =
       delegate_->HandleWebSocketConnection(request.path);
   if (external_delegate) {
     scoped_refptr<DevToolsAgentHost> agent_host =
         DevToolsAgentHost::Create(external_delegate);
     connection_to_client_[connection_id] = new DevToolsAgentHostClientImpl(
         thread_->message_loop(), server_wrapper_, connection_id, agent_host);
     AcceptWebSocket(connection_id, request);
     return;
   }
 
-  size_t pos = request.path.find(kPageUrlPrefix);
-  if (pos != 0) {
+  if (!base::StartsWith(request.path, kPageUrlPrefix,
+                        base::CompareCase::SENSITIVE)) {
     Send404(connection_id);
     return;
   }
 
   std::string target_id = request.path.substr(strlen(kPageUrlPrefix));
   DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
   scoped_refptr<DevToolsAgentHost> agent =
       descriptor ? descriptor->GetAgentHost() : nullptr;
   if (!agent.get()) {
     Send500(connection_id, "No such target id: " + target_id);
@@ skipping 194 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace devtools_http_handler