Introduce HostID and de-couple Extensions from "script injection System" [browser side]

chrome/browser/extensions/user_script_loader.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 "chrome/browser/extensions/user_script_loader.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
-#include "base/memory/shared_memory.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
-#include "extensions/browser/component_extension_resource_manager.h"
 #include "extensions/browser/content_verifier.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/browser/extensions_browser_client.h"
-#include "extensions/common/extension_messages.h"
 #include "extensions/common/file_util.h"
-#include "extensions/common/manifest_handlers/default_locale_handler.h"
-#include "extensions/common/message_bundle.h"
-#include "extensions/common/one_shot_event.h"
-#include "ui/base/resource/resource_bundle.h"
 
 using content::BrowserThread;
-using extensions::ExtensionsBrowserClient;
 
 namespace extensions {
 
 namespace {
 
-typedef base::Callback<
-    void(scoped_ptr<UserScriptList>, scoped_ptr<base::SharedMemory>)>
-    LoadScriptsCallback;
+using LoadScriptsCallback =
+    base::Callback<void(scoped_ptr<UserScriptList>,
+                        scoped_ptr<base::SharedMemory>)>;
 
-void VerifyContent(scoped_refptr<ContentVerifier> verifier,
-                   const ExtensionId& 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();
-  }
+UserScriptLoader::SubstitutionMap* GetLocalizationMessages(
+    const UserScriptLoader::ConsumersInfo& consumers_info,
+    const ConsumerID& consumer_id) {
+  UserScriptLoader::ConsumersInfo::const_iterator iter =
+      consumers_info.find(consumer_id);
+  if (iter == consumers_info.end())
+    return nullptr;
+  return file_util::LoadMessageBundleSubstitutionMap(
+      iter->second.first, consumer_id.host_id(), iter->second.second);
 }
 
-bool LoadScriptContent(const ExtensionId& extension_id,
-                       UserScript::File* script_file,
-                       const SubstitutionMap* localization_messages,
-                       scoped_refptr<ContentVerifier> verifier) {
-  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;
-    if (ExtensionsBrowserClient::Get()->GetComponentExtensionResourceManager()->
-        IsComponentExtensionResource(script_file->extension_root(),
-                                     script_file->relative_path(),
-                                     &resource_id)) {
-      const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-      content = rb.GetRawDataResource(resource_id).as_string();
-    } else {
-      LOG(WARNING) << "Failed to get file path to "
-                   << script_file->relative_path().value() << " from "
-                   << script_file->extension_root().value();
-      return false;
-    }
-  } else {
-    if (!base::ReadFileToString(path, &content)) {
-      LOG(WARNING) << "Failed to load user script file: " << path.value();
-      return false;
-    }
-    if (verifier.get()) {
-      content::BrowserThread::PostTask(content::BrowserThread::IO,
-                                       FROM_HERE,
-                                       base::Bind(&VerifyContent,
-                                                  verifier,
-                                                  extension_id,
-                                                  script_file->extension_root(),
-                                                  script_file->relative_path(),
-                                                  content));
-    }
-  }
-
-  // Localize the content.
-  if (localization_messages) {
-    std::string error;
-    MessageBundle::ReplaceMessagesWithExternalDictionary(
-        *localization_messages, &content, &error);
-    if (!error.empty()) {
-      LOG(WARNING) << "Failed to replace messages in script: " << error;
-    }
-  }
-
-  // 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 ExtensionsInfo& extensions_info,
-                                         const ExtensionId& extension_id) {
-  ExtensionsInfo::const_iterator iter = extensions_info.find(extension_id);
-  if (iter == extensions_info.end())
-    return NULL;
-  return file_util::LoadMessageBundleSubstitutionMap(
-      iter->second.first, extension_id, iter->second.second);
-}
-
-void LoadUserScripts(UserScriptList* user_scripts,
-                     const ExtensionsInfo& extensions_info,
-                     const std::set<int>& added_script_ids,
-                     ContentVerifier* verifier) {
+void LoadUserScripts(
+    UserScriptList* user_scripts,
+    const UserScriptLoader::ConsumersInfo& consumers_info,
+    const std::set<int>& added_script_ids,
+    ContentVerifier* verifier,

[Devlin, 2015/01/20 17:51:05]

nit: Please update this to take a const scoped_refptr<ContentVerifier>& (and
similarly LoadScriptContent).

[Xi Han, 2015/01/21 21:30:16]

Updated.

+    UserScriptLoader::LoadUserScriptsFunctionCallback callback) {

[Devlin, 2015/01/20 17:51:05]

nit: I think |load_script_content_function| is more descriptive than |callback|.

[Xi Han, 2015/01/21 21:30:16]

Done.

   for (UserScriptList::iterator script = user_scripts->begin();
        script != user_scripts->end();
        ++script) {
     if (added_script_ids.count(script->id()) == 0)
       continue;
-    scoped_ptr<SubstitutionMap> localization_messages(
-        GetLocalizationMessages(extensions_info, script->extension_id()));
+    scoped_ptr<UserScriptLoader::SubstitutionMap> localization_messages(
+        GetLocalizationMessages(consumers_info, script->consumer_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->extension_id(), &script_file, NULL, verifier);
+        callback.Run(script->consumer_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->extension_id(),
-                          &script_file,
-                          localization_messages.get(),
-                          verifier);
+        callback.Run(script->consumer_id(), &script_file,
+                     localization_messages.get(), verifier);
     }
   }
 }
 
 // Pickle user scripts and return pointer to the shared memory.
 scoped_ptr<base::SharedMemory> Serialize(const UserScriptList& scripts) {
   Pickle pickle;
   pickle.WriteSizeT(scripts.size());
   for (UserScriptList::const_iterator script = scripts.begin();
        script != scripts.end();
@@ skipping 31 matching lines @@
 
   base::SharedMemoryHandle readonly_handle;
   if (!shared_memory.ShareReadOnlyToProcess(base::GetCurrentProcessHandle(),
                                             &readonly_handle))
     return scoped_ptr<base::SharedMemory>();
 
   return make_scoped_ptr(new base::SharedMemory(readonly_handle,
                                                 /*read_only=*/true));
 }
 
-void LoadScriptsOnFileThread(scoped_ptr<UserScriptList> user_scripts,
-                             const ExtensionsInfo& extensions_info,
-                             const std::set<int>& added_script_ids,
-                             scoped_refptr<ContentVerifier> verifier,
-                             LoadScriptsCallback callback) {
+void LoadScriptsOnFileThread(
+    scoped_ptr<UserScriptList> user_scripts,
+    const UserScriptLoader::ConsumersInfo& consumers_info,
+    const std::set<int>& added_script_ids,
+    scoped_refptr<ContentVerifier> verifier,
+    UserScriptLoader::LoadUserScriptsFunctionCallback function,
+    LoadScriptsCallback callback) {
   DCHECK(user_scripts.get());
-  LoadUserScripts(
-      user_scripts.get(), extensions_info, added_script_ids, verifier.get());
+  LoadUserScripts(user_scripts.get(), consumers_info, added_script_ids,
+                  verifier.get(), function);
   scoped_ptr<base::SharedMemory> memory = Serialize(*user_scripts);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
 }
 
 // Helper function to parse greasesmonkey headers
 bool GetDeclarationValue(const base::StringPiece& line,
                          const base::StringPiece& prefix,
@@ skipping 102 matching lines @@
   }
 
   // If no patterns were specified, default to @include *. This is what
   // Greasemonkey does.
   if (script->globs().empty() && script->url_patterns().is_empty())
     script->add_glob("*");
 
   return true;
 }
 
-// static
 void UserScriptLoader::LoadScriptsForTest(UserScriptList* user_scripts) {
-  ExtensionsInfo info;
+  ConsumersInfo 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 */);
+  LoadUserScripts(user_scripts, info, added_script_ids,
+                  NULL /* no verifier for testing */,
+                  GetLoadUserScriptsFunction());
 }
 
 UserScriptLoader::UserScriptLoader(Profile* profile,
-                                   const ExtensionId& owner_extension_id,
-                                   bool listen_for_extension_system_loaded)
+                                   const ConsumerID& consumer_id,
+                                   ContentVerifier* content_verifier)

[Devlin, 2015/01/20 17:51:05]

Please update this to take a const scoped_refptr<ContentVerifier>&.

[Xi Han, 2015/01/21 21:30:16]

Done.

     : user_scripts_(new UserScriptList()),
       clear_scripts_(false),
-      extension_system_ready_(false),
+      ready_(false),
       pending_load_(false),
       profile_(profile),
-      owner_extension_id_(owner_extension_id),
-      extension_registry_observer_(this),
+      consumer_id_(consumer_id),
+      content_verifier_(content_verifier),
       weak_factory_(this) {
-  extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
-  if (listen_for_extension_system_loaded) {
-    ExtensionSystem::Get(profile_)->ready().Post(
-        FROM_HERE,
-        base::Bind(&UserScriptLoader::OnExtensionSystemReady,
-                   weak_factory_.GetWeakPtr()));
-  } else {
-    extension_system_ready_ = true;
-  }
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 UserScriptLoader::~UserScriptLoader() {
 }
 
 void UserScriptLoader::AddScripts(const std::set<UserScript>& scripts) {
   for (std::set<UserScript>::const_iterator it = scripts.begin();
@@ skipping 25 matching lines @@
 void UserScriptLoader::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK_EQ(type, content::NOTIFICATION_RENDERER_PROCESS_CREATED);
   content::RenderProcessHost* process =
       content::Source<content::RenderProcessHost>(source).ptr();
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   if (!profile_->IsSameProfile(profile))
     return;
   if (scripts_ready()) {
-    SendUpdate(process,
-               shared_memory_.get(),
-               std::set<ExtensionId>());  // Include all extensions.
+    SendUpdate(process, shared_memory_.get(),
+               std::set<ConsumerID>());  // Include all consumers.
   }
 }
 
-void UserScriptLoader::OnExtensionUnloaded(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    UnloadedExtensionInfo::Reason reason) {
-  extensions_info_.erase(extension->id());
-}
-
-void UserScriptLoader::OnExtensionSystemReady() {
-  extension_system_ready_ = true;
-  AttemptLoad();
-}
-
 bool UserScriptLoader::ScriptsMayHaveChanged() const {
   // Scripts may have changed if there are scripts added, scripts removed, or
   // if scripts were cleared and either:
   // (1) A load is in progress (which may result in a non-zero number of
   //     scripts that need to be cleared), or
   // (2) The current set of scripts is non-empty (so they need to be cleared).
   return (added_scripts_.size() ||
           removed_scripts_.size() ||
           (clear_scripts_ &&
            (is_loading() || user_scripts_->size())));
 }
 
 void UserScriptLoader::AttemptLoad() {
-  if (extension_system_ready_ && ScriptsMayHaveChanged()) {
+  if (ready_ && ScriptsMayHaveChanged()) {
     if (is_loading())
       pending_load_ = true;
     else
       StartLoad();
   }
 }
 
+UserScriptLoader::LoadUserScriptsFunctionCallback
+UserScriptLoader::GetLoadUserScriptsFunction() {
+  return base::Bind(&UserScriptLoader::LoadScriptContent);
+}
+
 void UserScriptLoader::StartLoad() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_loading());
 
   // If scripts were marked for clearing before adding and removing, then clear
   // them.
   if (clear_scripts_) {
     user_scripts_->clear();
   } else {
     for (UserScriptList::iterator it = user_scripts_->begin();
          it != user_scripts_->end();) {
       if (removed_scripts_.count(*it))
         it = user_scripts_->erase(it);
       else
         ++it;
     }
   }
 
   user_scripts_->insert(
       user_scripts_->end(), added_scripts_.begin(), added_scripts_.end());
 
   std::set<int> added_script_ids;
   for (std::set<UserScript>::const_iterator it = added_scripts_.begin();
        it != added_scripts_.end();
        ++it) {
     added_script_ids.insert(it->id());
   }
 
-  // Expand |changed_extensions_| for OnScriptsLoaded, which will use it in
+  // Expand |changed_consumers_| for OnScriptsLoaded, which will use it in
   // its IPC message. This must be done before we clear |added_scripts_| and
   // |removed_scripts_| below.
   std::set<UserScript> changed_scripts(added_scripts_);
   changed_scripts.insert(removed_scripts_.begin(), removed_scripts_.end());
-  ExpandChangedExtensions(changed_scripts);
+  ExpandChangedConsumers(changed_scripts);
 
-  // Update |extensions_info_| to contain info from every extension in
-  // |changed_extensions_| before passing it to LoadScriptsOnFileThread.
-  UpdateExtensionsInfo();
+  // |changed_consumers_| before passing it to LoadScriptsOnFileThread.
+  UpdateConsumersInfo(changed_consumers_);
 
   BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&LoadScriptsOnFileThread,
-                 base::Passed(&user_scripts_),
-                 extensions_info_,
-                 added_script_ids,
-                 make_scoped_refptr(
-                     ExtensionSystem::Get(profile_)->content_verifier()),
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&LoadScriptsOnFileThread, base::Passed(&user_scripts_),
+                 consumers_info_, added_script_ids,
+                 make_scoped_refptr(content_verifier_),
+                 GetLoadUserScriptsFunction(),
                  base::Bind(&UserScriptLoader::OnScriptsLoaded,
                             weak_factory_.GetWeakPtr())));
 
   clear_scripts_ = false;
   added_scripts_.clear();
   removed_scripts_.clear();
   user_scripts_.reset(NULL);
 }
 
+// static
+bool UserScriptLoader::LoadScriptContent(

[Devlin, 2015/01/20 17:51:05]

Why can't we remove this method, remove the static method declaration in the .h,
move the ExtensionUserScriptLoader::LoadScriptContent into an anonymous
namespace in the .cc of that file, and make GetLoadUserScriptsFunction
pure-virtual?

[Xi Han, 2015/01/21 21:30:17]

Done.

+    const ConsumerID& consumer_id,
+    UserScript::File* script_file,
+    const SubstitutionMap* localization_messages,
+    scoped_refptr<ContentVerifier> verifier) {
+  return false;
+}
+
+void UserScriptLoader::AddConsumerInfo(const ConsumerID& consumer_id,
+                                       const PathAndDefaultLocale& location) {
+  if (consumers_info_.find(consumer_id) != consumers_info_.end())
+    return;
+  consumers_info_[consumer_id] = location;
+}
+
+void UserScriptLoader::RemoveConsumerInfo(const std::string& host_id) {
+  std::set<ConsumerID> ids_to_delete;
+
+  for (ConsumersInfo::iterator it = consumers_info_.begin();
+       it != consumers_info_.end(); ++it) {
+    const ConsumerID& id = it->first;
+    if (id.host_id() == host_id)
+      ids_to_delete.insert(id);
+  }
+
+  for (std::set<ConsumerID>::iterator it = ids_to_delete.begin();
+       it != ids_to_delete.end(); ++it)
+    consumers_info_.erase(*it);
+}
+
+void UserScriptLoader::SetReady(bool ready) {
+  ready_ = ready;
+  if (ready_)
+    AttemptLoad();

[Devlin, 2015/01/20 17:51:05]

We should either:
DCHECK_NE(ready, ready_);
or
bool was_ready = ready_;
ready_ = ready;
if (ready_ && !was_ready)
  AttemptLoad();

i.e., if we were already ready, we shouldn't attempt the load.

[Xi Han, 2015/01/21 21:30:17]

Done.

+}
+
 void UserScriptLoader::OnScriptsLoaded(
     scoped_ptr<UserScriptList> user_scripts,
     scoped_ptr<base::SharedMemory> shared_memory) {
   user_scripts_.reset(user_scripts.release());
   if (pending_load_) {
     // While we were loading, there were further changes. Don't bother
     // notifying about these scripts and instead just immediately reload.
     pending_load_ = false;
     StartLoad();
     return;
@@ skipping 11 matching lines @@
     return;
   }
 
   // We've got scripts ready to go.
   shared_memory_.reset(shared_memory.release());
 
   for (content::RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd();
        i.Advance()) {
-    SendUpdate(i.GetCurrentValue(), shared_memory_.get(), changed_extensions_);
+    SendUpdate(i.GetCurrentValue(), shared_memory_.get(), changed_consumers_);
   }
-  changed_extensions_.clear();
+  changed_consumers_.clear();
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
       content::Source<Profile>(profile_),
       content::Details<base::SharedMemory>(shared_memory_.get()));
 }
 
 void UserScriptLoader::SendUpdate(
     content::RenderProcessHost* process,
     base::SharedMemory* shared_memory,
-    const std::set<ExtensionId>& changed_extensions) {
+    const std::set<ConsumerID>& changed_consumers) {
   // Don't allow injection of content scripts into <webview>.
   if (process->IsIsolatedGuest())
     return;
 
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   // Make sure we only send user scripts to processes in our profile.
   if (!profile_->IsSameProfile(profile))
     return;
 
   // If the process is being started asynchronously, early return.  We'll end up
   // calling InitUserScripts when it's created which will call this again.
   base::ProcessHandle handle = process->GetHandle();
   if (!handle)
     return;
 
   base::SharedMemoryHandle handle_for_process;
   if (!shared_memory->ShareToProcess(handle, &handle_for_process))
     return;  // This can legitimately fail if the renderer asserts at startup.
 
-  if (base::SharedMemory::IsHandleValid(handle_for_process)) {

[Devlin, 2015/01/20 17:51:05]

Why not keep this if here, so that subclasses don't have to worry about it?

[Xi Han, 2015/01/21 21:30:17]

Sure, move the code back.

-    process->Send(new ExtensionMsg_UpdateUserScripts(
-        handle_for_process, owner_extension_id_, changed_extensions));
-  }
+  SendUpdate(process, handle_for_process, changed_consumers);
 }
 
-void UserScriptLoader::ExpandChangedExtensions(
+void UserScriptLoader::ExpandChangedConsumers(
     const std::set<UserScript>& scripts) {
   for (std::set<UserScript>::const_iterator it = scripts.begin();

[Devlin, 2015/01/20 17:51:05]

let's C++11-ify this:
for (const UserScript& script : scripts)
  changed_consumers_.insert(script.consumer_id());

[Xi Han, 2015/01/21 21:30:16]

Done.

        it != scripts.end();
        ++it) {
-    changed_extensions_.insert(it->extension_id());
+    changed_consumers_.insert(it->consumer_id());
   }
 }
 
-void UserScriptLoader::UpdateExtensionsInfo() {
-  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
-  for (std::set<ExtensionId>::const_iterator it = changed_extensions_.begin();
-       it != changed_extensions_.end();
-       ++it) {
-    if (extensions_info_.find(*it) == extensions_info_.end()) {
-      const Extension* extension =
-          registry->GetExtensionById(*it, ExtensionRegistry::EVERYTHING);
-      // |changed_extensions_| may include extensions that have been removed,
-      // which leads to the above lookup failing. In this case, just continue.
-      if (!extension)
-        continue;
-      extensions_info_[*it] = ExtensionSet::ExtensionPathAndDefaultLocale(
-          extension->path(), LocaleInfo::GetDefaultLocale(extension));
-    }
-  }
-}
-
 }  // namespace extensions