Add more string_util functions to base namespace.

components/search_engines/template_url.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 "components/search_engines/template_url.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 334 matching lines @@
 bool TemplateURLRef::IsValid(const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return valid_;
 }
 
 base::string16 TemplateURLRef::DisplayURL(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   std::string result(GetURL());
   if (valid_ && !replacements_.empty()) {
-    ReplaceSubstringsAfterOffset(&result, 0,
-                                 kSearchTermsParameterFull,
-                                 kDisplaySearchTerms);
-    ReplaceSubstringsAfterOffset(&result, 0,
-                                 kGoogleUnescapedSearchTermsParameterFull,
-                                 kDisplayUnescapedSearchTerms);
+    base::ReplaceSubstringsAfterOffset(&result, 0,
+                                       kSearchTermsParameterFull,
+                                       kDisplaySearchTerms);
+    base::ReplaceSubstringsAfterOffset(&result, 0,
+                                       kGoogleUnescapedSearchTermsParameterFull,
+                                       kDisplayUnescapedSearchTerms);
   }
   return base::UTF8ToUTF16(result);
 }
 
 // static
 std::string TemplateURLRef::DisplayURLToURLRef(
     const base::string16& display_url) {
   std::string result = base::UTF16ToUTF8(display_url);
-  ReplaceSubstringsAfterOffset(&result, 0,
-                               kDisplaySearchTerms,
-                               kSearchTermsParameterFull);
-  ReplaceSubstringsAfterOffset(&result, 0,
-                               kDisplayUnescapedSearchTerms,
-                               kGoogleUnescapedSearchTermsParameterFull);
+  base::ReplaceSubstringsAfterOffset(&result, 0,
+                                     kDisplaySearchTerms,
+                                     kSearchTermsParameterFull);
+  base::ReplaceSubstringsAfterOffset(&result, 0,
+                                     kDisplayUnescapedSearchTerms,
+                                     kGoogleUnescapedSearchTermsParameterFull);
   return result;
 }
 
 const std::string& TemplateURLRef::GetHost(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return host_;
 }
 
 const std::string& TemplateURLRef::GetPath(
@@ skipping 385 matching lines @@
       // could be more than one term, but it's uncommon; so we punt.
       if (has_only_one_search_term)
         ParseHostAndSearchTermKey(search_terms_data);
     }
   }
 }
 
 void TemplateURLRef::ParseHostAndSearchTermKey(
     const SearchTermsData& search_terms_data) const {
   std::string url_string(GetURL());
-  ReplaceSubstringsAfterOffset(&url_string, 0, "{google:baseURL}",
-                               search_terms_data.GoogleBaseURLValue());
-  ReplaceSubstringsAfterOffset(&url_string, 0, "{google:baseSuggestURL}",
-                               search_terms_data.GoogleBaseSuggestURLValue());
+  base::ReplaceSubstringsAfterOffset(
+      &url_string, 0, "{google:baseURL}",
+      search_terms_data.GoogleBaseURLValue());
+  base::ReplaceSubstringsAfterOffset(
+      &url_string, 0, "{google:baseSuggestURL}",
+      search_terms_data.GoogleBaseSuggestURLValue());
 
   search_term_key_.clear();
   search_term_position_in_path_ = std::string::npos;
   host_.clear();
   path_.clear();
   search_term_key_location_ = url::Parsed::QUERY;
 
   GURL url(url_string);
   if (!url.is_valid())
     return;
@@ skipping 714 matching lines @@
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }