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

content/browser/dom_storage/session_storage_database.cc

 // Copyright 2013 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 "content/browser/dom_storage/session_storage_database.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include <vector>
@@ skipping 280 matching lines @@
   if (!DatabaseErrorCheck(it->status().ok())) {
     db_->ReleaseSnapshot(options.snapshot);
     return false;
   }
 
   // Skip the dummy entry "namespace-" and iterate the namespaces.
   std::string current_namespace_start_key;
   std::string current_namespace_id;
   for (it->Next(); it->Valid(); it->Next()) {
     std::string key = it->key().ToString();
-    if (key.find(namespace_prefix) != 0) {
+    if (!base::StartsWith(key, namespace_prefix,
+                          base::CompareCase::SENSITIVE)) {
       // Iterated past the "namespace-" keys.
       break;
     }
     // For each namespace, the first key is "namespace-<namespaceid>-", and the
     // subsequent keys are "namespace-<namespaceid>-<origin>". Read the unique
     // "<namespaceid>" parts from the keys.
     if (current_namespace_start_key.empty() ||
         key.substr(0, current_namespace_start_key.length()) !=
         current_namespace_start_key) {
       // The key is of the form "namespace-<namespaceid>-" for a new
@@ skipping 178 matching lines @@
     // The namespace_start_key is not found when the namespace doesn't contain
     // any areas. We don't need to do anything.
     return true;
   }
   if (!DatabaseErrorCheck(it->status().ok()))
     return false;
 
   // Skip the dummy entry "namespace-<namespaceid>-" and iterate the origins.
   for (it->Next(); it->Valid(); it->Next()) {
     std::string key = it->key().ToString();
-    if (key.find(namespace_start_key) != 0) {
+    if (!base::StartsWith(key, namespace_start_key,
+                          base::CompareCase::SENSITIVE)) {
       // Iterated past the origins for this namespace.
       break;
     }
     std::string origin = key.substr(namespace_start_key.length());
     std::string map_id = it->value().ToString();
     (*areas)[origin] = map_id;
   }
   return true;
 }
 
@@ skipping 31 matching lines @@
     return false;
   // Advance the iterator 2 times (we still haven't really deleted
   // namespace_key).
   it->Next();
   if (!ConsistencyCheck(it->Valid()))
     return false;
   it->Next();
   if (!it->Valid())
     return true;
   std::string key = it->key().ToString();
-  if (key.find(namespace_start_key) != 0)
+  if (!base::StartsWith(key, namespace_start_key, base::CompareCase::SENSITIVE))
     batch->Delete(namespace_start_key);
   return true;
 }
 
 bool SessionStorageDatabase::GetMapForArea(const std::string& namespace_id,
                                            const std::string& origin,
                                            const leveldb::ReadOptions& options,
                                            bool* exists, std::string* map_id) {
   std::string namespace_key = NamespaceKey(namespace_id, origin);
   leveldb::Status s = db_->Get(options, namespace_key, map_id);
@@ skipping 38 matching lines @@
   // If the key is not found, the status of the iterator won't be IsNotFound(),
   // but the iterator will be invalid. The map needs to exist, otherwise we have
   // a stale map_id in the database.
   if (!ConsistencyCheck(it->Valid()))
     return false;
   if (!DatabaseErrorCheck(it->status().ok()))
     return false;
   // Skip the dummy entry "map-<mapid>-".
   for (it->Next(); it->Valid(); it->Next()) {
     std::string key = it->key().ToString();
-    if (key.find(map_start_key) != 0) {
+    if (!base::StartsWith(key, map_start_key, base::CompareCase::SENSITIVE)) {
       // Iterated past the keys in this map.
       break;
     }
     // Key is of the form "map-<mapid>-<key>".
     base::string16 key16 =
         base::UTF8ToUTF16(key.substr(map_start_key.length()));
     if (only_keys) {
       (*result)[key16] = base::NullableString16();
     } else {
       // Convert the raw data stored in std::string (it->value()) to raw data
@@ skipping 140 matching lines @@
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace content