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