Snapshot of all changes to get jumbo in blink and content.

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 <stddef.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 22 matching lines @@
 using blink::WebServiceWorkerProvider;
 using base::ThreadLocalPointer;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<ThreadLocalPointer<void>>::Leaky g_dispatcher_tls =
     LAZY_INSTANCE_INITIALIZER;
 
-void* const kHasBeenDeleted = reinterpret_cast<void*>(0x1);
+void* const kSWDispatcherHasBeenDeleted = reinterpret_cast<void*>(0x1);
 
-int CurrentWorkerId() {
+int ServiceWorkerCurrentWorkerId() {
   return WorkerThread::GetCurrentId();
 }
 
 }  // namespace
 
 ServiceWorkerDispatcher::ServiceWorkerDispatcher(
     ThreadSafeSender* thread_safe_sender,
     base::SingleThreadTaskRunner* main_thread_task_runner)
     : thread_safe_sender_(thread_safe_sender),
       main_thread_task_runner_(main_thread_task_runner) {
   g_dispatcher_tls.Pointer()->Set(static_cast<void*>(this));
 }
 
 ServiceWorkerDispatcher::~ServiceWorkerDispatcher() {
-  g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
+  g_dispatcher_tls.Pointer()->Set(kSWDispatcherHasBeenDeleted);
 }
 
 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
 
   // When you add a new message handler, you should consider adding a similar
   // handler in ServiceWorkerMessageFilter to release references passed from
   // the browser process in case we fail to post task to the thread.
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_AssociateRegistration,
@@ skipping 67 matching lines @@
 
   int request_id = pending_registration_callbacks_.Add(std::move(callbacks));
   ServiceWorkerRegistrationOptions options(pattern);
 
   TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker",
                            "ServiceWorkerDispatcher::RegisterServiceWorker",
                            request_id,
                            "Scope", pattern.spec(),
                            "Script URL", script_url.spec());
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker(
-      CurrentWorkerId(), request_id, provider_id, script_url, options));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, script_url, options));
 }
 
 void ServiceWorkerDispatcher::UpdateServiceWorker(
     int provider_id,
     int64_t registration_id,
     std::unique_ptr<WebServiceWorkerUpdateCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id = pending_update_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_UpdateServiceWorker(
-      CurrentWorkerId(), request_id, provider_id, registration_id));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, registration_id));
 }
 
 void ServiceWorkerDispatcher::UnregisterServiceWorker(
     int provider_id,
     int64_t registration_id,
     std::unique_ptr<WebServiceWorkerUnregistrationCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id = pending_unregistration_callbacks_.Add(std::move(callbacks));
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerDispatcher::UnregisterServiceWorker",
                            request_id, "Registration ID", registration_id);
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_UnregisterServiceWorker(
-      CurrentWorkerId(), request_id, provider_id, registration_id));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, registration_id));
 }
 
 void ServiceWorkerDispatcher::GetRegistration(
     int provider_id,
     const GURL& document_url,
     std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks> callbacks) {
   DCHECK(callbacks);
 
   if (document_url.possibly_invalid_spec().size() > url::kMaxURLChars) {
     std::string error_message(kServiceWorkerGetRegistrationErrorPrefix);
     error_message += "The provided documentURL is too long.";
     callbacks->OnError(
         WebServiceWorkerError(WebServiceWorkerError::kErrorTypeSecurity,
                               blink::WebString::FromASCII(error_message)));
     return;
   }
 
   int request_id =
       pending_get_registration_callbacks_.Add(std::move(callbacks));
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistration",
                            request_id,
                            "Document URL", document_url.spec());
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistration(
-      CurrentWorkerId(), request_id, provider_id, document_url));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, document_url));
 }
 
 void ServiceWorkerDispatcher::GetRegistrations(
     int provider_id,
     std::unique_ptr<WebServiceWorkerGetRegistrationsCallbacks> callbacks) {
   DCHECK(callbacks);
 
   int request_id =
       pending_get_registrations_callbacks_.Add(std::move(callbacks));
 
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistrations",
                            request_id);
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistrations(
-      CurrentWorkerId(), request_id, provider_id));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id));
 }
 
 void ServiceWorkerDispatcher::GetRegistrationForReady(
     int provider_id,
     std::unique_ptr<WebServiceWorkerGetRegistrationForReadyCallbacks>
         callbacks) {
   int request_id = get_for_ready_callbacks_.Add(std::move(callbacks));
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistrationForReady",
                            request_id);
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistrationForReady(
-      CurrentWorkerId(), request_id, provider_id));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id));
 }
 
 void ServiceWorkerDispatcher::EnableNavigationPreload(
     int provider_id,
     int64_t registration_id,
     bool enable,
     std::unique_ptr<WebEnableNavigationPreloadCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id =
       enable_navigation_preload_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_EnableNavigationPreload(
-      CurrentWorkerId(), request_id, provider_id, registration_id, enable));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, registration_id, enable));
 }
 
 void ServiceWorkerDispatcher::GetNavigationPreloadState(
     int provider_id,
     int64_t registration_id,
     std::unique_ptr<WebGetNavigationPreloadStateCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id =
       get_navigation_preload_state_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetNavigationPreloadState(
-      CurrentWorkerId(), request_id, provider_id, registration_id));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, registration_id));
 }
 
 void ServiceWorkerDispatcher::SetNavigationPreloadHeader(
     int provider_id,
     int64_t registration_id,
     const std::string& value,
     std::unique_ptr<WebSetNavigationPreloadHeaderCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id =
       set_navigation_preload_header_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_SetNavigationPreloadHeader(
-      CurrentWorkerId(), request_id, provider_id, registration_id, value));
+      ServiceWorkerCurrentWorkerId(), request_id, provider_id, registration_id, value));
 }
 
 void ServiceWorkerDispatcher::AddProviderContext(
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
   int provider_id = provider_context->provider_id();
   DCHECK(!base::ContainsKey(provider_contexts_, provider_id));
   provider_contexts_[provider_id] = provider_context;
 }
 
@@ skipping 16 matching lines @@
 void ServiceWorkerDispatcher::RemoveProviderClient(int provider_id) {
   // This could be possibly called multiple times to ensure termination.
   if (base::ContainsKey(provider_clients_, provider_id))
     provider_clients_.erase(provider_id);
 }
 
 ServiceWorkerDispatcher*
 ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
     ThreadSafeSender* thread_safe_sender,
     base::SingleThreadTaskRunner* main_thread_task_runner) {
-  if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
+  if (g_dispatcher_tls.Pointer()->Get() == kSWDispatcherHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher.";
     g_dispatcher_tls.Pointer()->Set(NULL);
   }
   if (g_dispatcher_tls.Pointer()->Get())
     return static_cast<ServiceWorkerDispatcher*>(
         g_dispatcher_tls.Pointer()->Get());
 
   ServiceWorkerDispatcher* dispatcher =
       new ServiceWorkerDispatcher(thread_safe_sender, main_thread_task_runner);
   if (WorkerThread::GetCurrentId())
     WorkerThread::AddObserver(dispatcher);
   return dispatcher;
 }
 
 ServiceWorkerDispatcher* ServiceWorkerDispatcher::GetThreadSpecificInstance() {
-  if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted)
+  if (g_dispatcher_tls.Pointer()->Get() == kSWDispatcherHasBeenDeleted)
     return NULL;
   return static_cast<ServiceWorkerDispatcher*>(
       g_dispatcher_tls.Pointer()->Get());
 }
 
 void ServiceWorkerDispatcher::WillStopCurrentWorkerThread() {
   delete this;
 }
 
 scoped_refptr<WebServiceWorkerImpl>
@@ skipping 607 matching lines @@
   return ServiceWorkerRegistrationHandleReference::Adopt(
       info, thread_safe_sender_.get());
 }
 
 std::unique_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerObjectInfo& info) {
   return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
 }
 
 }  // namespace content