Home | History | Annotate | Download | only in shared_worker 
      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 "content/browser/shared_worker/shared_worker_message_filter.h"
      6 
      7 #include "content/browser/message_port_message_filter.h"
      8 #include "content/browser/shared_worker/shared_worker_service_impl.h"
      9 #include "content/common/devtools_messages.h"
     10 #include "content/common/view_messages.h"
     11 #include "content/common/worker_messages.h"
     12 
     13 namespace content {
     14 namespace {
     15 const uint32 kFilteredMessageClasses[] = {
     16   ViewMsgStart,
     17   WorkerMsgStart,
     18 };
     19 }  // namespace
     20 
     21 SharedWorkerMessageFilter::SharedWorkerMessageFilter(
     22     int render_process_id,
     23     ResourceContext* resource_context,
     24     const WorkerStoragePartition& partition,
     25     MessagePortMessageFilter* message_port_message_filter)
     26     : BrowserMessageFilter(kFilteredMessageClasses,
     27                            arraysize(kFilteredMessageClasses)),
     28       render_process_id_(render_process_id),
     29       resource_context_(resource_context),
     30       partition_(partition),
     31       message_port_message_filter_(message_port_message_filter) {
     32 }
     33 
     34 SharedWorkerMessageFilter::~SharedWorkerMessageFilter() {
     35   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     36 }
     37 
     38 void SharedWorkerMessageFilter::OnChannelClosing() {
     39   SharedWorkerServiceImpl::GetInstance()->OnSharedWorkerMessageFilterClosing(
     40       this);
     41 }
     42 
     43 bool SharedWorkerMessageFilter::OnMessageReceived(const IPC::Message& message) {
     44   bool handled = true;
     45   IPC_BEGIN_MESSAGE_MAP(SharedWorkerMessageFilter, message)
     46     // Only sent from renderer for now, until we have nested workers.
     47     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWorker, OnCreateWorker)
     48     IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToWorker, OnForwardToWorker)
     49     // Only sent from renderer.
     50     IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentDetached, OnDocumentDetached)
     51     // Only sent from SharedWorker in renderer.
     52     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextClosed,
     53                         OnWorkerContextClosed)
     54     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextDestroyed,
     55                         OnWorkerContextDestroyed)
     56     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerReadyForInspection,
     57                         OnWorkerReadyForInspection)
     58     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerScriptLoaded,
     59                         OnWorkerScriptLoaded)
     60     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerScriptLoadFailed,
     61                         OnWorkerScriptLoadFailed)
     62     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerConnected,
     63                         OnWorkerConnected)
     64     IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowDatabase, OnAllowDatabase)
     65     IPC_MESSAGE_HANDLER_DELAY_REPLY(
     66         WorkerProcessHostMsg_RequestFileSystemAccessSync,
     67         OnRequestFileSystemAccess)
     68     IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowIndexedDB, OnAllowIndexedDB)
     69     IPC_MESSAGE_UNHANDLED(handled = false)
     70   IPC_END_MESSAGE_MAP()
     71   return handled;
     72 }
     73 
     74 int SharedWorkerMessageFilter::GetNextRoutingID() {
     75   return message_port_message_filter_->GetNextRoutingID();
     76 }
     77 
     78 void SharedWorkerMessageFilter::OnCreateWorker(
     79     const ViewHostMsg_CreateWorker_Params& params,
     80     int* route_id) {
     81   bool url_error = false;
     82   *route_id = GetNextRoutingID();
     83   SharedWorkerServiceImpl::GetInstance()->CreateWorker(
     84       params,
     85       *route_id,
     86       this,
     87       resource_context_,
     88       WorkerStoragePartitionId(partition_),
     89       &url_error);
     90   if (url_error)
     91     *route_id = MSG_ROUTING_NONE;
     92 }
     93 
     94 void SharedWorkerMessageFilter::OnForwardToWorker(const IPC::Message& message) {
     95   SharedWorkerServiceImpl::GetInstance()->ForwardToWorker(message, this);
     96 }
     97 
     98 void SharedWorkerMessageFilter::OnDocumentDetached(
     99     unsigned long long document_id) {
    100   SharedWorkerServiceImpl::GetInstance()->DocumentDetached(document_id, this);
    101 }
    102 
    103 void SharedWorkerMessageFilter::OnWorkerContextClosed(int worker_route_id) {
    104   SharedWorkerServiceImpl::GetInstance()->WorkerContextClosed(worker_route_id,
    105                                                               this);
    106 }
    107 
    108 void SharedWorkerMessageFilter::OnWorkerContextDestroyed(int worker_route_id) {
    109   SharedWorkerServiceImpl::GetInstance()->WorkerContextDestroyed(
    110       worker_route_id,
    111       this);
    112 }
    113 
    114 void SharedWorkerMessageFilter::OnWorkerReadyForInspection(
    115     int worker_route_id) {
    116   SharedWorkerServiceImpl::GetInstance()->WorkerReadyForInspection(
    117       worker_route_id, this);
    118 }
    119 
    120 void SharedWorkerMessageFilter::OnWorkerScriptLoaded(int worker_route_id) {
    121   SharedWorkerServiceImpl::GetInstance()->WorkerScriptLoaded(worker_route_id,
    122                                                              this);
    123 }
    124 
    125 void SharedWorkerMessageFilter::OnWorkerScriptLoadFailed(int worker_route_id) {
    126   SharedWorkerServiceImpl::GetInstance()->WorkerScriptLoadFailed(
    127       worker_route_id,
    128       this);
    129 }
    130 
    131 void SharedWorkerMessageFilter::OnWorkerConnected(int message_port_id,
    132                                                   int worker_route_id) {
    133   SharedWorkerServiceImpl::GetInstance()->WorkerConnected(
    134       message_port_id,
    135       worker_route_id,
    136       this);
    137 }
    138 
    139 void SharedWorkerMessageFilter::OnAllowDatabase(
    140     int worker_route_id,
    141     const GURL& url,
    142     const base::string16& name,
    143     const base::string16& display_name,
    144     unsigned long estimated_size,
    145     bool* result) {
    146   SharedWorkerServiceImpl::GetInstance()->AllowDatabase(worker_route_id,
    147                                                         url,
    148                                                         name,
    149                                                         display_name,
    150                                                         estimated_size,
    151                                                         result,
    152                                                         this);
    153 }
    154 
    155 void SharedWorkerMessageFilter::OnRequestFileSystemAccess(
    156     int worker_route_id,
    157     const GURL& url,
    158     IPC::Message* reply_msg) {
    159   SharedWorkerServiceImpl::GetInstance()->AllowFileSystem(
    160       worker_route_id, url, reply_msg, this);
    161 }
    162 
    163 void SharedWorkerMessageFilter::OnAllowIndexedDB(int worker_route_id,
    164                                                  const GURL& url,
    165                                                  const base::string16& name,
    166                                                  bool* result) {
    167   SharedWorkerServiceImpl::GetInstance()->AllowIndexedDB(worker_route_id,
    168                                                          url,
    169                                                          name,
    170                                                          result,
    171                                                          this);
    172 }
    173 
    174 }  // namespace content
    175