[WIP] make GURL::path() return a StringPiece

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/command_line.h"
@@ skipping 125 matching lines @@
                               &result.value_prefix, &result.value_suffix)) {
         result.key = params.substr(key.begin, key.len);
         break;
       }
     }
   }
   return result;
 }
 
 // Extract the position of the search terms' parameter in the URL path.
-bool FindSearchTermsInPath(const std::string& path,
+bool FindSearchTermsInPath(const base::StringPiece& path,
                            url::Component* parameter_position) {
   DCHECK(parameter_position);
   parameter_position->reset();
   const size_t begin = path.find(kSearchTermsParameterFullEscaped);
   if (begin == std::string::npos)
     return false;
   parameter_position->begin = begin;
   parameter_position->len = arraysize(kSearchTermsParameterFullEscaped) - 1;
   return true;
 }
@@ skipping 336 matching lines @@
       (url.port() != port_) ||
       ((url.path() != path_) &&
           (search_term_key_location_ != url::Parsed::PATH))) {
     return false;
   }
 
   std::string source;
   url::Component position;
 
   if (search_term_key_location_ == url::Parsed::PATH) {
-    source = url.path();
+    source = url.path().as_string();
 
     // Characters in the path before and after search terms must match.
     if (source.length() < path_.length())
       return false;
     position.begin = search_term_position_in_path_;
     position.len = source.length() - path_.length();
     if (source.substr(0, position.begin) + source.substr(position.end()) !=
         path_)
       return false;
   } else {
@@ skipping 303 matching lines @@
   auto ref_result = FindSearchTermsKey(url.ref());
   url::Component parameter_position;
   const bool in_query = query_result.found();
   const bool in_ref = ref_result.found();
   const bool in_path = FindSearchTermsInPath(url.path(), &parameter_position);
   if (in_query ? (in_ref || in_path) : (in_ref == in_path))
     return;  // No key or multiple keys found.  We only handle having one key.
 
   host_ = url.host();
   port_ = url.port();
-  path_ = url.path();
+  path_ = url.path().as_string();
   if (in_query) {
     search_term_key_ = query_result.key;
     search_term_key_location_ = url::Parsed::QUERY;
     search_term_value_prefix_ = query_result.value_prefix;
     search_term_value_suffix_ = query_result.value_suffix;
   } else if (in_ref) {
     search_term_key_ = ref_result.key;
     search_term_key_location_ = url::Parsed::REF;
     search_term_value_prefix_ = ref_result.value_prefix;
     search_term_value_suffix_ = ref_result.value_suffix;
@@ skipping 541 matching lines @@
   EncodeSearchTerms(search_terms_args, is_in_query, &input_encoding,
                     &encoded_terms, &encoded_original_query);
 
   std::string old_params;
   if (search_term_component == url::Parsed::QUERY) {
     old_params = url.query();
   } else if (search_term_component == url::Parsed::REF) {
     old_params = url.ref();
   } else {
     DCHECK_EQ(search_term_component, url::Parsed::PATH);
-    old_params = url.path();
+    old_params = url.path().as_string();
   }
 
   std::string new_params(old_params, 0, search_terms_position.begin);
   new_params += base::UTF16ToUTF8(encoded_terms);
   new_params += old_params.substr(search_terms_position.end());
   GURL::Replacements replacements;
 
   if (search_term_component == url::Parsed::QUERY) {
     replacements.SetQueryStr(new_params);
   } else if (search_term_component == url::Parsed::REF) {
@@ skipping 131 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;
 }