Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

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 103 matching lines @@
                         OnPostMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void ServiceWorkerDispatcher::RegisterServiceWorker(
     int provider_id,
     const GURL& pattern,
     const GURL& script_url,
-    WebServiceWorkerRegistrationCallbacks* callbacks) {
+    std::unique_ptr<WebServiceWorkerRegistrationCallbacks> callbacks) {
   DCHECK(callbacks);
 
   if (pattern.possibly_invalid_spec().size() > url::kMaxURLChars ||
       script_url.possibly_invalid_spec().size() > url::kMaxURLChars) {
-    std::unique_ptr<WebServiceWorkerRegistrationCallbacks> owned_callbacks(
-        callbacks);
     std::string error_message(kServiceWorkerRegisterErrorPrefix);
     error_message += "The provided scriptURL or scope is too long.";
     callbacks->onError(
         WebServiceWorkerError(WebServiceWorkerError::ErrorTypeSecurity,
                               blink::WebString::fromUTF8(error_message)));
     return;
   }
 
-  int request_id = pending_registration_callbacks_.Add(callbacks);
+  int request_id = pending_registration_callbacks_.Add(std::move(callbacks));
   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, pattern, script_url));
 }
 
 void ServiceWorkerDispatcher::UpdateServiceWorker(
     int provider_id,
     int64_t registration_id,
-    WebServiceWorkerUpdateCallbacks* callbacks) {
+    std::unique_ptr<WebServiceWorkerUpdateCallbacks> callbacks) {
   DCHECK(callbacks);
-  int request_id = pending_update_callbacks_.Add(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));
 }
 
 void ServiceWorkerDispatcher::UnregisterServiceWorker(
     int provider_id,
     int64_t registration_id,
-    WebServiceWorkerUnregistrationCallbacks* callbacks) {
+    std::unique_ptr<WebServiceWorkerUnregistrationCallbacks> callbacks) {
   DCHECK(callbacks);
-  int request_id = pending_unregistration_callbacks_.Add(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));
 }
 
 void ServiceWorkerDispatcher::GetRegistration(
     int provider_id,
     const GURL& document_url,
-    WebServiceWorkerGetRegistrationCallbacks* callbacks) {
+    std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks> callbacks) {
   DCHECK(callbacks);
 
   if (document_url.possibly_invalid_spec().size() > url::kMaxURLChars) {
-    std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks> owned_callbacks(
-        callbacks);
     std::string error_message(kServiceWorkerGetRegistrationErrorPrefix);
     error_message += "The provided documentURL is too long.";
     callbacks->onError(
         WebServiceWorkerError(WebServiceWorkerError::ErrorTypeSecurity,
                               blink::WebString::fromUTF8(error_message)));
     return;
   }
 
-  int request_id = pending_get_registration_callbacks_.Add(callbacks);
+  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));
 }
 
 void ServiceWorkerDispatcher::GetRegistrations(
     int provider_id,
-    WebServiceWorkerGetRegistrationsCallbacks* callbacks) {
+    std::unique_ptr<WebServiceWorkerGetRegistrationsCallbacks> callbacks) {
   DCHECK(callbacks);
 
-  int request_id = pending_get_registrations_callbacks_.Add(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));
 }
 
 void ServiceWorkerDispatcher::GetRegistrationForReady(
     int provider_id,
-    WebServiceWorkerGetRegistrationForReadyCallbacks* callbacks) {
-  int request_id = get_for_ready_callbacks_.Add(callbacks);
+    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));
 }
 
 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(callbacks.release());
+      enable_navigation_preload_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_EnableNavigationPreload(
       CurrentWorkerId(), 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(callbacks.release());
+      get_navigation_preload_state_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetNavigationPreloadState(
       CurrentWorkerId(), 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(callbacks.release());
+      set_navigation_preload_header_callbacks_.Add(std::move(callbacks));
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_SetNavigationPreloadHeader(
       CurrentWorkerId(), 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 641 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