extensions/browser/extension_message_filter.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/browser/extension_message_filter.h"
   6
   7 #include "components/crx_file/id_util.h"
   8 #include "content/public/browser/browser_thread.h"
   9 #include "content/public/browser/render_frame_host.h"
  10 #include "content/public/browser/render_process_host.h"
  11 #include "content/public/browser/render_view_host.h"
  12 #include "content/public/browser/resource_dispatcher_host.h"
  13 #include "extensions/browser/blob_holder.h"
  14 #include "extensions/browser/event_router.h"
  15 #include "extensions/browser/extension_function_dispatcher.h"
  16 #include "extensions/browser/extension_system.h"
  17 #include "extensions/browser/info_map.h"
  18 #include "extensions/browser/process_manager.h"
  19 #include "extensions/common/extension.h"
  20 #include "extensions/common/extension_messages.h"
  21 #include "ipc/ipc_message_macros.h"
  22
  23 using content::BrowserThread;
  24 using content::RenderProcessHost;
  25
  26 namespace extensions {
  27
  28 ExtensionMessageFilter::ExtensionMessageFilter(int render_process_id,
  29                                                content::BrowserContext* context)
  30     : BrowserMessageFilter(ExtensionMsgStart),
  31       render_process_id_(render_process_id),
  32       browser_context_(context),
  33       extension_info_map_(ExtensionSystem::Get(context)->info_map()),
  34       weak_ptr_factory_(this) {
  35   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  36 }
  37
  38 ExtensionMessageFilter::~ExtensionMessageFilter() {
  39   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  40 }
  41
  42 void ExtensionMessageFilter::OverrideThreadForMessage(
  43     const IPC::Message& message,
  44     BrowserThread::ID* thread) {
  45   switch (message.type()) {
  46     case ExtensionHostMsg_AddListener::ID:
  47     case ExtensionHostMsg_RemoveListener::ID:
  48     case ExtensionHostMsg_AddLazyListener::ID:
  49     case ExtensionHostMsg_RemoveLazyListener::ID:
  50     case ExtensionHostMsg_AddFilteredListener::ID:
  51     case ExtensionHostMsg_RemoveFilteredListener::ID:
  52     case ExtensionHostMsg_ShouldSuspendAck::ID:
  53     case ExtensionHostMsg_SuspendAck::ID:
  54     case ExtensionHostMsg_TransferBlobsAck::ID:
  55       *thread = BrowserThread::UI;
  56       break;
  57     default:
  58       break;
  59   }
  60 }
  61
  62 void ExtensionMessageFilter::OnDestruct() const {
  63   // Destroy the filter on the IO thread since that's where its weak pointers
  64   // are being used.
  65   BrowserThread::DeleteOnIOThread::Destruct(this);
  66 }
  67
  68 bool ExtensionMessageFilter::OnMessageReceived(const IPC::Message& message) {
  69   bool handled = true;
  70   IPC_BEGIN_MESSAGE_MAP(ExtensionMessageFilter, message)
  71     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddListener,
  72                         OnExtensionAddListener)
  73     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveListener,
  74                         OnExtensionRemoveListener)
  75     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddLazyListener,
  76                         OnExtensionAddLazyListener)
  77     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveLazyListener,
  78                         OnExtensionRemoveLazyListener)
  79     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddFilteredListener,
  80                         OnExtensionAddFilteredListener)
  81     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveFilteredListener,
  82                         OnExtensionRemoveFilteredListener)
  83     IPC_MESSAGE_HANDLER(ExtensionHostMsg_ShouldSuspendAck,
  84                         OnExtensionShouldSuspendAck)
  85     IPC_MESSAGE_HANDLER(ExtensionHostMsg_SuspendAck,
  86                         OnExtensionSuspendAck)
  87     IPC_MESSAGE_HANDLER(ExtensionHostMsg_TransferBlobsAck,
  88                         OnExtensionTransferBlobsAck)
  89     IPC_MESSAGE_HANDLER(ExtensionHostMsg_GenerateUniqueID,
  90                         OnExtensionGenerateUniqueID)
  91     IPC_MESSAGE_HANDLER(ExtensionHostMsg_ResumeRequests,
  92                         OnExtensionResumeRequests);
  93     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RequestForIOThread,
  94                         OnExtensionRequestForIOThread)
  95     IPC_MESSAGE_UNHANDLED(handled = false)
  96   IPC_END_MESSAGE_MAP()
  97   return handled;
  98 }
  99
 100 void ExtensionMessageFilter::OnExtensionAddListener(
 101     const std::string& extension_id,
 102     const GURL& listener_url,
 103     const std::string& event_name) {
 104   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
 105   if (!process)
 106     return;
 107   EventRouter* router = EventRouter::Get(browser_context_);
 108   if (!router)
 109     return;
 110
 111   if (crx_file::id_util::IdIsValid(extension_id)) {
 112     router->AddEventListener(event_name, process, extension_id);
 113   } else if (listener_url.is_valid()) {
 114     router->AddEventListenerForURL(event_name, process, listener_url);
 115   } else {
 116     NOTREACHED() << "Tried to add an event listener without a valid "
 117                  << "extension ID nor listener URL";
 118   }
 119 }
 120
 121 void ExtensionMessageFilter::OnExtensionRemoveListener(
 122     const std::string& extension_id,
 123     const GURL& listener_url,
 124     const std::string& event_name) {
 125   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
 126   if (!process)
 127     return;
 128   EventRouter* router = EventRouter::Get(browser_context_);
 129   if (!router)
 130     return;
 131
 132   if (crx_file::id_util::IdIsValid(extension_id)) {
 133     router->RemoveEventListener(event_name, process, extension_id);
 134   } else if (listener_url.is_valid()) {
 135     router->RemoveEventListenerForURL(event_name, process, listener_url);
 136   } else {
 137     NOTREACHED() << "Tried to remove an event listener without a valid "
 138                  << "extension ID nor listener URL";
 139   }
 140 }
 141
 142 void ExtensionMessageFilter::OnExtensionAddLazyListener(
 143     const std::string& extension_id, const std::string& event_name) {
 144   EventRouter* router = EventRouter::Get(browser_context_);
 145   if (!router)
 146     return;
 147   router->AddLazyEventListener(event_name, extension_id);
 148 }
 149
 150 void ExtensionMessageFilter::OnExtensionRemoveLazyListener(
 151     const std::string& extension_id, const std::string& event_name) {
 152   EventRouter* router = EventRouter::Get(browser_context_);
 153   if (!router)
 154     return;
 155   router->RemoveLazyEventListener(event_name, extension_id);
 156 }
 157
 158 void ExtensionMessageFilter::OnExtensionAddFilteredListener(
 159     const std::string& extension_id,
 160     const std::string& event_name,
 161     const base::DictionaryValue& filter,
 162     bool lazy) {
 163   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
 164   if (!process)
 165     return;
 166   EventRouter* router = EventRouter::Get(browser_context_);
 167   if (!router)
 168     return;
 169   router->AddFilteredEventListener(
 170       event_name, process, extension_id, filter, lazy);
 171 }
 172
 173 void ExtensionMessageFilter::OnExtensionRemoveFilteredListener(
 174     const std::string& extension_id,
 175     const std::string& event_name,
 176     const base::DictionaryValue& filter,
 177     bool lazy) {
 178   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
 179   if (!process)
 180     return;
 181   EventRouter* router = EventRouter::Get(browser_context_);
 182   if (!router)
 183     return;
 184   router->RemoveFilteredEventListener(
 185       event_name, process, extension_id, filter, lazy);
 186 }
 187
 188 void ExtensionMessageFilter::OnExtensionShouldSuspendAck(
 189      const std::string& extension_id, int sequence_id) {
 190   ProcessManager::Get(browser_context_)
 191       ->OnShouldSuspendAck(extension_id, sequence_id);
 192 }
 193
 194 void ExtensionMessageFilter::OnExtensionSuspendAck(
 195      const std::string& extension_id) {
 196   ProcessManager::Get(browser_context_)->OnSuspendAck(extension_id);
 197 }
 198
 199 void ExtensionMessageFilter::OnExtensionTransferBlobsAck(
 200     const std::vector<std::string>& blob_uuids) {
 201   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
 202   if (!process)
 203     return;
 204   BlobHolder::FromRenderProcessHost(process)->DropBlobs(blob_uuids);
 205 }
 206
 207 void ExtensionMessageFilter::OnExtensionGenerateUniqueID(int* unique_id) {
 208   static int next_unique_id = 0;
 209   *unique_id = ++next_unique_id;
 210 }
 211
 212 void ExtensionMessageFilter::OnExtensionResumeRequests(int route_id) {
 213   content::ResourceDispatcherHost::Get()->ResumeBlockedRequestsForRoute(
 214       render_process_id_, route_id);
 215 }
 216
 217 void ExtensionMessageFilter::OnExtensionRequestForIOThread(
 218     int routing_id,
 219     const ExtensionHostMsg_Request_Params& params) {
 220   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 221   ExtensionFunctionDispatcher::DispatchOnIOThread(
 222       extension_info_map_.get(),
 223       browser_context_,
 224       render_process_id_,
 225       weak_ptr_factory_.GetWeakPtr(),
 226       routing_id,
 227       params);
 228 }
 229
 230 }  // namespace extensions