Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

third_party/WebKit/Source/modules/cachestorage/Cache.cpp

 // 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 "modules/cachestorage/Cache.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "bindings/modules/v8/V8Response.h"
 #include "core/dom/DOMException.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "modules/cachestorage/CacheStorageError.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/FetchDataLoader.h"
 #include "modules/fetch/GlobalFetch.h"
 #include "modules/fetch/Request.h"
 #include "modules/fetch/Response.h"
 #include "platform/HTTPNames.h"
 #include "platform/Histogram.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCache.h"
 #include <memory>
+#include <utility>
 
 namespace blink {
 
 namespace {
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheMatchCallbacks : public WebServiceWorkerCache::CacheMatchCallbacks {
   WTF_MAKE_NONCOPYABLE(CacheMatchCallbacks);
 
  public:
@@ skipping 262 matching lines @@
     ASSERT(index < m_batchOperations.size());
     if (m_completed)
       return;
     if (!m_resolver->getExecutionContext() ||
         m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
       return;
     m_batchOperations[index] = batchOperation;
     if (--m_numberOfRemainingOperations != 0)
       return;
     m_cache->webCache()->dispatchBatch(
-        new CallbackPromiseAdapter<void, CacheStorageError>(m_resolver),
+        WTF::makeUnique<CallbackPromiseAdapter<void, CacheStorageError>>(
+            m_resolver),
         m_batchOperations);
   }
 
   void onError(const String& errorMessage) {
     if (m_completed)
       return;
     m_completed = true;
     if (!m_resolver->getExecutionContext() ||
         m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
       return;
@@ skipping 205 matching lines @@
                                const CacheQueryOptions& options) {
   WebServiceWorkerRequest webRequest;
   request->populateWebServiceWorkerRequest(webRequest);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
   if (request->method() != HTTPNames::GET && !options.ignoreMethod()) {
     resolver->resolve();
     return promise;
   }
-  m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest,
-                            toWebQueryParams(options));
+  m_webCache->dispatchMatch(WTF::makeUnique<CacheMatchCallbacks>(resolver),
+                            webRequest, toWebQueryParams(options));
   return promise;
 }
 
 ScriptPromise Cache::matchAllImpl(ScriptState* scriptState) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
-  m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver),
-                               WebServiceWorkerRequest(),
-                               WebServiceWorkerCache::QueryParams());
+  m_webCache->dispatchMatchAll(
+      WTF::makeUnique<CacheWithResponsesCallbacks>(resolver),
+      WebServiceWorkerRequest(), WebServiceWorkerCache::QueryParams());
   return promise;
 }
 
 ScriptPromise Cache::matchAllImpl(ScriptState* scriptState,
                                   const Request* request,
                                   const CacheQueryOptions& options) {
   WebServiceWorkerRequest webRequest;
   request->populateWebServiceWorkerRequest(webRequest);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
   if (request->method() != HTTPNames::GET && !options.ignoreMethod()) {
     resolver->resolve(HeapVector<Member<Response>>());
     return promise;
   }
-  m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver),
-                               webRequest, toWebQueryParams(options));
+  m_webCache->dispatchMatchAll(
+      WTF::makeUnique<CacheWithResponsesCallbacks>(resolver), webRequest,
+      toWebQueryParams(options));
   return promise;
 }
 
 ScriptPromise Cache::addAllImpl(ScriptState* scriptState,
                                 const HeapVector<Member<Request>>& requests,
                                 ExceptionState& exceptionState) {
   if (requests.isEmpty())
     return ScriptPromise::castUndefined(scriptState);
 
   HeapVector<RequestInfo> requestInfos;
@@ skipping 29 matching lines @@
   batchOperations[0].operationType = WebServiceWorkerCache::OperationTypeDelete;
   request->populateWebServiceWorkerRequest(batchOperations[0].request);
   batchOperations[0].matchParams = toWebQueryParams(options);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
   if (request->method() != HTTPNames::GET && !options.ignoreMethod()) {
     resolver->resolve(false);
     return promise;
   }
-  m_webCache->dispatchBatch(new CacheDeleteCallback(resolver), batchOperations);
+  m_webCache->dispatchBatch(WTF::makeUnique<CacheDeleteCallback>(resolver),
+                            batchOperations);
   return promise;
 }
 
 ScriptPromise Cache::putImpl(ScriptState* scriptState,
                              const HeapVector<Member<Request>>& requests,
                              const HeapVector<Member<Response>>& responses) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
   BarrierCallbackForPut* barrierCallback =
       new BarrierCallbackForPut(requests.size(), this, resolver);
@@ skipping 44 matching lines @@
     responses[i]->populateWebServiceWorkerResponse(batchOperation.response);
     barrierCallback->onSuccess(i, batchOperation);
   }
 
   return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
-  m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver),
-                           WebServiceWorkerRequest(),
-                           WebServiceWorkerCache::QueryParams());
+  m_webCache->dispatchKeys(
+      WTF::makeUnique<CacheWithRequestsCallbacks>(resolver),
+      WebServiceWorkerRequest(), WebServiceWorkerCache::QueryParams());
   return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState,
                               const Request* request,
                               const CacheQueryOptions& options) {
   WebServiceWorkerRequest webRequest;
   request->populateWebServiceWorkerRequest(webRequest);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
   if (request->method() != HTTPNames::GET && !options.ignoreMethod()) {
     resolver->resolve(HeapVector<Member<Request>>());
     return promise;
   }
-  m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), webRequest,
-                           toWebQueryParams(options));
+  m_webCache->dispatchKeys(
+      WTF::makeUnique<CacheWithRequestsCallbacks>(resolver), webRequest,
+      toWebQueryParams(options));
   return promise;
 }
 
 WebServiceWorkerCache* Cache::webCache() const {
   return m_webCache.get();
 }
 
 }  // namespace blink