Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

third_party/WebKit/Source/modules/cachestorage/InspectorCacheStorageAgent.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/InspectorCacheStorageAgent.h"
 
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCache.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheError.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheStorage.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
 #include <memory>
+#include <utility>
 
 using blink::protocol::Array;
 using blink::protocol::CacheStorage::Cache;
 using blink::protocol::CacheStorage::DataEntry;
 
 typedef blink::protocol::CacheStorage::Backend::DeleteCacheCallback
     DeleteCacheCallback;
 typedef blink::protocol::CacheStorage::Backend::DeleteEntryCallback
     DeleteEntryCallback;
 typedef blink::protocol::CacheStorage::Backend::RequestCacheNamesCallback
@@ skipping 229 matching lines @@
       std::unique_ptr<Array<DataEntry>> array = Array<DataEntry>::create();
       m_callback->sendSuccess(std::move(array), false);
       return;
     }
     RefPtr<ResponsesAccumulator> accumulator =
         adoptRef(new ResponsesAccumulator(requests.size(), m_params,
                                           std::move(m_callback)));
 
     for (size_t i = 0; i < requests.size(); i++) {
       const auto& request = requests[i];
-      auto* cacheRequest =
-          new GetCacheResponsesForRequestData(m_params, request, accumulator);
-      m_cache->dispatchMatch(cacheRequest, request,
+      auto cacheRequest = WTF::makeUnique<GetCacheResponsesForRequestData>(
+          m_params, request, accumulator);
+      m_cache->dispatchMatch(std::move(cacheRequest), request,
                              WebServiceWorkerCache::QueryParams());
     }
   }
 
   void onError(WebServiceWorkerCacheError error) override {
     m_callback->sendFailure(Response::Error(
         String::format("Error requesting requests for cache %s: %s",
                        m_params.cacheName.utf8().data(),
                        serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams m_params;
   std::unique_ptr<WebServiceWorkerCache> m_cache;
   std::unique_ptr<RequestEntriesCallback> m_callback;
 };
 
 class GetCacheForRequestData
     : public WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
   WTF_MAKE_NONCOPYABLE(GetCacheForRequestData);
 
  public:
   GetCacheForRequestData(const DataRequestParams& params,
                          std::unique_ptr<RequestEntriesCallback> callback)
       : m_params(params), m_callback(std::move(callback)) {}
   ~GetCacheForRequestData() override {}
 
   void onSuccess(std::unique_ptr<WebServiceWorkerCache> cache) override {
-    auto* cacheRequest = new GetCacheKeysForRequestData(
-        m_params, wrapUnique(cache.release()), std::move(m_callback));
-    cacheRequest->cache()->dispatchKeys(cacheRequest, WebServiceWorkerRequest(),
+    auto cacheRequest = WTF::makeUnique<GetCacheKeysForRequestData>(
+        m_params, std::move(cache), std::move(m_callback));
+    cacheRequest->cache()->dispatchKeys(std::move(cacheRequest),
+                                        WebServiceWorkerRequest(),
                                         WebServiceWorkerCache::QueryParams());
   }
 
   void onError(WebServiceWorkerCacheError error) override {
     m_callback->sendFailure(Response::Error(String::format(
         "Error requesting cache %s: %s", m_params.cacheName.utf8().data(),
         serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
@@ skipping 48 matching lines @@
  public:
   GetCacheForDeleteEntry(const String& requestSpec,
                          const String& cacheName,
                          std::unique_ptr<DeleteEntryCallback> callback)
       : m_requestSpec(requestSpec),
         m_cacheName(cacheName),
         m_callback(std::move(callback)) {}
   ~GetCacheForDeleteEntry() override {}
 
   void onSuccess(std::unique_ptr<WebServiceWorkerCache> cache) override {
-    auto* deleteRequest = new DeleteCacheEntry(std::move(m_callback));
+    auto deleteRequest =
+        WTF::makeUnique<DeleteCacheEntry>(std::move(m_callback));
     BatchOperation deleteOperation;
     deleteOperation.operationType = WebServiceWorkerCache::OperationTypeDelete;
     deleteOperation.request.setURL(KURL(ParsedURLString, m_requestSpec));
     Vector<BatchOperation> operations;
     operations.append(deleteOperation);
-    cache.release()->dispatchBatch(deleteRequest,
+    cache.release()->dispatchBatch(std::move(deleteRequest),
                                    WebVector<BatchOperation>(operations));
   }
 
   void onError(WebServiceWorkerCacheError error) override {
     m_callback->sendFailure(Response::Error(String::format(
         "Error requesting cache %s: %s", m_cacheName.utf8().data(),
         serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
@@ skipping 26 matching lines @@
     return;
   }
 
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
   Response response = assertCacheStorage(securityOrigin, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   cache->dispatchKeys(
-      new RequestCacheNames(securityOrigin, std::move(callback)));
+      WTF::makeUnique<RequestCacheNames>(securityOrigin, std::move(callback)));
 }
 
 void InspectorCacheStorageAgent::requestEntries(
     const String& cacheId,
     int skipCount,
     int pageSize,
     std::unique_ptr<RequestEntriesCallback> callback) {
   String cacheName;
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
   Response response =
       assertCacheStorageAndNameForId(cacheId, &cacheName, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   DataRequestParams params;
   params.cacheName = cacheName;
   params.pageSize = pageSize;
   params.skipCount = skipCount;
-  cache->dispatchOpen(new GetCacheForRequestData(params, std::move(callback)),
-                      WebString(cacheName));
+  cache->dispatchOpen(
+      WTF::makeUnique<GetCacheForRequestData>(params, std::move(callback)),
+      WebString(cacheName));
 }
 
 void InspectorCacheStorageAgent::deleteCache(
     const String& cacheId,
     std::unique_ptr<DeleteCacheCallback> callback) {
   String cacheName;
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
   Response response =
       assertCacheStorageAndNameForId(cacheId, &cacheName, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
-  cache->dispatchDelete(new DeleteCache(std::move(callback)),
+  cache->dispatchDelete(WTF::makeUnique<DeleteCache>(std::move(callback)),
                         WebString(cacheName));
 }
 
 void InspectorCacheStorageAgent::deleteEntry(
     const String& cacheId,
     const String& request,
     std::unique_ptr<DeleteEntryCallback> callback) {
   String cacheName;
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
   Response response =
       assertCacheStorageAndNameForId(cacheId, &cacheName, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
-  cache->dispatchOpen(
-      new GetCacheForDeleteEntry(request, cacheName, std::move(callback)),
-      WebString(cacheName));
+  cache->dispatchOpen(WTF::makeUnique<GetCacheForDeleteEntry>(
+                          request, cacheName, std::move(callback)),
+                      WebString(cacheName));
 }
 
 }  // namespace blink