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

extensions/renderer/user_script_injector.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 "extensions/renderer/user_script_injector.h"
 
 #include <tuple>
 #include <vector>
 
 #include "base/lazy_instance.h"
@@ skipping 66 matching lines @@
   return blink::WebScriptSource(source_);
 }
 
 base::LazyInstance<GreasemonkeyApiJsString>::Leaky g_greasemonkey_api =
     LAZY_INSTANCE_INITIALIZER;
 
 bool ShouldInjectScripts(const UserScript::FileList& scripts,
                          const std::set<std::string>& injected_files) {
   for (const std::unique_ptr<UserScript::File>& file : scripts) {
     // Check if the script is already injected.
-    if (injected_files.count(file->url().path()) == 0) {
+    if (injected_files.count(file->url().path().as_string()) == 0) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace
 
 UserScriptInjector::UserScriptInjector(const UserScript* script,
                                        UserScriptSet* script_list,
@@ skipping 122 matching lines @@
   const UserScript::FileList& js_scripts = script_->js_scripts();
   sources.reserve(js_scripts.size() +
                   (script_->emulate_greasemonkey() ? 1 : 0));
   // Emulate Greasemonkey API for scripts that were converted to extension
   // user scripts.
   if (script_->emulate_greasemonkey())
     sources.push_back(g_greasemonkey_api.Get().GetSource());
   for (const std::unique_ptr<UserScript::File>& file : js_scripts) {
     const GURL& script_url = file->url();
     // Check if the script is already injected.
-    if (executing_scripts->count(script_url.path()) != 0)
+    if (executing_scripts->count(script_url.path().as_string()) != 0)
       continue;
 
     sources.push_back(blink::WebScriptSource(
         user_script_set_->GetJsSource(*file, script_->emulate_greasemonkey()),
         script_url));
 
     (*num_injected_js_scripts) += 1;
-    executing_scripts->insert(script_url.path());
+    executing_scripts->insert(script_url.path().as_string());
   }
 
   return sources;
 }
 
 std::vector<blink::WebString> UserScriptInjector::GetCssSources(
     UserScript::RunLocation run_location,
     std::set<std::string>* injected_stylesheets,
     size_t* num_injected_stylesheets) const {
   DCHECK(script_);
   DCHECK_EQ(UserScript::DOCUMENT_START, run_location);
 
   std::vector<blink::WebString> sources;
 
   const UserScript::FileList& css_scripts = script_->css_scripts();
   sources.reserve(css_scripts.size());
   for (const std::unique_ptr<UserScript::File>& file : script_->css_scripts()) {
-    const std::string& stylesheet_path = file->url().path();
+    const std::string& stylesheet_path = file->url().path().as_string();
     // Check if the stylesheet is already injected.
     if (injected_stylesheets->count(stylesheet_path) != 0)
       continue;
 
     sources.push_back(user_script_set_->GetCssSource(*file));
     (*num_injected_stylesheets) += 1;
     injected_stylesheets->insert(stylesheet_path);
   }
   return sources;
 }
 
 void UserScriptInjector::OnInjectionComplete(
     std::unique_ptr<base::Value> execution_result,
     UserScript::RunLocation run_location,
     content::RenderFrame* render_frame) {}
 
 void UserScriptInjector::OnWillNotInject(InjectFailureReason reason,
                                          content::RenderFrame* render_frame) {
 }
 
 }  // namespace extensions