Implement <webview>.addContentScript/removeContentScript API [2]

extensions/browser/web_ui_user_script_loader.cc

+// Copyright 2015 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/browser/web_ui_user_script_loader.h"
+
+#include "base/bind.h"
+#include "base/pickle.h"
+#include "base/strings/string_util.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "extensions/browser/content_verifier.h"
+
+namespace {
+using LoadScriptsCallback =
+    base::Callback<void(scoped_ptr<extensions::UserScriptList>,
+                        scoped_ptr<base::SharedMemory>)>;
+
+void SerializeOnFileThread(scoped_ptr<extensions::UserScriptList> user_scripts,
+                           LoadScriptsCallback callback) {
+  scoped_ptr<base::SharedMemory> memory =
+      extensions::UserScriptLoader::Serialize(*user_scripts);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
+}
+
+}  // namespace
+
+struct WebUIUserScriptLoader::UserScriptRenderInfo {
+  int render_process_id;
+  int render_view_id;
+
+  UserScriptRenderInfo() : render_process_id(-1), render_view_id(-1) {}
+
+  UserScriptRenderInfo(int render_process_id, int render_view_id)
+      : render_process_id(render_process_id), render_view_id(render_view_id) {}
+
+  bool operator<(const UserScriptRenderInfo& other) {
+    if (render_process_id != other.render_process_id)
+      return render_process_id < other.render_process_id;
+
+    if (render_view_id != other.render_view_id)
+      return render_view_id < other.render_view_id;
+
+    return false;
+  }
+};
+
+WebUIUserScriptLoader::WebUIUserScriptLoader(
+    content::BrowserContext* browser_context,
+    const HostID& host_id)
+    : UserScriptLoader(browser_context, host_id), weak_factory_(this) {
+  SetReady(true);
+}
+
+WebUIUserScriptLoader::~WebUIUserScriptLoader() {
+}
+
+void WebUIUserScriptLoader::AddScripts(
+    const std::set<extensions::UserScript>& scripts,
+    int render_process_id,
+    int render_view_id) {
+  UserScriptRenderInfo info(render_process_id, render_view_id);
+  for (const extensions::UserScript& script : scripts)
+    script_render_info_map_.insert(
+        std::pair<int, UserScriptRenderInfo>(script.id(), info));
+
+  extensions::UserScriptLoader::AddScripts(scripts);
+}
+
+void WebUIUserScriptLoader::LoadScripts(const std::set<HostID>& changed_hosts,

[Devlin, 2015/04/20 23:48:25]

See comment in other class about changing this method signature.

[Xi Han, 2015/04/21 21:18:58]

Done.

+                                        const std::set<int>& added_script_ids) {
+  ClearScripts(false);
+
+  std::set<extensions::UserScript::File*> file_set;

[Devlin, 2015/04/20 23:48:25]

unless you need the uniqueness that a set offers, prefer vector.

[Xi Han, 2015/04/21 21:18:58]

Done.

+  bool find_render_info = false;
+  UserScriptRenderInfo info;
+
+  for (extensions::UserScript& script : *user_scripts_) {
+    if (added_script_ids.count(script.id()) == 0)
+      continue;
+
+    // Since every script in |added_script_ids| is associated with the same

[Devlin, 2015/04/20 23:48:25]

If every script here is guaranteed to be associated with the same render info,
why do we need a map of render info at all (as opposed to a single instance)?

[Xi Han, 2015/04/21 21:18:58]

Updated the comment here. After reconsidering it, I think we need this map since
user scripts may be added by calling multiple AddScripts() when loading, so we
cannot guarantee all of them comes from the same render. 

+    // render info, so we only need to look up the map once.
+    if (!find_render_info) {
+      auto iter = script_render_info_map_.find(script.id());
+      if (iter != script_render_info_map_.end()) {
+        info.render_process_id = iter->second.render_process_id;
+        info.render_view_id = iter->second.render_view_id;
+      }
+      find_render_info = true;
+    }
+
+    for (size_t k = 0; k < script.js_scripts().size(); ++k) {
+      extensions::UserScript::File& script_file = script.js_scripts()[k];
+      if (script_file.GetContent().empty()) {
+        file_set.insert(&script_file);
+      }
+    }
+    for (size_t k = 0; k < script.css_scripts().size(); ++k) {
+      extensions::UserScript::File& script_file = script.css_scripts()[k];
+      if (script_file.GetContent().empty()) {
+        file_set.insert(&script_file);
+      }
+    }
+    script_render_info_map_.erase(script.id());
+  }
+  // Initial URL fetches.
+  complete_fetchers_ = 0;
+  total_fetchers_ = file_set.size();
+
+  for (extensions::UserScript::File* file : file_set) {
+    scoped_ptr<WebUIURLFetcher> fetcher(new WebUIURLFetcher(
+        browser_context(),
+        base::Bind(&WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete,
+                   base::Unretained(this), file)));
+    fetcher->Start(info.render_process_id, info.render_view_id, file->url());
+    fetchers_.push_back(fetcher.release());
+  }
+}
+
+void WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete(
+    extensions::UserScript::File* script_file,
+    bool success,
+    const std::string& data) {
+  if (success) {
+    // Remove BOM from the content.
+    std::string::size_type index = data.find(base::kUtf8ByteOrderMark);
+    if (index == 0)
+      script_file->set_content(data.substr(strlen(base::kUtf8ByteOrderMark)));
+    else
+      script_file->set_content(data);
+  }
+
+  ++complete_fetchers_;
+  if (complete_fetchers_ == total_fetchers_) {
+    OnWebUIURLFetchComplete();
+    fetchers_.clear();
+  }
+}
+
+void WebUIUserScriptLoader::OnWebUIURLFetchComplete() {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&SerializeOnFileThread, base::Passed(&user_scripts_),
+                 base::Bind(&WebUIUserScriptLoader::OnScriptsLoaded,
+                            weak_factory_.GetWeakPtr())));
+  user_scripts_.reset(nullptr);
+}