Move StartsWith[ASCII] to base namespace.

components/policy/core/common/preg_parser_win.cc

 // Copyright (c) 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 "components/policy/core/common/preg_parser_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 158 matching lines @@
       subdict = new RegistryDict();
       dict->SetKey(name, make_scoped_ptr(subdict));
     }
     dict = subdict;
   }
 
   if (value.empty())
     return;
 
   std::string value_name(base::UTF16ToUTF8(value));
-  if (!StartsWithASCII(value_name, kActionTriggerPrefix, true)) {
+  if (!base::StartsWithASCII(value_name, kActionTriggerPrefix, true)) {
     scoped_ptr<base::Value> value;
     if (DecodePRegValue(type, data, &value))
       dict->SetValue(value_name, value.Pass());
     return;
   }
 
   std::string action_trigger(base::StringToLowerASCII(value_name.substr(
       arraysize(kActionTriggerPrefix) - 1)));
   if (action_trigger == kActionTriggerDeleteValues) {
     std::vector<std::string> values;
     Tokenize(DecodePRegStringValue(data), ";", &values);
     for (std::vector<std::string>::const_iterator value(values.begin());
          value != values.end(); ++value) {
       dict->RemoveValue(*value);
     }
-  } else if (StartsWithASCII(action_trigger, kActionTriggerDeleteKeys, true)) {
+  } else if (base::StartsWithASCII(action_trigger, kActionTriggerDeleteKeys,
+                                   true)) {
     std::vector<std::string> keys;
     Tokenize(DecodePRegStringValue(data), ";", &keys);
     for (std::vector<std::string>::const_iterator key(keys.begin());
          key != keys.end(); ++key) {
       dict->RemoveKey(*key);
     }
-  } else if (StartsWithASCII(action_trigger, kActionTriggerDel, true)) {
+  } else if (base::StartsWithASCII(action_trigger, kActionTriggerDel, true)) {
     dict->RemoveValue(
         value_name.substr(arraysize(kActionTriggerPrefix) - 1 +
                           arraysize(kActionTriggerDel) - 1));
-  } else if (StartsWithASCII(action_trigger, kActionTriggerDelVals, true)) {
+  } else if (base::StartsWithASCII(action_trigger, kActionTriggerDelVals,
+                                   true)) {
     // Delete all values.
     dict->ClearValues();
-  } else if (StartsWithASCII(action_trigger, kActionTriggerSecureKey, true) ||
-             StartsWithASCII(action_trigger, kActionTriggerSoft, true)) {
+  } else if (base::StartsWithASCII(action_trigger, kActionTriggerSecureKey,
+                                   true) ||
+             base::StartsWithASCII(action_trigger, kActionTriggerSoft, true)) {
     // Doesn't affect values.
   } else {
     LOG(ERROR) << "Bad action trigger " << value_name;
   }
 }
 
 bool ReadFile(const base::FilePath& file_path,
               const base::string16& root,
               RegistryDict* dict,
               PolicyLoadStatusSample* status) {
@@ skipping 67 matching lines @@
       data.resize(size);
       if (!ReadFieldBinary(&cursor, end, size, vector_as_array(&data)))
         break;
       current = NextChar(&cursor, end);
     }
 
     if (current != kDelimBracketClose)
       break;
 
     // Process the record if it is within the |root| subtree.
-    if (StartsWith(key_name, root, false))
+    if (base::StartsWith(key_name, root, false))
       HandleRecord(key_name.substr(root.size()), value, type, data, dict);
   }
 
   LOG(ERROR) << "Error parsing " << file_path.value() << " at offset "
              << reinterpret_cast<const uint8*>(cursor - 1) - mapped_file.data();
   status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
   return false;
 }
 
 }  // namespace preg_parser
 }  // namespace policy