Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 443 matching lines @@
       service_manager::InterfaceProviderSpec());
   context_->remote_interfaces.Bind(std::move(remote_interfaces));
 }
 
 blink::WebURL ServiceWorkerContextClient::scope() const {
   return service_worker_scope_;
 }
 
 void ServiceWorkerContextClient::getClient(
     const blink::WebString& id,
     blink::WebServiceWorkerClientCallbacks* callbacks) {

[danakj, 2016/11/18 00:15:33]

samesamesame

   DCHECK(callbacks);
-  int request_id = context_->client_callbacks.Add(callbacks);
+  int request_id = context_->client_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerClientCallbacks>(callbacks));
   Send(new ServiceWorkerHostMsg_GetClient(
       GetRoutingID(), request_id, base::UTF16ToUTF8(base::StringPiece16(id))));
 }
 
 void ServiceWorkerContextClient::getClients(
     const blink::WebServiceWorkerClientQueryOptions& weboptions,
     blink::WebServiceWorkerClientsCallbacks* callbacks) {
   DCHECK(callbacks);
-  int request_id = context_->clients_callbacks.Add(callbacks);
+  int request_id = context_->clients_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerClientsCallbacks>(callbacks));
   ServiceWorkerClientQueryOptions options;
   options.client_type = weboptions.clientType;
   options.include_uncontrolled = weboptions.includeUncontrolled;
   Send(new ServiceWorkerHostMsg_GetClients(
       GetRoutingID(), request_id, options));
 }
 
 void ServiceWorkerContextClient::openWindow(
     const blink::WebURL& url,
     blink::WebServiceWorkerClientCallbacks* callbacks) {
   DCHECK(callbacks);
-  int request_id = context_->client_callbacks.Add(callbacks);
+  int request_id = context_->client_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerClientCallbacks>(callbacks));
   Send(new ServiceWorkerHostMsg_OpenWindow(
       GetRoutingID(), request_id, url));
 }
 
 void ServiceWorkerContextClient::setCachedMetadata(const blink::WebURL& url,
                                                     const char* data,
                                                     size_t size) {
   std::vector<char> copy(data, data + size);
   Send(new ServiceWorkerHostMsg_SetCachedMetadata(GetRoutingID(), url, copy));
 }
@@ skipping 378 matching lines @@
     const blink::WebCrossOriginServiceWorkerClient&,
     const blink::WebString&,
     blink::WebMessagePortChannelArray*) {
   NOTREACHED();
 }
 
 void ServiceWorkerContextClient::focus(
     const blink::WebString& uuid,
     blink::WebServiceWorkerClientCallbacks* callback) {
   DCHECK(callback);
-  int request_id = context_->client_callbacks.Add(callback);
+  int request_id = context_->client_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerClientCallbacks>(callback));
   Send(new ServiceWorkerHostMsg_FocusClient(
       GetRoutingID(), request_id,
       base::UTF16ToUTF8(base::StringPiece16(uuid))));
 }
 
 void ServiceWorkerContextClient::navigate(
     const blink::WebString& uuid,
     const blink::WebURL& url,
     blink::WebServiceWorkerClientCallbacks* callback) {
   DCHECK(callback);
-  int request_id = context_->client_callbacks.Add(callback);
+  int request_id = context_->client_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerClientCallbacks>(callback));
   Send(new ServiceWorkerHostMsg_NavigateClient(
       GetRoutingID(), request_id, base::UTF16ToUTF8(base::StringPiece16(uuid)),
       url));
 }
 
 void ServiceWorkerContextClient::skipWaiting(
     blink::WebServiceWorkerSkipWaitingCallbacks* callbacks) {
   DCHECK(callbacks);
-  int request_id = context_->skip_waiting_callbacks.Add(callbacks);
+  int request_id = context_->skip_waiting_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>(callbacks));
   Send(new ServiceWorkerHostMsg_SkipWaiting(GetRoutingID(), request_id));
 }
 
 void ServiceWorkerContextClient::claim(
     blink::WebServiceWorkerClientsClaimCallbacks* callbacks) {
   DCHECK(callbacks);
-  int request_id = context_->claim_clients_callbacks.Add(callbacks);
+  int request_id = context_->claim_clients_callbacks.Add(
+      std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks>(callbacks));
   Send(new ServiceWorkerHostMsg_ClaimClients(GetRoutingID(), request_id));
 }
 
 void ServiceWorkerContextClient::registerForeignFetchScopes(
     const blink::WebVector<blink::WebURL>& sub_scopes,
     const blink::WebVector<blink::WebSecurityOrigin>& origins) {
   Send(new ServiceWorkerHostMsg_RegisterForeignFetchScopes(
       GetRoutingID(), std::vector<GURL>(sub_scopes.begin(), sub_scopes.end()),
       std::vector<url::Origin>(origins.begin(), origins.end())));
 }
 
 void ServiceWorkerContextClient::DispatchSyncEvent(
     const std::string& tag,
     blink::WebServiceWorkerContextProxy::LastChanceOption last_chance,
     const SyncCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchSyncEvent");
-  int request_id =
-      context_->sync_event_callbacks.Add(new SyncCallback(callback));
+  int request_id = context_->sync_event_callbacks.Add(
+      base::MakeUnique<SyncCallback>(callback));
 
   // TODO(jkarlin): Make this blink::WebString::FromUTF8Lenient once
   // https://crrev.com/1768063002/ lands.
   proxy_->dispatchSyncEvent(request_id, blink::WebString::fromUTF8(tag),
                             last_chance);
 }
 
 void ServiceWorkerContextClient::Send(IPC::Message* message) {
   sender_->Send(message);
 }
@@ skipping 68 matching lines @@
 
 void ServiceWorkerContextClient::DispatchFetchEvent(
     int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     std::unique_ptr<NavigationPreloadRequest> preload_request,
     const FetchCallback& callback) {
   const bool navigation_preload_sent = !!preload_request;
   blink::WebServiceWorkerRequest webRequest;
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchFetchEvent");
-  context_->fetch_event_callbacks.AddWithID(new FetchCallback(callback),
-                                            fetch_event_id);
+  context_->fetch_event_callbacks.AddWithID(
+      base::MakeUnique<FetchCallback>(callback), fetch_event_id);
   if (preload_request) {
     context_->preload_requests.AddWithID(std::move(preload_request),
                                          fetch_event_id);
   }
 
   webRequest.setURL(blink::WebURL(request.url));
   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
   for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();
        it != request.headers.end();
        ++it) {
@@ skipping 263 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content