Move RemoveChars, ReplaceChars, TrimString, and TruncateUTF8ToByteSize to base namespace.

chrome/browser/policy/cloud/resource_cache.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 "chrome/browser/policy/cloud/resource_cache.h"
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/safe_numerics.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 
 namespace policy {
 
 namespace {
 
 // Verifies that |value| is not empty and encodes it into base64url format,
 // which is safe to use as a file name on all platforms.
 bool Base64Encode(const std::string& value, std::string* encoded) {
   DCHECK(!value.empty());
   if (value.empty() || !base::Base64Encode(value, encoded))
     return false;
-  ReplaceChars(*encoded, "+", "-", encoded);
-  ReplaceChars(*encoded, "/", "_", encoded);
+  base::ReplaceChars(*encoded, "+", "-", encoded);
+  base::ReplaceChars(*encoded, "/", "_", encoded);
   return true;
 }
 
 // Decodes all elements of |input| from base64url format and stores the decoded
 // elements in |output|.
 bool Base64Encode(const std::set<std::string>& input,
                   std::set<std::string>* output) {
   output->clear();
   for (std::set<std::string>::const_iterator it = input.begin();
        it != input.end(); ++it) {
     std::string encoded;
     if (!Base64Encode(*it, &encoded)) {
       output->clear();
       return false;
     }
     output->insert(encoded);
   }
   return true;
 }
 
 // Decodes |encoded| from base64url format and verifies that the result is not
 // emtpy.
 bool Base64Decode(const std::string& encoded, std::string* value) {
   std::string buffer;
-  ReplaceChars(encoded, "-", "+", &buffer);
-  ReplaceChars(buffer, "_", "/", &buffer);
+  base::ReplaceChars(encoded, "-", "+", &buffer);
+  base::ReplaceChars(buffer, "_", "/", &buffer);
   return base::Base64Decode(buffer, value) && !value->empty();
 }
 
 }  // namespace
 
 ResourceCache::ResourceCache(
     const base::FilePath& cache_dir,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : cache_dir_(cache_dir),
       task_runner_(task_runner) {
@@ skipping 167 matching lines @@
   if (!VerifyKeyPath(key, allow_create_key, &key_path) ||
       !Base64Encode(subkey, &encoded)) {
     return false;
   }
   *path = key_path.AppendASCII(encoded);
   return true;
 }
 
 
 }  // namespace policy