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

extensions/browser/extension_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/extension_user_script_loader.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 #include "extensions/common/message_bundle.h"
 #include "extensions/common/one_shot_event.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::BrowserContext;
 
 namespace extensions {
 
 namespace {
 
+using SubstitutionMap = std::map<std::string, std::string>;
+
 // Verifies file contents as they are read.
 void VerifyContent(const scoped_refptr<ContentVerifier>& verifier,
                    const std::string& extension_id,
                    const base::FilePath& extension_root,
                    const base::FilePath& relative_path,
                    const std::string& content) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   scoped_refptr<ContentVerifyJob> job(
       verifier->CreateJobFor(extension_id, extension_root, relative_path));
   if (job.get()) {
     job->Start();
     job->BytesRead(content.size(), content.data());
     job->DoneReading();
   }
 }
 
 // Loads user scripts from the extension who owns these scripts.
-bool ExtensionLoadScriptContent(
-    const HostID& host_id,
-    UserScript::File* script_file,
-    const UserScriptLoader::SubstitutionMap* localization_messages,
-    const scoped_refptr<ContentVerifier>& verifier) {
+bool LoadScriptContent(const HostID& host_id,
+                       UserScript::File* script_file,
+                       const SubstitutionMap* localization_messages,
+                       const scoped_refptr<ContentVerifier>& verifier) {
   DCHECK(script_file);
   std::string content;
   const base::FilePath& path = ExtensionResource::GetFilePath(
       script_file->extension_root(), script_file->relative_path(),
       ExtensionResource::SYMLINKS_MUST_RESOLVE_WITHIN_ROOT);
   if (path.empty()) {
     int resource_id = 0;
     if (ExtensionsBrowserClient::Get()
             ->GetComponentExtensionResourceManager()
             ->IsComponentExtensionResource(script_file->extension_root(),
@@ skipping 33 matching lines @@
   // Remove BOM from the content.
   std::string::size_type index = content.find(base::kUtf8ByteOrderMark);
   if (index == 0)
     script_file->set_content(content.substr(strlen(base::kUtf8ByteOrderMark)));
   else
     script_file->set_content(content);
 
   return true;
 }
 
+SubstitutionMap* GetLocalizationMessages(
+    const ExtensionUserScriptLoader::HostsInfo& hosts_info,
+    const HostID& host_id) {
+  ExtensionUserScriptLoader::HostsInfo::const_iterator iter =
+      hosts_info.find(host_id);
+  if (iter == hosts_info.end())
+    return nullptr;
+  return file_util::LoadMessageBundleSubstitutionMap(
+      iter->second.first, host_id.id(), iter->second.second);
+}
+
+void LoadUserScripts(UserScriptList* user_scripts,
+                     const ExtensionUserScriptLoader::HostsInfo& hosts_info,
+                     const std::set<int>& added_script_ids,
+                     const scoped_refptr<ContentVerifier>& verifier) {
+  for (UserScript& script : *user_scripts) {
+    if (added_script_ids.count(script.id()) == 0)
+      continue;
+    scoped_ptr<SubstitutionMap> localization_messages(
+        GetLocalizationMessages(hosts_info, script.host_id()));
+    for (UserScript::File& script_file : script.js_scripts()) {
+      if (script_file.GetContent().empty())
+        LoadScriptContent(script.host_id(), &script_file, nullptr, verifier);
+    }
+    for (UserScript::File& script_file : script.css_scripts()) {
+      if (script_file.GetContent().empty())
+        LoadScriptContent(script.host_id(), &script_file,
+                          localization_messages.get(), verifier);
+    }
+  }
+}
+
+void LoadScriptsOnFileThread(
+    scoped_ptr<UserScriptList> user_scripts,
+    const ExtensionUserScriptLoader::HostsInfo& hosts_info,
+    const std::set<int>& added_script_ids,
+    const scoped_refptr<ContentVerifier>& verifier,
+    UserScriptLoader::LoadScriptsCallback callback) {
+  DCHECK(user_scripts.get());
+  LoadUserScripts(user_scripts.get(), hosts_info, added_script_ids, verifier);
+  scoped_ptr<base::SharedMemory> memory =
+      UserScriptLoader::Serialize(*user_scripts);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
+}
+
 }  // namespace
 
 ExtensionUserScriptLoader::ExtensionUserScriptLoader(
     BrowserContext* browser_context,
     const HostID& host_id,
     bool listen_for_extension_system_loaded)
-    : UserScriptLoader(
-          browser_context,
-          host_id,
+    : UserScriptLoader(browser_context, host_id),
+      content_verifier_(
           ExtensionSystem::Get(browser_context)->content_verifier()),
       extension_registry_observer_(this),
       weak_factory_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context));
   if (listen_for_extension_system_loaded) {
     ExtensionSystem::Get(browser_context)
         ->ready()
         .Post(FROM_HERE,
               base::Bind(&ExtensionUserScriptLoader::OnExtensionSystemReady,
                          weak_factory_.GetWeakPtr()));
   } else {
     SetReady(true);
   }
 }
 
 ExtensionUserScriptLoader::~ExtensionUserScriptLoader() {
 }
 
+void ExtensionUserScriptLoader::LoadScriptsForTest(
+    UserScriptList* user_scripts) {
+  HostsInfo info;
+  std::set<int> added_script_ids;
+  for (UserScript& script : *user_scripts)
+    added_script_ids.insert(script.id());
+
+  LoadUserScripts(user_scripts, info, added_script_ids,
+                  nullptr /* no verifier for testing */);
+}
+
+void ExtensionUserScriptLoader::LoadScripts(
+    scoped_ptr<UserScriptList> user_scripts,
+    const std::set<HostID>& changed_hosts,
+    const std::set<int>& added_script_ids,
+    LoadScriptsCallback callback) {
+  UpdateHostsInfo(changed_hosts);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&LoadScriptsOnFileThread, base::Passed(&user_scripts),
+                 hosts_info_, added_script_ids, content_verifier_, callback));
+}
+
 void ExtensionUserScriptLoader::UpdateHostsInfo(
     const std::set<HostID>& changed_hosts) {
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
   for (const HostID& host_id : changed_hosts) {
     const Extension* extension =
         registry->GetExtensionById(host_id.id(), ExtensionRegistry::ENABLED);
     // |changed_hosts_| may include hosts that have been removed,
     // which leads to the above lookup failing. In this case, just continue.
     if (!extension)
       continue;
-    AddHostInfo(host_id, ExtensionSet::ExtensionPathAndDefaultLocale(
-                             extension->path(),
-                             LocaleInfo::GetDefaultLocale(extension)));
+    if (hosts_info_.find(host_id) != hosts_info_.end())
+      continue;
+    hosts_info_[host_id] = ExtensionSet::ExtensionPathAndDefaultLocale(
+        extension->path(), LocaleInfo::GetDefaultLocale(extension));
   }
 }
 
-UserScriptLoader::LoadUserScriptsContentFunction
-ExtensionUserScriptLoader::GetLoadUserScriptsFunction() {
-  return base::Bind(&ExtensionLoadScriptContent);
-}
-
 void ExtensionUserScriptLoader::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
-  RemoveHostInfo(HostID(HostID::EXTENSIONS, extension->id()));
+  hosts_info_.erase(HostID(HostID::EXTENSIONS, extension->id()));
 }
 
 void ExtensionUserScriptLoader::OnExtensionSystemReady() {
   SetReady(true);
 }
 
 }  // namespace extensions