Add SharedWorkerMessageFilter for the embedded SharedWorker.

It will be used instead of WorkerMessageFilter when "enable-embedded-shared-worker" is set.

BUG=327256

Review URL: https://codereview.chromium.org/166273002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@251334 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/shared_worker/shared_worker_message_filter.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/shared_worker/shared_worker_message_filter.h"
+
+#include "content/browser/devtools/worker_devtools_manager.h"
+#include "content/browser/message_port_message_filter.h"
+#include "content/browser/shared_worker/shared_worker_service_impl.h"
+#include "content/common/devtools_messages.h"
+#include "content/common/view_messages.h"
+#include "content/common/worker_messages.h"
+
+namespace content {
+
+SharedWorkerMessageFilter::SharedWorkerMessageFilter(
+    int render_process_id,
+    ResourceContext* resource_context,
+    const WorkerStoragePartition& partition,
+    MessagePortMessageFilter* message_port_message_filter)
+    : render_process_id_(render_process_id),
+      resource_context_(resource_context),
+      partition_(partition),
+      message_port_message_filter_(message_port_message_filter) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+}
+
+SharedWorkerMessageFilter::~SharedWorkerMessageFilter() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+}
+
+void SharedWorkerMessageFilter::OnChannelClosing() {
+  SharedWorkerServiceImpl::GetInstance()->OnSharedWorkerMessageFilterClosing(
+      this);
+}
+
+bool SharedWorkerMessageFilter::OnMessageReceived(const IPC::Message& message,
+                                                  bool* message_was_ok) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(SharedWorkerMessageFilter, message, *message_was_ok)
+    // Only sent from renderer for now, until we have nested workers.
+    IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWorker, OnCreateWorker)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToWorker, OnForwardToWorker)
+    // Only sent from renderer.
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentDetached, OnDocumentDetached)
+    // Only sent from SharedWorker in renderer.
+    IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextClosed,
+                        OnWorkerContextClosed)
+    IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextDestroyed,
+                        OnWorkerContextDestroyed)
+    IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerScriptLoaded,
+                        OnWorkerScriptLoaded)
+    IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerScriptLoadFailed,
+                        OnWorkerScriptLoadFailed)
+    IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerConnected,
+                        OnWorkerConnected)
+    IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowDatabase, OnAllowDatabase)
+    IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowFileSystem, OnAllowFileSystem)
+    IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowIndexedDB, OnAllowIndexedDB)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+  return handled;
+}
+
+int SharedWorkerMessageFilter::GetNextRoutingID() {
+  return message_port_message_filter_->GetNextRoutingID();
+}
+
+void SharedWorkerMessageFilter::OnCreateWorker(
+    const ViewHostMsg_CreateWorker_Params& params,
+    int* route_id) {
+  bool url_error = false;
+  *route_id = GetNextRoutingID();
+  SharedWorkerServiceImpl::GetInstance()->CreateWorker(
+      params, *route_id, this, resource_context_, partition_, &url_error);
+  if (url_error)
+    *route_id = MSG_ROUTING_NONE;
+}
+
+void SharedWorkerMessageFilter::OnForwardToWorker(const IPC::Message& message) {
+  SharedWorkerServiceImpl::GetInstance()->ForwardToWorker(message, this);
+}
+
+void SharedWorkerMessageFilter::OnDocumentDetached(
+    unsigned long long document_id) {
+  SharedWorkerServiceImpl::GetInstance()->DocumentDetached(document_id, this);
+}
+
+void SharedWorkerMessageFilter::OnWorkerContextClosed(int worker_route_id) {
+  SharedWorkerServiceImpl::GetInstance()->WorkerContextClosed(worker_route_id,
+                                                              this);
+}
+
+void SharedWorkerMessageFilter::OnWorkerContextDestroyed(int worker_route_id) {
+  SharedWorkerServiceImpl::GetInstance()->WorkerContextDestroyed(
+      worker_route_id,
+      this);
+}
+
+void SharedWorkerMessageFilter::OnWorkerScriptLoaded(int worker_route_id) {
+  SharedWorkerServiceImpl::GetInstance()->WorkerScriptLoaded(worker_route_id,
+                                                             this);
+}
+
+void SharedWorkerMessageFilter::OnWorkerScriptLoadFailed(int worker_route_id) {
+  SharedWorkerServiceImpl::GetInstance()->WorkerScriptLoadFailed(
+      worker_route_id,
+      this);
+}
+
+void SharedWorkerMessageFilter::OnWorkerConnected(int message_port_id,
+                                                  int worker_route_id) {
+  SharedWorkerServiceImpl::GetInstance()->WorkerConnected(
+      message_port_id,
+      worker_route_id,
+      this);
+}
+
+void SharedWorkerMessageFilter::OnAllowDatabase(
+    int worker_route_id,
+    const GURL& url,
+    const base::string16& name,
+    const base::string16& display_name,
+    unsigned long estimated_size,
+    bool* result) {
+  SharedWorkerServiceImpl::GetInstance()->AllowDatabase(worker_route_id,
+                                                        url,
+                                                        name,
+                                                        display_name,
+                                                        estimated_size,
+                                                        result,
+                                                        this);
+}
+
+void SharedWorkerMessageFilter::OnAllowFileSystem(int worker_route_id,
+                                                  const GURL& url,
+                                                  bool* result) {
+  SharedWorkerServiceImpl::GetInstance()->AllowFileSystem(worker_route_id,
+                                                          url,
+                                                          result,
+                                                          this);
+}
+
+void SharedWorkerMessageFilter::OnAllowIndexedDB(int worker_route_id,
+                                                 const GURL& url,
+                                                 const base::string16& name,
+                                                 bool* result) {
+  SharedWorkerServiceImpl::GetInstance()->AllowIndexedDB(worker_route_id,
+                                                         url,
+                                                         name,
+                                                         result,
+                                                         this);
+}
+
+}  // namespace content

content/browser/shared_worker/shared_worker_message_filter.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_MESSAGE_FILTER_H_
+#define CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_MESSAGE_FILTER_H_
+
+#include "content/browser/worker_host/worker_storage_partition.h"
+#include "content/public/browser/browser_message_filter.h"
+
+class GURL;
+struct ViewHostMsg_CreateWorker_Params;
+
+namespace content {
+class MessagePortMessageFilter;
+class ResourceContext;
+
+// If "enable-embedded-shared-worker" is set this class will be used instead of
+// WorkerMessageFilter.
+class SharedWorkerMessageFilter : public BrowserMessageFilter {
+ public:
+  SharedWorkerMessageFilter(int render_process_id,
+                            ResourceContext* resource_context,
+                            const WorkerStoragePartition& partition,
+                            MessagePortMessageFilter* message_port_filter);
+
+  // BrowserMessageFilter implementation.
+  virtual void OnChannelClosing() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message,
+                                 bool* message_was_ok) OVERRIDE;
+
+  int GetNextRoutingID();
+  int render_process_id() const { return render_process_id_; }
+
+  MessagePortMessageFilter* message_port_message_filter() const {
+    return message_port_message_filter_;
+  }
+
+ private:
+  virtual ~SharedWorkerMessageFilter();
+
+  // Message handlers.
+  void OnCreateWorker(const ViewHostMsg_CreateWorker_Params& params,
+                      int* route_id);
+  void OnForwardToWorker(const IPC::Message& message);
+  void OnDocumentDetached(unsigned long long document_id);
+  void OnWorkerContextClosed(int worker_route_id);
+  void OnWorkerContextDestroyed(int worker_route_id);
+  void OnWorkerScriptLoaded(int worker_route_id);
+  void OnWorkerScriptLoadFailed(int worker_route_id);
+  void OnWorkerConnected(int message_port_id, int worker_route_id);
+  void OnAllowDatabase(int worker_route_id,
+                       const GURL& url,
+                       const base::string16& name,
+                       const base::string16& display_name,
+                       unsigned long estimated_size,
+                       bool* result);
+  void OnAllowFileSystem(int worker_route_id,
+                         const GURL& url,
+                         bool* result);
+  void OnAllowIndexedDB(int worker_route_id,
+                        const GURL& url,
+                        const base::string16& name,
+                        bool* result);
+
+  const int render_process_id_;
+  ResourceContext* const resource_context_;
+  const WorkerStoragePartition partition_;
+  MessagePortMessageFilter* const message_port_message_filter_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(SharedWorkerMessageFilter);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_MESSAGE_FILTER_H_

content/browser/shared_worker/shared_worker_service_impl.cc

@@ -4,6 +4,7 @@
 
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
 
+#include "content/browser/shared_worker/shared_worker_message_filter.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/worker_service_observer.h"
@@ -11,21 +12,16 @@
 namespace content {
 
 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() {
-  // TODO(horo): implement this.
-  NOTIMPLEMENTED();
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return Singleton<SharedWorkerServiceImpl>::get();
 }
 
 SharedWorkerServiceImpl::SharedWorkerServiceImpl() {
-  // TODO(horo): implement this.
 }
 
 SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {
-  // TODO(horo): implement this.
 }
 
-
 bool SharedWorkerServiceImpl::TerminateWorker(int process_id, int route_id) {
   // TODO(horo): implement this.
   return false;
@@ -47,4 +43,102 @@ void SharedWorkerServiceImpl::RemoveObserver(WorkerServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void SharedWorkerServiceImpl::CreateWorker(
+    const ViewHostMsg_CreateWorker_Params& params,
+    int route_id,
+    SharedWorkerMessageFilter* filter,
+    ResourceContext* resource_context,
+    const WorkerStoragePartition& partition,
+    bool* url_mismatch) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::ForwardToWorker(
+    const IPC::Message& message,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::DocumentDetached(
+    unsigned long long document_id,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::WorkerContextClosed(
+    int worker_route_id,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::WorkerContextDestroyed(
+    int worker_route_id,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::WorkerScriptLoaded(
+    int worker_route_id,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::WorkerScriptLoadFailed(
+    int worker_route_id,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::WorkerConnected(
+    int message_port_id,
+    int worker_route_id,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::AllowDatabase(
+    int worker_route_id,
+    const GURL& url,
+    const base::string16& name,
+    const base::string16& display_name,
+    unsigned long estimated_size,
+    bool* result,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::AllowFileSystem(
+    int worker_route_id,
+    const GURL& url,
+    bool* result,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::AllowIndexedDB(
+    int worker_route_id,
+    const GURL& url,
+    const base::string16& name,
+    bool* result,
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
+void SharedWorkerServiceImpl::OnSharedWorkerMessageFilterClosing(
+    SharedWorkerMessageFilter* filter) {
+  // TODO(horo): implement this.
+  NOTIMPLEMENTED();
+}
+
 }  // namespace content

content/browser/shared_worker/shared_worker_service_impl.h

@@ -12,11 +12,20 @@
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/worker_service.h"
 
+struct ViewHostMsg_CreateWorker_Params;
+
+namespace IPC {
+class Message;
+}
+
 namespace content {
 
+class SharedWorkerMessageFilter;
+class ResourceContext;
 class WorkerServiceObserver;
+class WorkerStoragePartition;
 
-// If "enable-embedded-shared-worker" is set this class will be used in stead of
+// If "enable-embedded-shared-worker" is set this class will be used instead of
 // WorkerServiceImpl.
 // TODO(horo): implement this class.
 class CONTENT_EXPORT SharedWorkerServiceImpl
@@ -31,6 +40,48 @@ class CONTENT_EXPORT SharedWorkerServiceImpl
   virtual void AddObserver(WorkerServiceObserver* observer) OVERRIDE;
   virtual void RemoveObserver(WorkerServiceObserver* observer) OVERRIDE;
 
+  // These methods correspond to worker related IPCs.
+  void CreateWorker(const ViewHostMsg_CreateWorker_Params& params,
+                    int route_id,
+                    SharedWorkerMessageFilter* filter,
+                    ResourceContext* resource_context,
+                    const WorkerStoragePartition& worker_partition,
+                    bool* url_mismatch);
+  void ForwardToWorker(const IPC::Message& message,
+                       SharedWorkerMessageFilter* filter);
+  void DocumentDetached(unsigned long long document_id,
+                        SharedWorkerMessageFilter* filter);
+  void WorkerContextClosed(int worker_route_id,
+                           SharedWorkerMessageFilter* filter);
+  void WorkerContextDestroyed(int worker_route_id,
+                              SharedWorkerMessageFilter* filter);
+  void WorkerScriptLoaded(int worker_route_id,
+                          SharedWorkerMessageFilter* filter);
+  void WorkerScriptLoadFailed(int worker_route_id,
+                              SharedWorkerMessageFilter* filter);
+  void WorkerConnected(int message_port_id,
+                       int worker_route_id,
+                       SharedWorkerMessageFilter* filter);
+  void AllowDatabase(int worker_route_id,
+                     const GURL& url,
+                     const base::string16& name,
+                     const base::string16& display_name,
+                     unsigned long estimated_size,
+                     bool* result,
+                     SharedWorkerMessageFilter* filter);
+  void AllowFileSystem(int worker_route_id,
+                       const GURL& url,
+                       bool* result,
+                       SharedWorkerMessageFilter* filter);
+  void AllowIndexedDB(int worker_route_id,
+                      const GURL& url,
+                      const base::string16& name,
+                      bool* result,
+                      SharedWorkerMessageFilter* filter);
+
+  void OnSharedWorkerMessageFilterClosing(
+      SharedWorkerMessageFilter* filter);
+
  private:
   friend struct DefaultSingletonTraits<SharedWorkerServiceImpl>;
 

content/content_browser.gypi

@@ -1128,6 +1128,8 @@
     'browser/service_worker/service_worker_storage.h',
     'browser/service_worker/service_worker_version.cc',
     'browser/service_worker/service_worker_version.h',
+    'browser/shared_worker/shared_worker_message_filter.cc',
+    'browser/shared_worker/shared_worker_message_filter.h',
     'browser/shared_worker/shared_worker_service_impl.cc',
     'browser/shared_worker/shared_worker_service_impl.h',
     'browser/signed_certificate_timestamp_store_impl.cc',