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
13namespace content {
14namespace {
15const uint32 kFilteredMessageClasses[] = {
16  ViewMsgStart,
17  WorkerMsgStart,
18};
19}  // namespace
20
21SharedWorkerMessageFilter::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
34SharedWorkerMessageFilter::~SharedWorkerMessageFilter() {
35  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
36}
37
38void SharedWorkerMessageFilter::OnChannelClosing() {
39  SharedWorkerServiceImpl::GetInstance()->OnSharedWorkerMessageFilterClosing(
40      this);
41}
42
43bool 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
74int SharedWorkerMessageFilter::GetNextRoutingID() {
75  return message_port_message_filter_->GetNextRoutingID();
76}
77
78void 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
94void SharedWorkerMessageFilter::OnForwardToWorker(const IPC::Message& message) {
95  SharedWorkerServiceImpl::GetInstance()->ForwardToWorker(message, this);
96}
97
98void SharedWorkerMessageFilter::OnDocumentDetached(
99    unsigned long long document_id) {
100  SharedWorkerServiceImpl::GetInstance()->DocumentDetached(document_id, this);
101}
102
103void SharedWorkerMessageFilter::OnWorkerContextClosed(int worker_route_id) {
104  SharedWorkerServiceImpl::GetInstance()->WorkerContextClosed(worker_route_id,
105                                                              this);
106}
107
108void SharedWorkerMessageFilter::OnWorkerContextDestroyed(int worker_route_id) {
109  SharedWorkerServiceImpl::GetInstance()->WorkerContextDestroyed(
110      worker_route_id,
111      this);
112}
113
114void SharedWorkerMessageFilter::OnWorkerReadyForInspection(
115    int worker_route_id) {
116  SharedWorkerServiceImpl::GetInstance()->WorkerReadyForInspection(
117      worker_route_id, this);
118}
119
120void SharedWorkerMessageFilter::OnWorkerScriptLoaded(int worker_route_id) {
121  SharedWorkerServiceImpl::GetInstance()->WorkerScriptLoaded(worker_route_id,
122                                                             this);
123}
124
125void SharedWorkerMessageFilter::OnWorkerScriptLoadFailed(int worker_route_id) {
126  SharedWorkerServiceImpl::GetInstance()->WorkerScriptLoadFailed(
127      worker_route_id,
128      this);
129}
130
131void 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
139void 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
155void 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
163void 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