Create thread-safe RendererExtensionRegistry from ExtensionSet

extensions/renderer/user_script_set_manager.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 "extensions/renderer/user_script_set_manager.h"
 
 #include "components/crx_file/id_util.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/user_script_set.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace extensions {
 
-UserScriptSetManager::UserScriptSetManager(const ExtensionSet* extensions)
-    : static_scripts_(extensions),
-      extensions_(extensions) {
+UserScriptSetManager::UserScriptSetManager() {
   content::RenderThread::Get()->AddObserver(this);
 }
 
 UserScriptSetManager::~UserScriptSetManager() {
 }
 
 void UserScriptSetManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
@@ skipping 79 matching lines @@
     }
   }
 
   UserScriptSet* scripts = NULL;
   if (!host_id.id().empty()) {
     // The expectation when there is a host that "owns" this shared
     // memory region is that the |changed_hosts| is either the empty list
     // or just the owner.
     CHECK(changed_hosts.size() <= 1);
     if (programmatic_scripts_.find(host_id) == programmatic_scripts_.end()) {
-      scripts = new UserScriptSet(extensions_);
+      scripts = new UserScriptSet();
       programmatic_scripts_[host_id] = make_linked_ptr(scripts);
     } else {
       scripts = programmatic_scripts_[host_id].get();
     }
   } else {
     scripts = &static_scripts_;
   }
   DCHECK(scripts);
 
   // If no hosts are included in the set, that indicates that all
   // hosts were updated. Add them all to the set so that observers and
   // individual UserScriptSets don't need to know this detail.
   const std::set<HostID>* effective_hosts = &changed_hosts;
   std::set<HostID> all_hosts;
   if (changed_hosts.empty()) {
     // The meaning of "all hosts(extensions)" varies, depending on whether some
     // host "owns" this shared memory region.
     // No owner => all known hosts.
     // Owner    => just the owner host.
     if (host_id.id().empty()) {
-      std::set<std::string> extension_ids = extensions_->GetIDs();
+      std::set<std::string> extension_ids =
+          RendererExtensionRegistry::Get()->GetIDs();
       for (const std::string& extension_id : extension_ids)
         all_hosts.insert(HostID(HostID::EXTENSIONS, extension_id));
     } else {
       all_hosts.insert(host_id);
     }
     effective_hosts = &all_hosts;
   }
 
   if (scripts->UpdateUserScripts(shared_memory,
                                  *effective_hosts,
                                  whitelisted_only)) {
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnUserScriptsUpdated(*effective_hosts, scripts->scripts()));
   }
 }
 
 }  // namespace extensions