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 LoadScriptsCallback =
+    base::Callback<void(scoped_ptr<UserScriptList>,
+                        scoped_ptr<base::SharedMemory>)>;
+
 // 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(
+bool LoadScriptContent(
     const HostID& host_id,
     UserScript::File* script_file,
     const UserScriptLoader::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()) {
@@ skipping 37 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;
 }
 
+UserScriptLoader::SubstitutionMap* GetLocalizationMessages(
+    const UserScriptLoader::HostsInfo& hosts_info,
+    const HostID& host_id) {
+  UserScriptLoader::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 UserScriptLoader::HostsInfo& hosts_info,
+                     const std::set<int>& added_script_ids,
+                     const scoped_refptr<ContentVerifier>& verifier) {
+  for (UserScriptList::iterator script = user_scripts->begin();
+       script != user_scripts->end(); ++script) {
+    if (added_script_ids.count(script->id()) == 0)
+      continue;
+    scoped_ptr<UserScriptLoader::SubstitutionMap> localization_messages(
+        GetLocalizationMessages(hosts_info, script->host_id()));
+    for (size_t k = 0; k < script->js_scripts().size(); ++k) {
+      UserScript::File& script_file = script->js_scripts()[k];
+      if (script_file.GetContent().empty())
+        LoadScriptContent(script->host_id(), &script_file, NULL, verifier);
+    }
+    for (size_t k = 0; k < script->css_scripts().size(); ++k) {
+      UserScript::File& script_file = script->css_scripts()[k];
+      if (script_file.GetContent().empty())
+        LoadScriptContent(script->host_id(), &script_file,
+                          localization_messages.get(), verifier);
+    }
+  }
+}
+
+void LoadScriptsOnFileThread(scoped_ptr<UserScriptList> user_scripts,
+                             const UserScriptLoader::HostsInfo& hosts_info,
+                             const std::set<int>& added_script_ids,
+                             const scoped_refptr<ContentVerifier>& verifier,
+                             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 (UserScriptList::iterator it = user_scripts->begin();
+       it != user_scripts->end(); ++it) {
+    added_script_ids.insert(it->id());
+  }
+  LoadUserScripts(user_scripts, info, added_script_ids,
+                  NULL /* no verifier for testing */);
+}
+
+void ExtensionUserScriptLoader::LoadScripts(

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

This would be cleaner if we kept the |user_scripts_| in the superclass as much
as possible.  Let's have the superclass pass in the user_scripts_ here, as well
as a callback to OnScriptsLoaded.

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

Change |user_scripts_| to a private member of base class.

+    const std::set<HostID>& changed_hosts,
+    const std::set<int>& added_script_ids) {
+  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_,
+                 base::Bind(&ExtensionUserScriptLoader::OnScriptsLoaded,
+                            weak_factory_.GetWeakPtr())));
+  ClearScripts(false);
+  user_scripts_.reset(NULL);
+}
+
 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())
+      return;

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

Why return?  Shouldn't it be continue?

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

Good catch, thanks.

+    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