Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

third_party/WebKit/Source/modules/cachestorage/CacheStorage.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/CacheStorage.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "modules/cachestorage/CacheStorageError.h"
 #include "modules/fetch/Request.h"
 #include "modules/fetch/Response.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheError.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheStorage.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
+#include <utility>
 
 namespace blink {
 
 namespace {
 
 DOMException* createNoImplementationException() {
   return DOMException::create(NotSupportedError,
                               "No CacheStorage implementation provided.");
 }
 
@@ skipping 201 matching lines @@
 
 ScriptPromise CacheStorage::open(ScriptState* scriptState,
                                  const String& cacheName,
                                  ExceptionState& exceptionState) {
   if (!commonChecks(scriptState, exceptionState))
     return ScriptPromise();
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
 
-  if (m_webCacheStorage)
+  if (m_webCacheStorage) {
     m_webCacheStorage->dispatchOpen(
-        new WithCacheCallbacks(cacheName, this, resolver), cacheName);
-  else
+        WTF::makeUnique<WithCacheCallbacks>(cacheName, this, resolver),
+        cacheName);
+  } else {
     resolver->reject(createNoImplementationException());
+  }
 
   return promise;
 }
 
 ScriptPromise CacheStorage::has(ScriptState* scriptState,
                                 const String& cacheName,
                                 ExceptionState& exceptionState) {
   if (!commonChecks(scriptState, exceptionState))
     return ScriptPromise();
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
 
-  if (m_webCacheStorage)
-    m_webCacheStorage->dispatchHas(new Callbacks(resolver), cacheName);
-  else
+  if (m_webCacheStorage) {
+    m_webCacheStorage->dispatchHas(WTF::makeUnique<Callbacks>(resolver),
+                                   cacheName);
+  } else {
     resolver->reject(createNoImplementationException());
+  }
 
   return promise;
 }
 
 ScriptPromise CacheStorage::deleteFunction(ScriptState* scriptState,
                                            const String& cacheName,
                                            ExceptionState& exceptionState) {
   if (!commonChecks(scriptState, exceptionState))
     return ScriptPromise();
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
 
-  if (m_webCacheStorage)
+  if (m_webCacheStorage) {
     m_webCacheStorage->dispatchDelete(
-        new DeleteCallbacks(cacheName, this, resolver), cacheName);
-  else
+        WTF::makeUnique<DeleteCallbacks>(cacheName, this, resolver), cacheName);
+  } else {
     resolver->reject(createNoImplementationException());
+  }
 
   return promise;
 }
 
 ScriptPromise CacheStorage::keys(ScriptState* scriptState,
                                  ExceptionState& exceptionState) {
   if (!commonChecks(scriptState, exceptionState))
     return ScriptPromise();
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
 
   if (m_webCacheStorage)
-    m_webCacheStorage->dispatchKeys(new KeysCallbacks(resolver));
+    m_webCacheStorage->dispatchKeys(WTF::makeUnique<KeysCallbacks>(resolver));
   else
     resolver->reject(createNoImplementationException());
 
   return promise;
 }
 
 ScriptPromise CacheStorage::match(ScriptState* scriptState,
                                   const RequestInfo& request,
                                   const CacheQueryOptions& options,
                                   ExceptionState& exceptionState) {
@@ skipping 18 matching lines @@
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   const ScriptPromise promise = resolver->promise();
 
   if (request->method() != HTTPNames::GET && !options.ignoreMethod()) {
     resolver->resolve();
     return promise;
   }
 
   if (m_webCacheStorage)
-    m_webCacheStorage->dispatchMatch(new MatchCallbacks(resolver), webRequest,
+    m_webCacheStorage->dispatchMatch(WTF::makeUnique<MatchCallbacks>(resolver),
+                                     webRequest,
                                      Cache::toWebQueryParams(options));
   else
     resolver->reject(createNoImplementationException());
 
   return promise;
 }
 
 CacheStorage::CacheStorage(
     GlobalFetch::ScopedFetcher* fetcher,
     std::unique_ptr<WebServiceWorkerCacheStorage> webCacheStorage)
     : m_scopedFetcher(fetcher), m_webCacheStorage(std::move(webCacheStorage)) {}
 
 CacheStorage::~CacheStorage() {}
 
 void CacheStorage::dispose() {
   m_webCacheStorage.reset();
 }
 
 DEFINE_TRACE(CacheStorage) {
   visitor->trace(m_scopedFetcher);
 }
 
 }  // namespace blink