Stop copying script contents for each RenderFrames.

extensions/renderer/user_script_set.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_set.h"
 
 #include <stddef.h>
 
 #include <utility>
 
+#include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/renderer/extension_injection_host.h"
 #include "extensions/renderer/extensions_renderer_client.h"
 #include "extensions/renderer/injection_host.h"
 #include "extensions/renderer/renderer_extension_registry.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/user_script_injector.h"
 #include "extensions/renderer/web_ui_injection_host.h"
+#include "grit/extensions_renderer_resources.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
+// These two strings are injected before and after the Greasemonkey API and
+// user script to wrap it in an anonymous scope.
+const char kUserScriptHead[] = "(function (unsafeWindow) {\n";
+const char kUserScriptTail[] = "\n})(window);";
+
 GURL GetDocumentUrlForFrame(blink::WebLocalFrame* frame) {
   GURL data_source_url = ScriptContext::GetDataSourceURLForFrame(frame);
   if (!data_source_url.is_empty() && frame->isViewSourceModeEnabled()) {
     data_source_url = GURL(content::kViewSourceScheme + std::string(":") +
                            data_source_url.spec());
   }
 
   return data_source_url;
 }
 
+// Greasemonkey API source that is injected with the scripts.
+struct GreasemonkeyApiJsString {
+  GreasemonkeyApiJsString();
+  blink::WebScriptSource GetSource() const;
+
+ private:
+  blink::WebString source_;
+};
+
+// The below constructor, monstrous as it is, just makes a WebScriptSource from
+// the GreasemonkeyApiJs resource.
+GreasemonkeyApiJsString::GreasemonkeyApiJsString() {
+  base::StringPiece source_piece =
+      ResourceBundle::GetSharedInstance().GetRawDataResource(
+          IDR_GREASEMONKEY_API_JS);
+  source_ =
+      blink::WebString::fromUTF8(source_piece.data(), source_piece.length());
+}
+
+blink::WebScriptSource GreasemonkeyApiJsString::GetSource() const {
+  return blink::WebScriptSource(source_);
+}
+
+base::LazyInstance<GreasemonkeyApiJsString> g_greasemonkey_api =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 UserScriptSet::UserScriptSet() {}
 
 UserScriptSet::~UserScriptSet() {
 }
 
 void UserScriptSet::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 52 matching lines @@
     return false;
 
   // Unpickle scripts.
   uint32_t num_scripts = 0;
   base::Pickle pickle(reinterpret_cast<char*>(shared_memory_->memory()),
                       pickle_size);
   base::PickleIterator iter(pickle);
   CHECK(iter.ReadUInt32(&num_scripts));
 
   scripts_.clear();
+  js_script_sources_.clear();
+  css_script_sources_.clear();
   scripts_.reserve(num_scripts);
   for (uint32_t i = 0; i < num_scripts; ++i) {
     std::unique_ptr<UserScript> script(new UserScript());
     script->Unpickle(pickle, &iter);
 
     // Note that this is a pointer into shared memory. We don't own it. It gets
     // cleared up when the last renderer or browser process drops their
     // reference to the shared memory.
     for (size_t j = 0; j < script->js_scripts().size(); ++j) {
       const char* body = NULL;
@@ skipping 93 matching lines @@
   bool inject_js =
       !script->js_scripts().empty() && script->run_location() == run_location;
   if (inject_css || inject_js) {
     injection.reset(new ScriptInjection(std::move(injector), render_frame,
                                         std::move(injection_host), run_location,
                                         log_activity));
   }
   return injection;
 }
 
+std::vector<blink::WebScriptSource> UserScriptSet::GetJsSources(int script_id) {

[Devlin, 2016/08/25 17:07:35]

Semi-random placement: This is going to conflict with catmullings@'s patch at
https://codereview.chromium.org/2213603002/ to prevent duplicate script
injection. The idea there is that we avoid injecting a subset of the files if
they've already been injected in the frame.  For that, we need to be able to
construct a vector with a subset of the script files.

The easiest solution to this would be to change this method to just be a lookup
for a given file's url, so that the logic for what to inject remains in the
UserScriptInjector, and the UserScriptSet just stores all the cached webstrings
for a given file (that also obviates the need for separate js/css containers). 
It means the lookup is slightly less of a win (because we don't get the instant
vector), but I think that cost is reasonably small in the long run.

WDYT?

[lazyboy, 2016/09/06 19:37:32]

I've changed the storage to map GURL-> WebString.

+  UserScriptList::const_iterator script_iter =
+      std::find_if(scripts_.begin(), scripts_.end(),

[Devlin, 2016/08/25 17:07:35]

In the past, I've found that I've been too gung-ho to use the new c++11
fanciness in situations like this.  But at the end of the day, usually it's
clearer to do something like:
UserScript* script = nullptr;
for (const auto& iter : scripts_) {
  if (script->id() == script_id) {
    script = iter.get();
    break;
  }
}

It's one line more, but I find it significantly more readable, and I'd bet it's
also faster (since it avoids calling into the lambda function).

But, that's also just my opinion, so I'm fine with this too :)

[lazyboy, 2016/09/06 19:37:31]

Acknowledged, this is no longer relevant.

+                   [&script_id](const std::unique_ptr<UserScript>& script) {
+                     return script->id() == script_id;
+                   });
+  if (script_iter == scripts_.end())
+    return std::vector<blink::WebScriptSource>();
+
+  const UserScript& script = *script_iter->get();
+  std::map<int, std::vector<blink::WebScriptSource>>::iterator iter =
+      js_script_sources_.find(script_id);
+  if (iter != js_script_sources_.end()) {
+    // Win, we already have the script contents in WebString-s.
+    return iter->second;
+  }
+
+  iter = js_script_sources_.insert(iter, std::make_pair(
+      script_id, std::vector<blink::WebScriptSource>()));
+  std::vector<blink::WebScriptSource>& sources_vector = iter->second;
+
+  for (const std::unique_ptr<UserScript::File>& js_file :
+       script_iter->get()->js_scripts()) {
+    base::StringPiece script_content = js_file->GetContent();
+    blink::WebString source;
+    if (script.emulate_greasemonkey()) {
+      // We add this dumb function wrapper for user scripts to emulate what
+      // Greasemonkey does. |script_content| becomes:
+      // concat(kUserScriptHead, script_content, kUserScriptTail).
+      std::string content;
+      content.reserve(strlen(kUserScriptHead) + script_content.length() +
+                      strlen(kUserScriptTail));
+      content.append(kUserScriptHead);
+      script_content.AppendToString(&content);
+      content.append(kUserScriptTail);
+      source = blink::WebString::fromUTF8(content);
+    } else {
+      source = blink::WebString::fromUTF8(script_content.data(),
+                                          script_content.length());
+    }
+    sources_vector.push_back(blink::WebScriptSource(source));
+  }
+
+  // Emulate Greasemonkey API for scripts that were converted to extension
+  // user scripts.
+  if (script.emulate_greasemonkey()) {
+    sources_vector.insert(sources_vector.begin(),
+                          g_greasemonkey_api.Get().GetSource());
+  }
+
+  return sources_vector;
+}
+
+std::vector<blink::WebString> UserScriptSet::GetCssSources(int script_id) {
+  const auto& script_iter =
+      std::find_if(scripts_.begin(), scripts_.end(),
+                   [&script_id](const std::unique_ptr<UserScript>& script) {
+                     return script->id() == script_id;
+                   });
+  if (script_iter == scripts_.end())
+    return std::vector<blink::WebString>();
+  const UserScript& script = *script_iter->get();
+
+  auto iter = css_script_sources_.find(script_id);
+  if (iter != css_script_sources_.end()) {
+    // Win, we already have the script contents in WebString-s.
+    return iter->second;
+  }
+
+  iter = css_script_sources_.insert(iter, std::make_pair(
+      script_id, std::vector<blink::WebString>()));
+
+  std::vector<blink::WebString>& sources_vector = iter->second;
+  for (const std::unique_ptr<UserScript::File>& css_file :
+       script.css_scripts()) {
+    base::StringPiece script_content = css_file->GetContent();
+    sources_vector.push_back(blink::WebString::fromUTF8(
+        script_content.data(), script_content.length()));
+  }
+
+  return sources_vector;
+}
+
 }  // namespace extensions