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)) {
+        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]);
       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,
+                                   const ExtensionId& owner_extension_id,
+                                   bool listen_for_extension_system_loaded)
+    : user_scripts_(new std::set<UserScript>()),
       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;
+    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,
-    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;
+void UserScriptLoader::AddScripts(const std::set<UserScript>& scripts) {
+  for (std::set<UserScript>::const_iterator it = scripts.begin();
+       it != scripts.end();
+       ++it) {
+    removed_scripts_.erase(*it);
+    added_scripts_.insert(*it);
   }
-
-  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_);
-  }
-  changed_extensions_.clear();
-
-  content::NotificationService::current()->Notify(
-      extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
-      content::Source<Profile>(profile_),
-      content::Details<base::SharedMemory>(shared_memory_.get()));
+  AttemptLoad();
 }
 
-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());
+void UserScriptLoader::RemoveScripts(const std::set<UserScript>& scripts) {
+  for (std::set<UserScript>::const_iterator it = scripts.begin();
+       it != scripts.end();
+       ++it) {
+    added_scripts_.erase(*it);
+    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 (scripts_ready()) {
+    SendUpdate(process,
+               GetSharedMemory(),
+               std::set<ExtensionId>());  // Include all extensions.
+  }
+  AttemptLoad();
+}
+
+void UserScriptLoader::AttemptLoad() {
+  if (extension_system_ready_) {
     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() {
+void UserScriptLoader::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;
+  // If scripts were marked for clearing before adding and removing, then clear
+  // them.
+  if (clear_scripts_) {
+    user_scripts_->clear();
+  } else {
+    // Remove scripts marked for removal.

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

Let's lose this and the "Add scripts marked for addition" comment.  Should be
self-explanatory (and clear code is always better than clear comments, because
it's guaranteed to be current).

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

Done.

+    for (std::set<UserScript>::iterator it = removed_scripts_.begin();
+         it != removed_scripts_.end();
+         ++it) {
+      user_scripts_->erase(it);
     }
   }
 
-  // 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);
-    }
-  }
+  // 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_extensions_,
+                 added_scripts_,
                  make_scoped_refptr(
                      ExtensionSystem::Get(profile_)->content_verifier()),
-                 base::Bind(&UserScriptMaster::OnScriptsLoaded,
+                 base::Bind(&UserScriptLoader::OnScriptsLoaded,
                             weak_factory_.GetWeakPtr())));
-  added_extensions_.clear();
-  removed_extensions_.clear();
+
+  clear_scripts_ = false;
+  added_scripts_.clear();
+  removed_scripts_.clear();
   user_scripts_.reset(NULL);
 }
 
-void UserScriptMaster::SendUpdate(
+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::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<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() {

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

It looks like this does away with the empty-set-means-all-extensions case.  Do
we need to update the IPC/renderer for this?

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

I don't think so. This does the same thing we did before. The case where we
deliberately sent an empty set still exists up in Observe().

+  changed_extensions_.clear();
+  for (std::set<UserScript>::const_iterator it = removed_scripts_.begin();
+       it != removed_scripts_.end();
+       ++it) {
+    changed_extensions_.insert(it->extension_id());
+  }
+  for (std::set<UserScript>::const_iterator it = added_scripts_.begin();
+       it != added_scripts_.end();
+       ++it) {
+    changed_extensions_.insert(it->extension_id());
+  }
+}
+
+void UserScriptLoader::UpdateExtensionsInfo() {

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

Do we need to worry about removing outdated extension infos?

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

Excellent point. I've implemented this with a public
ClearExtensionInfo(ExtensionId) that is invoked by the OnExtensionUnload of both
UserScriptMaster variants. Do you think this is a good solution, or should this
bookkeeping be the responsibility of the loader (in which case it should become
an ExtensionRegistryObserver).

[Devlin, 2014/08/06 15:59:25]

It should probably be the job of UserScriptLoader.  As mentioned before, making
something an observer is pretty cheap when just using the basic pattern, and
it's simpler/less fragile than saying "And be sure that this gets called when an
extension is unloaded".

[Mark Dittmer, 2014/08/06 22:08:18]

Right. Done.

+  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