Declarative content scripts: Browser-side: per-extension shared memory regions (lazily loaded)

chrome/browser/extensions/user_script_loader.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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_master.h"
+#include "chrome/browser/extensions/user_script_loader.h"
 
+#include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/shared_memory.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/i18n/default_locale_handler.h"
 #include "chrome/common/extensions/manifest_handlers/content_scripts_handler.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/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;
+typedef base::Callback<
+    void(scoped_ptr<std::set<UserScript> >, scoped_ptr<base::SharedMemory>)>
+    LoadScriptsCallback;
 
 void VerifyContent(scoped_refptr<ContentVerifier> verifier,
-                   const std::string& extension_id,
+                   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();
   }
 }
 
-bool LoadScriptContent(const std::string& extension_id,
+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(),
+      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)) {
+    if (ExtensionsBrowserClient::Get()
+            ->GetComponentExtensionResourceManager()

[Devlin, 2014/08/04 18:33:25]

nit: I'm sure that this is just git cl format, but please avoid style changes
like this, because it just makes noise in the git/svn history.  Exceptions for
if it's an egregious style mistake.

[Mark Dittmer, 2014/08/05 20:33:19]

Done.

+            ->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)) {
@@ skipping 27 matching lines @@
   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 std::string& extension_id) {
+                                         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);
+  return file_util::LoadMessageBundleSubstitutionMap(
+      iter->second.first, extension_id, iter->second.second);
 }
 
-void LoadUserScripts(UserScriptList* user_scripts,
+void LoadUserScripts(std::set<UserScript>* user_scripts,
                      const ExtensionsInfo& extensions_info,
-                     const std::set<std::string>& new_extensions,
+                     const std::set<UserScript>& added_scripts,
                      ContentVerifier* verifier) {
-  for (size_t i = 0; i < user_scripts->size(); ++i) {
-    UserScript& script = user_scripts->at(i);
-    if (new_extensions.count(script.extension_id()) == 0)
+  for (std::set<UserScript>::iterator script = user_scripts->begin();
+       script != user_scripts->end();
+       ++script) {
+    if (added_scripts.count(*script) == 0)
       continue;
     scoped_ptr<SubstitutionMap> localization_messages(
-        GetLocalizationMessages(extensions_info, script.extension_id()));
-    for (size_t k = 0; k < script.js_scripts().size(); ++k) {
-      UserScript::File& script_file = script.js_scripts()[k];
+        GetLocalizationMessages(extensions_info, script->extension_id()));
+    for (size_t k = 0; k < script->js_scripts().size(); ++k) {
+      UserScript::File& script_file =
+          const_cast<UserScript::File&>(script->js_scripts()[k]);

[Devlin, 2014/08/04 18:33:25]

Why do we need the const cast?

[Mark Dittmer, 2014/08/05 20:33:19]

std::set const'ifies its iterators because it's concerned about the user
changing data that is used for (in)equality operations. The const'ness of the
UserScript in the iterator bleeds out to the UserScript::File. In this case, we
are safe because this code path will never call set_id() on the UserScript in
the set; in fact, we only de-const the UserScript::File (which is not used for
(in)equality operations on UserScripts).

[Devlin, 2014/08/05 21:47:26]

Ah.  Right you are.  Unfortunately, any kind of modification to the value while
iterating over a set results in undefined behavior (unless you were to make the
modified member mutable) [1].

This... is ugly.  The best solution I can think of is probably to convert
|user_scripts_| back to a vector.  This may make adding/removing marginally
slower, but not too bad given |user_scripts_| should be fairly small, and
addition/removal should be fairly rare.  If we do this, we should also convert
|removed_scripts_| and |added_scripts_| to sets of int64 to save some space.

Any other ideas?

[1] This comes from jyasskin@, C++ guru supreme.

[Mark Dittmer, 2014/08/06 15:32:24]

I don't think we can get away with added/removed as int64s. User scripts that
arrive while the UI thread does not have ownership of user_scripts_ may contain
metadata that needs to be copied to user_scripts_ later.

For now, I've changed user_scripts_ to UserScriptList, but left the other
collections as std::set<UserScript>.

       if (script_file.GetContent().empty())
-        LoadScriptContent(
-            script.extension_id(), &script_file, NULL, verifier);
+        LoadScriptContent(script->extension_id(), &script_file, NULL, verifier);
     }
-    for (size_t k = 0; k < script.css_scripts().size(); ++k) {
-      UserScript::File& script_file = script.css_scripts()[k];
+    for (size_t k = 0; k < script->css_scripts().size(); ++k) {
+      UserScript::File& script_file =
+          const_cast<UserScript::File&>(script->css_scripts()[k]);
       if (script_file.GetContent().empty())
-        LoadScriptContent(script.extension_id(),
+        LoadScriptContent(script->extension_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) {
+scoped_ptr<base::SharedMemory> Serialize(const std::set<UserScript>& scripts) {
   Pickle pickle;
   pickle.WriteUInt64(scripts.size());
-  for (size_t i = 0; i < scripts.size(); i++) {
-    const UserScript& script = scripts[i];
+  for (std::set<UserScript>::const_iterator script = scripts.begin();
+       script != scripts.end();
+       ++script) {
     // TODO(aa): This can be replaced by sending content script metadata to
     // renderers along with other extension data in ExtensionMsg_Loaded.
     // See crbug.com/70516.
-    script.Pickle(&pickle);
+    script->Pickle(&pickle);
     // Write scripts as 'data' so that we can read it out in the slave without
     // allocating a new string.
-    for (size_t j = 0; j < script.js_scripts().size(); j++) {
-      base::StringPiece contents = script.js_scripts()[j].GetContent();
+    for (size_t j = 0; j < script->js_scripts().size(); j++) {
+      base::StringPiece contents = script->js_scripts()[j].GetContent();
       pickle.WriteData(contents.data(), contents.length());
     }
-    for (size_t j = 0; j < script.css_scripts().size(); j++) {
-      base::StringPiece contents = script.css_scripts()[j].GetContent();
+    for (size_t j = 0; j < script->css_scripts().size(); j++) {
+      base::StringPiece contents = script->css_scripts()[j].GetContent();
       pickle.WriteData(contents.data(), contents.length());
     }
   }
 
   // Create the shared memory object.
   base::SharedMemory shared_memory;
 
   base::SharedMemoryCreateOptions options;
   options.size = pickle.size();
   options.share_read_only = true;
   if (!shared_memory.Create(options))
     return scoped_ptr<base::SharedMemory>();
 
   if (!shared_memory.Map(pickle.size()))
     return scoped_ptr<base::SharedMemory>();
 
   // Copy the pickle to shared memory.
   memcpy(shared_memory.memory(), pickle.data(), pickle.size());
 
   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,
+void LoadScriptsOnFileThread(scoped_ptr<std::set<UserScript> > user_scripts,
                              const ExtensionsInfo& extensions_info,
-                             const std::set<std::string>& new_extensions,
+                             const std::set<UserScript>& added_scripts,
                              scoped_refptr<ContentVerifier> verifier,
                              LoadScriptsCallback callback) {
   DCHECK(user_scripts.get());
-  LoadUserScripts(
-      user_scripts.get(), extensions_info, new_extensions, verifier);
+  LoadUserScripts(user_scripts.get(), extensions_info, added_scripts, verifier);
   scoped_ptr<base::SharedMemory> memory = Serialize(*user_scripts);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(callback,
-                 base::Passed(&user_scripts),
-                 base::Passed(&memory)));
+      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,
                          std::string* value) {
   base::StringPiece::size_type index = line.find(prefix);
   if (index == base::StringPiece::npos)
     return false;
 
   std::string temp(line.data() + index + prefix.length(),
                    line.length() - index - prefix.length());
 
   if (temp.empty() || !IsWhitespace(temp[0]))
     return false;
 
   base::TrimWhitespaceASCII(temp, base::TRIM_ALL, value);
   return true;
 }
 
 }  // namespace
 
 // static
-bool UserScriptMaster::ParseMetadataHeader(
-      const base::StringPiece& script_text, UserScript* script) {
+bool UserScriptLoader::ParseMetadataHeader(const base::StringPiece& script_text,
+                                           UserScript* script) {
   // http://wiki.greasespot.net/Metadata_block
   base::StringPiece line;
   size_t line_start = 0;
   size_t line_end = line_start;
   bool in_metadata = false;
 
   static const base::StringPiece kUserScriptBegin("// ==UserScript==");
   static const base::StringPiece kUserScriptEng("// ==/UserScript==");
   static const base::StringPiece kNamespaceDeclaration("// @namespace");
   static const base::StringPiece kNameDeclaration("// @name");
@@ skipping 73 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 UserScriptMaster::LoadScriptsForTest(UserScriptList* user_scripts) {
+void UserScriptLoader::LoadScriptsForTest(std::set<UserScript>* user_scripts) {
   ExtensionsInfo info;
-  std::set<std::string> new_extensions;
-  for (UserScriptList::const_iterator iter = user_scripts->begin();
-       iter != user_scripts->end();
-       ++iter) {
-    new_extensions.insert(iter->extension_id());
-  }
+  std::set<UserScript> added_scripts;
+  added_scripts.insert(user_scripts->begin(), user_scripts->end());
   LoadUserScripts(
-      user_scripts, info, new_extensions, NULL /* no verifier for testing */);
+      user_scripts, info, added_scripts, NULL /* no verifier for testing */);
 }
 
-UserScriptMaster::UserScriptMaster(Profile* profile)
-    : user_scripts_(new UserScriptList()),
-      extensions_service_ready_(false),
+UserScriptLoader::UserScriptLoader(Profile* profile,
+                                   ExtensionId owner_extension_id,
+                                   bool listen_for_extension_system_loaded)
+    : user_scripts_(new std::set<UserScript>()),
+      extension_system_ready_(false),
       pending_load_(false),
       profile_(profile),
-      extension_registry_observer_(this),
+      owner_extension_id_(owner_extension_id),
       weak_factory_(this) {
-  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
+  if (listen_for_extension_system_loaded) {
+    extension_system_ready_ = false;

[Devlin, 2014/08/04 18:33:25]

This was already set in the constructor.

[Mark Dittmer, 2014/08/05 20:33:19]

True. I was thinking that the code looks more explicit and consistent when it's
set in both the if and the else. Should I remove it from the initializer list,
or ignore my instincts and remove this line?

[Devlin, 2014/08/05 21:47:26]

Remove this line.  It's pretty common practice to set something to a default and
the modify as needed, and we shouldn't set it needlessly.  (And, of course,
uninitialized variables are a) scary and b) against style)  Sorry, instincts. ;)

[Mark Dittmer, 2014/08/06 15:32:24]

Done.

+    ExtensionSystem::Get(profile_)->ready().Post(
+        FROM_HERE,
+        base::Bind(&UserScriptLoader::OnExtensionSystemReady,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    extension_system_ready_ = true;
+  }
   registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
-                 content::Source<Profile>(profile_));
-  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
+                 content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
-UserScriptMaster::~UserScriptMaster() {
+UserScriptLoader::~UserScriptLoader() {
 }
 
-void UserScriptMaster::OnScriptsLoaded(
-    scoped_ptr<UserScriptList> user_scripts,
+void UserScriptLoader::AddScripts(const std::set<UserScript>& scripts) {
+  for (std::set<UserScript>::const_iterator it = scripts.begin();
+       it != scripts.end();
+       ++it) {
+    if (removed_scripts_.count(*it) > 0)

[Devlin, 2014/08/04 18:33:25]

We don't need these ifs - we won't remove a nonexistent element, and can't add
two of the same element.

[Mark Dittmer, 2014/08/05 20:33:19]

Done.

+      removed_scripts_.erase(*it);
+    if (added_scripts_.count(*it) == 0)
+      added_scripts_.insert(*it);
+  }
+  AttemptLoad();
+}
+
+void UserScriptLoader::RemoveScripts(const std::set<UserScript>& scripts) {
+  for (std::set<UserScript>::const_iterator it = scripts.begin();
+       it != scripts.end();
+       ++it) {
+    if (added_scripts_.count(*it) > 0)

[Devlin, 2014/08/04 18:33:25]

ditto

[Mark Dittmer, 2014/08/05 20:33:19]

Done.

+      added_scripts_.erase(*it);
+    if (removed_scripts_.count(*it) == 0)
+      removed_scripts_.insert(*it);
+  }
+  AttemptLoad();
+}
+
+void UserScriptLoader::ClearScripts() {
+  clear_scripts_ = true;
+  added_scripts_.clear();
+  removed_scripts_.clear();
+  AttemptLoad();
+}
+
+void UserScriptLoader::OnExtensionSystemReady() {
+  extension_system_ready_ = true;
+  AttemptLoad();
+}
+
+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 (ScriptsReady()) {
+    SendUpdate(process,
+               GetSharedMemory(),
+               std::set<ExtensionId>());  // Include all extensions.
+  }
+  AttemptLoad();
+}
+
+void UserScriptLoader::AttemptLoad() {

[Devlin, 2014/08/04 18:33:25]

Shouldn't we also check extension_system_ready_?

[Mark Dittmer, 2014/08/05 20:33:19]

Yes! Good catch.

+  if (is_loading())
+    pending_load_ = true;
+  else
+    StartLoad();
+}
+
+void UserScriptLoader::StartLoad() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(!is_loading());
+
+  // If scripts were marked for clearing before adding+removal, then clear them.

[Devlin, 2014/08/04 18:33:25]

adding and removing

[Mark Dittmer, 2014/08/05 20:33:19]

Done.

+  if (clear_scripts_)
+    user_scripts_->clear();
+
+  // Remove scripts marked for removal.
+  for (std::set<UserScript>::iterator it = removed_scripts_.begin();

[Devlin, 2014/08/04 18:33:25]

Is there ever a case in which we need to remove scripts if |clear_scripts_| is
true?

[Mark Dittmer, 2014/08/05 20:33:19]

No. Good point.

+       it != removed_scripts_.end();
+       ++it) {
+    if (user_scripts_->count(*it) != 0)

[Devlin, 2014/08/04 18:33:25]

again, no reason for the if

[Mark Dittmer, 2014/08/05 20:33:19]

Done.

+      user_scripts_->erase(it);
+  }
+
+  // Add scripts marked for addition.
+  user_scripts_->insert(added_scripts_.begin(), added_scripts_.end());
+
+  // Recompute |changed_extensions_| for OnScriptsLoaded, which will use it in
+  // its IPC message. this must be done before we clear |added_scripts_| and
+  // |removed_scripts_| below.
+  ComputeChangedExtensions();
+
+  // Update |extensions_info_| to contain info from every extension in
+  // |changed_extensions_| before passing it to LoadScriptsOnFileThread.
+  UpdateExtensionsInfo();
+
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&LoadScriptsOnFileThread,
+                 base::Passed(&user_scripts_),
+                 extensions_info_,
+                 added_scripts_,
+                 make_scoped_refptr(
+                     ExtensionSystem::Get(profile_)->content_verifier()),
+                 base::Bind(&UserScriptLoader::OnScriptsLoaded,
+                            weak_factory_.GetWeakPtr())));
+
+  clear_scripts_ = false;
+  added_scripts_.clear();
+  removed_scripts_.clear();
+  user_scripts_.reset(NULL);
+}
+
+void UserScriptLoader::OnScriptsLoaded(
+    scoped_ptr<std::set<UserScript> > 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;
   }
 
   if (shared_memory.get() == NULL) {
     // This can happen if we run out of file descriptors.  In that case, we
     // have a choice between silently omitting all user scripts for new tabs,
     // by nulling out shared_memory_, or only silently omitting new ones by
     // leaving the existing object in place. The second seems less bad, even
     // though it removes the possibility that freeing the shared memory block
     // would open up enough FDs for long enough for a retry to succeed.
 
     // Pretend the extension change didn't happen.
     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_);
+           content::RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd();
+       i.Advance()) {
+    SendUpdate(i.GetCurrentValue(), shared_memory_.get(), changed_extensions_);
   }
-  changed_extensions_.clear();
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
       content::Source<Profile>(profile_),
       content::Details<base::SharedMemory>(shared_memory_.get()));
 }
 
-void UserScriptMaster::OnExtensionLoaded(
-    content::BrowserContext* browser_context,
-    const Extension* extension) {
-  added_extensions_.insert(extension->id());
-  removed_extensions_.erase(extension->id());
-  extensions_info_[extension->id()] =
-      ExtensionSet::ExtensionPathAndDefaultLocale(
-          extension->path(), LocaleInfo::GetDefaultLocale(extension));
-  if (extensions_service_ready_) {
-    changed_extensions_.insert(extension->id());
-    if (is_loading())
-      pending_load_ = true;
-    else
-      StartLoad();
-  }
-}
-
-void UserScriptMaster::OnExtensionUnloaded(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    UnloadedExtensionInfo::Reason reason) {
-  removed_extensions_.insert(extension->id());
-  added_extensions_.erase(extension->id());
-  // Remove any content scripts.
-  extensions_info_.erase(extension->id());
-  changed_extensions_.insert(extension->id());
-  if (is_loading())
-    pending_load_ = true;
-  else
-    StartLoad();
-}
-
-void UserScriptMaster::Observe(int type,
-                               const content::NotificationSource& source,
-                               const content::NotificationDetails& details) {
-  bool should_start_load = false;
-  switch (type) {
-    case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED:
-      extensions_service_ready_ = true;
-      should_start_load = true;
-      break;
-    case 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 (ScriptsReady()) {
-        SendUpdate(process,
-                   GetSharedMemory(),
-                   std::set<std::string>());  // Include all extensions.
-      }
-      break;
-    }
-    default:
-      DCHECK(false);
-  }
-
-  if (should_start_load) {
-    if (is_loading())
-      pending_load_ = true;
-    else
-      StartLoad();
-  }
-}
-
-void UserScriptMaster::StartLoad() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(!is_loading());
-
-  // Remove any user scripts belonging to any extension that was updated or
-  // removed.
-  for (UserScriptList::iterator iter = user_scripts_->begin();
-       iter != user_scripts_->end();) {
-    if (removed_extensions_.count(iter->extension_id()) > 0 ||
-        added_extensions_.count(iter->extension_id()) > 0) {
-      iter = user_scripts_->erase(iter);
-    } else {
-      ++iter;
-    }
-  }
-
-  // Add any content scripts for extensions that were recently loaded.
-  const ExtensionSet& enabled_extensions =
-      ExtensionRegistry::Get(profile_)->enabled_extensions();
-  for (std::set<std::string>::const_iterator iter = added_extensions_.begin();
-       iter != added_extensions_.end(); ++iter) {
-    const Extension* extension = enabled_extensions.GetByID(*iter);
-    if (!extension)
-      continue;
-    bool incognito_enabled =
-        util::IsIncognitoEnabled(extension->id(), profile_);
-    const UserScriptList& scripts =
-        ContentScriptsInfo::GetContentScripts(extension);
-    for (UserScriptList::const_iterator script = scripts.begin();
-         script != scripts.end();
-         ++script) {
-      user_scripts_->push_back(*script);
-      user_scripts_->back().set_incognito_enabled(incognito_enabled);
-    }
-  }
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&LoadScriptsOnFileThread,
-                 base::Passed(&user_scripts_),
-                 extensions_info_,
-                 added_extensions_,
-                 make_scoped_refptr(
-                     ExtensionSystem::Get(profile_)->content_verifier()),
-                 base::Bind(&UserScriptMaster::OnScriptsLoaded,
-                            weak_factory_.GetWeakPtr())));
-  added_extensions_.clear();
-  removed_extensions_.clear();
-  user_scripts_.reset(NULL);
-}
-
-void UserScriptMaster::SendUpdate(
+void UserScriptLoader::SendUpdate(
     content::RenderProcessHost* process,
     base::SharedMemory* shared_memory,
-    const std::set<std::string>& changed_extensions) {
+    const std::set<ExtensionId>& changed_extensions) {
   // 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)) {
     process->Send(new ExtensionMsg_UpdateUserScripts(
         handle_for_process, "" /* owner */, changed_extensions));
   }
 }
 
+void UserScriptLoader::ComputeChangedExtensions() {
+  changed_extensions_.clear();
+  for (std::set<UserScript>::const_iterator it = removed_scripts_.begin();
+       it != removed_scripts_.end();
+       ++it) {
+    if (changed_extensions_.count(it->extension_id()) == 0)

[Devlin, 2014/08/04 18:33:25]

no ifs

[Mark Dittmer, 2014/08/05 20:33:19]

Done.

+      changed_extensions_.insert(it->extension_id());
+  }
+  for (std::set<UserScript>::const_iterator it = added_scripts_.begin();
+       it != added_scripts_.end();
+       ++it) {
+    if (changed_extensions_.count(it->extension_id()) == 0)
+      changed_extensions_.insert(it->extension_id());
+  }
+}
+
+void UserScriptLoader::UpdateExtensionsInfo() {
+  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 =
+          ExtensionRegistry::Get(profile_)
+              ->GetExtensionById(*it, ExtensionRegistry::EVERYTHING);
+      extensions_info_[*it] = ExtensionSet::ExtensionPathAndDefaultLocale(
+          extension->path(), LocaleInfo::GetDefaultLocale(extension));
+    }
+  }
+}
+
 }  // namespace extensions