extensions/renderer/user_script_set_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/renderer/user_script_set_manager.h"
   6
   7 #include "components/crx_file/id_util.h"
   8 #include "content/public/renderer/render_thread.h"
   9 #include "extensions/common/extension_messages.h"
  10 #include "extensions/renderer/dispatcher.h"
  11 #include "extensions/renderer/script_injection.h"
  12 #include "extensions/renderer/user_script_set.h"
  13 #include "ipc/ipc_message.h"
  14 #include "ipc/ipc_message_macros.h"
  15
  16 namespace extensions {
  17
  18 UserScriptSetManager::UserScriptSetManager(const ExtensionSet* extensions)
  19     : static_scripts_(extensions),
  20       extensions_(extensions) {
  21   content::RenderThread::Get()->AddObserver(this);
  22 }
  23
  24 UserScriptSetManager::~UserScriptSetManager() {
  25 }
  26
  27 void UserScriptSetManager::AddObserver(Observer* observer) {
  28   observers_.AddObserver(observer);
  29 }
  30
  31 void UserScriptSetManager::RemoveObserver(Observer* observer) {
  32   observers_.RemoveObserver(observer);
  33 }
  34
  35 scoped_ptr<ScriptInjection>
  36 UserScriptSetManager::GetInjectionForDeclarativeScript(
  37     int script_id,
  38     content::RenderFrame* render_frame,
  39     int tab_id,
  40     const GURL& url,
  41     const std::string& extension_id) {
  42   UserScriptSet* user_script_set =
  43       GetProgrammaticScriptsByHostID(HostID(HostID::EXTENSIONS, extension_id));
  44   if (!user_script_set)
  45     return scoped_ptr<ScriptInjection>();
  46
  47   return user_script_set->GetDeclarativeScriptInjection(
  48       script_id,
  49       render_frame,
  50       tab_id,
  51       UserScript::BROWSER_DRIVEN,
  52       url);
  53 }
  54
  55 bool UserScriptSetManager::OnControlMessageReceived(
  56     const IPC::Message& message) {
  57   bool handled = true;
  58   IPC_BEGIN_MESSAGE_MAP(UserScriptSetManager, message)
  59     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateUserScripts, OnUpdateUserScripts)
  60     IPC_MESSAGE_UNHANDLED(handled = false)
  61   IPC_END_MESSAGE_MAP()
  62   return handled;
  63 }
  64
  65 void UserScriptSetManager::GetAllInjections(
  66     ScopedVector<ScriptInjection>* injections,
  67     content::RenderFrame* render_frame,
  68     int tab_id,
  69     UserScript::RunLocation run_location) {
  70   static_scripts_.GetInjections(injections, render_frame, tab_id, run_location);
  71   for (UserScriptSetMap::iterator it = programmatic_scripts_.begin();
  72        it != programmatic_scripts_.end();
  73        ++it) {
  74     it->second->GetInjections(injections, render_frame, tab_id, run_location);
  75   }
  76 }
  77
  78 void UserScriptSetManager::GetAllActiveExtensionIds(
  79     std::set<std::string>* ids) const {
  80   DCHECK(ids);
  81   static_scripts_.GetActiveExtensionIds(ids);
  82   for (UserScriptSetMap::const_iterator it = programmatic_scripts_.begin();
  83        it != programmatic_scripts_.end();
  84        ++it) {
  85     it->second->GetActiveExtensionIds(ids);
  86   }
  87 }
  88
  89 UserScriptSet* UserScriptSetManager::GetProgrammaticScriptsByHostID(
  90     const HostID& host_id) {
  91   UserScriptSetMap::const_iterator it = programmatic_scripts_.find(host_id);
  92   return it != programmatic_scripts_.end() ? it->second.get() : NULL;
  93 }
  94
  95 void UserScriptSetManager::OnUpdateUserScripts(
  96     base::SharedMemoryHandle shared_memory,
  97     const HostID& host_id,
  98     const std::set<HostID>& changed_hosts,
  99     bool whitelisted_only) {
 100   if (!base::SharedMemory::IsHandleValid(shared_memory)) {
 101     NOTREACHED() << "Bad scripts handle";
 102     return;
 103   }
 104
 105   for (const HostID& host_id : changed_hosts) {
 106     if (host_id.type() == HostID::EXTENSIONS &&
 107         !crx_file::id_util::IdIsValid(host_id.id())) {
 108       NOTREACHED() << "Invalid extension id: " << host_id.id();
 109       return;
 110     }
 111   }
 112
 113   UserScriptSet* scripts = NULL;
 114   if (!host_id.id().empty()) {
 115     // The expectation when there is a host that "owns" this shared
 116     // memory region is that the |changed_hosts| is either the empty list
 117     // or just the owner.
 118     CHECK(changed_hosts.size() <= 1);
 119     if (programmatic_scripts_.find(host_id) == programmatic_scripts_.end()) {
 120       scripts = new UserScriptSet(extensions_);
 121       programmatic_scripts_[host_id] = make_linked_ptr(scripts);
 122     } else {
 123       scripts = programmatic_scripts_[host_id].get();
 124     }
 125   } else {
 126     scripts = &static_scripts_;
 127   }
 128   DCHECK(scripts);
 129
 130   // If no hosts are included in the set, that indicates that all
 131   // hosts were updated. Add them all to the set so that observers and
 132   // individual UserScriptSets don't need to know this detail.
 133   const std::set<HostID>* effective_hosts = &changed_hosts;
 134   std::set<HostID> all_hosts;
 135   if (changed_hosts.empty()) {
 136     // The meaning of "all hosts(extensions)" varies, depending on whether some
 137     // host "owns" this shared memory region.
 138     // No owner => all known hosts.
 139     // Owner    => just the owner host.
 140     if (host_id.id().empty()) {
 141       std::set<std::string> extension_ids = extensions_->GetIDs();
 142       for (const std::string& extension_id : extension_ids)
 143         all_hosts.insert(HostID(HostID::EXTENSIONS, extension_id));
 144     } else {
 145       all_hosts.insert(host_id);
 146     }
 147     effective_hosts = &all_hosts;
 148   }
 149
 150   if (scripts->UpdateUserScripts(shared_memory,
 151                                  *effective_hosts,
 152                                  whitelisted_only)) {
 153     FOR_EACH_OBSERVER(
 154         Observer,
 155         observers_,
 156         OnUserScriptsUpdated(*effective_hosts, scripts->scripts()));
 157   }
 158 }
 159
 160 }  // namespace extensions