Revert of ServiceWorker: Introduce SWMessageSender in order to mock IPC messaging

content/child/service_worker/service_worker_dispatcher.cc

 // Copyright 2013 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/child/service_worker/service_worker_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
-#include "content/child/service_worker/service_worker_message_sender.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/service_worker_registration_handle_reference.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/common/url_utils.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerClientsInfo.h"
@@ skipping 15 matching lines @@
 ServiceWorkerDispatcher* const kHasBeenDeleted =
     reinterpret_cast<ServiceWorkerDispatcher*>(0x1);
 
 int CurrentWorkerId() {
   return WorkerTaskRunner::Instance()->CurrentWorkerId();
 }
 
 }  // namespace
 
 ServiceWorkerDispatcher::ServiceWorkerDispatcher(
-    ServiceWorkerMessageSender* sender)
-    : sender_(sender) {
+    ThreadSafeSender* thread_safe_sender)
+    : thread_safe_sender_(thread_safe_sender) {
   g_dispatcher_tls.Pointer()->Set(this);
 }
 
 ServiceWorkerDispatcher::~ServiceWorkerDispatcher() {
   g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
 }
 
 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
@@ skipping 24 matching lines @@
                         OnUpdateFound)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetControllerServiceWorker,
                         OnSetControllerServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToDocument,
                         OnPostMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
+bool ServiceWorkerDispatcher::Send(IPC::Message* msg) {
+  return thread_safe_sender_->Send(msg);
+}
+
 void ServiceWorkerDispatcher::RegisterServiceWorker(
     int provider_id,
     const GURL& pattern,
     const GURL& script_url,
     WebServiceWorkerRegistrationCallbacks* callbacks) {
   DCHECK(callbacks);
 
   if (pattern.possibly_invalid_spec().size() > GetMaxURLChars() ||
       script_url.possibly_invalid_spec().size() > GetMaxURLChars()) {
     scoped_ptr<WebServiceWorkerRegistrationCallbacks>
         owned_callbacks(callbacks);
     std::string error_message(kServiceWorkerRegisterErrorPrefix);
     error_message += "The provided scriptURL or scope is too long.";
     scoped_ptr<WebServiceWorkerError> error(
         new WebServiceWorkerError(WebServiceWorkerError::ErrorTypeSecurity,
                                   blink::WebString::fromUTF8(error_message)));
     callbacks->onError(error.release());
     return;
   }
 
   int request_id = pending_registration_callbacks_.Add(callbacks);
   TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker",
                            "ServiceWorkerDispatcher::RegisterServiceWorker",
                            request_id,
                            "Scope", pattern.spec(),
                            "Script URL", script_url.spec());
-  sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker(
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker(
       CurrentWorkerId(), request_id, provider_id, pattern, script_url));
 }
 
 void ServiceWorkerDispatcher::UnregisterServiceWorker(
     int provider_id,
     const GURL& pattern,
     WebServiceWorkerUnregistrationCallbacks* callbacks) {
   DCHECK(callbacks);
 
   if (pattern.possibly_invalid_spec().size() > GetMaxURLChars()) {
     scoped_ptr<WebServiceWorkerUnregistrationCallbacks>
         owned_callbacks(callbacks);
     std::string error_message(kServiceWorkerUnregisterErrorPrefix);
     error_message += "The provided scope is too long.";
     scoped_ptr<WebServiceWorkerError> error(
         new WebServiceWorkerError(WebServiceWorkerError::ErrorTypeSecurity,
                                   blink::WebString::fromUTF8(error_message)));
     callbacks->onError(error.release());
     return;
   }
 
   int request_id = pending_unregistration_callbacks_.Add(callbacks);
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerDispatcher::UnregisterServiceWorker",
                            request_id,
                            "Scope", pattern.spec());
-  sender_->Send(new ServiceWorkerHostMsg_UnregisterServiceWorker(
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_UnregisterServiceWorker(
       CurrentWorkerId(), request_id, provider_id, pattern));
 }
 
 void ServiceWorkerDispatcher::GetRegistration(
     int provider_id,
     const GURL& document_url,
     WebServiceWorkerRegistrationCallbacks* callbacks) {
   DCHECK(callbacks);
 
   if (document_url.possibly_invalid_spec().size() > GetMaxURLChars()) {
     scoped_ptr<WebServiceWorkerRegistrationCallbacks>
         owned_callbacks(callbacks);
     std::string error_message(kServiceWorkerGetRegistrationErrorPrefix);
     error_message += "The provided documentURL is too long.";
     scoped_ptr<WebServiceWorkerError> error(
         new WebServiceWorkerError(WebServiceWorkerError::ErrorTypeSecurity,
                                   blink::WebString::fromUTF8(error_message)));
     callbacks->onError(error.release());
     return;
   }
 
   int request_id = pending_get_registration_callbacks_.Add(callbacks);
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistration",
                            request_id,
                            "Document URL", document_url.spec());
-  sender_->Send(new ServiceWorkerHostMsg_GetRegistration(
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistration(
       CurrentWorkerId(), request_id, provider_id, document_url));
 }
 
 void ServiceWorkerDispatcher::GetRegistrationForReady(
     int provider_id,
     WebServiceWorkerGetRegistrationForReadyCallbacks* callbacks) {
   int request_id = get_for_ready_callbacks_.Add(callbacks);
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistrationForReady",
                            request_id);
-  sender_->Send(new ServiceWorkerHostMsg_GetRegistrationForReady(
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistrationForReady(
       CurrentWorkerId(), request_id, provider_id));
 }
 
 void ServiceWorkerDispatcher::AddProviderContext(
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
   int provider_id = provider_context->provider_id();
   DCHECK(!ContainsKey(provider_contexts_, provider_id));
   provider_contexts_[provider_id] = provider_context;
 }
@@ skipping 18 matching lines @@
 }
 
 void ServiceWorkerDispatcher::RemoveProviderClient(int provider_id) {
   // This could be possibly called multiple times to ensure termination.
   if (ContainsKey(provider_clients_, provider_id))
     provider_clients_.erase(provider_id);
 }
 
 ServiceWorkerDispatcher*
 ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
-    ServiceWorkerMessageSender* sender) {
+    ThreadSafeSender* thread_safe_sender) {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher.";
     g_dispatcher_tls.Pointer()->Set(NULL);
   }
   if (g_dispatcher_tls.Pointer()->Get())
     return g_dispatcher_tls.Pointer()->Get();
 
   ServiceWorkerDispatcher* dispatcher =
-      new ServiceWorkerDispatcher(sender);
+      new ServiceWorkerDispatcher(thread_safe_sender);
   if (WorkerTaskRunner::Instance()->CurrentWorkerId())
     WorkerTaskRunner::Instance()->AddStopObserver(dispatcher);
   return dispatcher;
 }
 
 ServiceWorkerDispatcher* ServiceWorkerDispatcher::GetThreadSpecificInstance() {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted)
     return NULL;
   return g_dispatcher_tls.Pointer()->Get();
 }
 
 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 WebServiceWorkerImpl* ServiceWorkerDispatcher::GetServiceWorker(
     const ServiceWorkerObjectInfo& info,
     bool adopt_handle) {
   if (info.handle_id == kInvalidServiceWorkerHandleId)
     return NULL;
 
   WorkerObjectMap::iterator existing_worker =
       service_workers_.find(info.handle_id);
 
   if (existing_worker != service_workers_.end()) {
     if (adopt_handle) {
       // We are instructed to adopt a handle but we already have one, so
       // adopt and destroy a handle ref.
-      ServiceWorkerHandleReference::Adopt(info, sender_.get());
+      ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
     }
     return existing_worker->second;
   }
 
   scoped_ptr<ServiceWorkerHandleReference> handle_ref =
       adopt_handle
-          ? ServiceWorkerHandleReference::Adopt(info, sender_.get())
-          : ServiceWorkerHandleReference::Create(info, sender_.get());
+          ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get())
+          : ServiceWorkerHandleReference::Create(info,
+                                                 thread_safe_sender_.get());
   // WebServiceWorkerImpl constructor calls AddServiceWorker.
-  return new WebServiceWorkerImpl(handle_ref.Pass(), sender_.get());
+  return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_.get());
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::CreateServiceWorkerRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     bool adopt_handle) {
   DCHECK(!ContainsKey(registrations_, info.handle_id));
   if (info.handle_id == kInvalidServiceWorkerRegistrationHandleId)
     return NULL;
 
   scoped_ptr<ServiceWorkerRegistrationHandleReference> handle_ref =
       adopt_handle ? ServiceWorkerRegistrationHandleReference::Adopt(
-                         info, sender_.get())
+                         info, thread_safe_sender_.get())
                    : ServiceWorkerRegistrationHandleReference::Create(
-                         info, sender_.get());
+                         info, thread_safe_sender_.get());
 
   // WebServiceWorkerRegistrationImpl constructor calls
   // AddServiceWorkerRegistration.
   return new WebServiceWorkerRegistrationImpl(handle_ref.Pass());
 }
 
 // We can assume that this message handler is called before the worker context
 // starts because script loading happens after this association.
 // TODO(nhiroki): This association information could be pushed into
 // EmbeddedWorkerMsg_StartWorker message and handed over to the worker thread
@@ skipping 363 matching lines @@
   DCHECK(ContainsKey(registrations_, registration_handle_id));
   registrations_.erase(registration_handle_id);
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::FindOrCreateRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
   if (found != registrations_.end()) {
-    ServiceWorkerRegistrationHandleReference::Adopt(info, sender_.get());
-    ServiceWorkerHandleReference::Adopt(attrs.installing, sender_.get());
-    ServiceWorkerHandleReference::Adopt(attrs.waiting, sender_.get());
-    ServiceWorkerHandleReference::Adopt(attrs.active, sender_.get());
+    ServiceWorkerRegistrationHandleReference::Adopt(info,
+                                                    thread_safe_sender_.get());
+    ServiceWorkerHandleReference::Adopt(attrs.installing,
+                                        thread_safe_sender_.get());
+    ServiceWorkerHandleReference::Adopt(attrs.waiting,
+                                        thread_safe_sender_.get());
+    ServiceWorkerHandleReference::Adopt(attrs.active,
+                                        thread_safe_sender_.get());
     return found->second;
   }
 
   bool adopt_handle = true;
   WebServiceWorkerRegistrationImpl* registration =
       CreateServiceWorkerRegistration(info, adopt_handle);
   registration->SetInstalling(GetServiceWorker(attrs.installing, adopt_handle));
   registration->SetWaiting(GetServiceWorker(attrs.waiting, adopt_handle));
   registration->SetActive(GetServiceWorker(attrs.active, adopt_handle));
   return registration;
 }
 
 }  // namespace content