Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

third_party/WebKit/Source/modules/cachestorage/CacheTest.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/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 107 matching lines @@
   }
   void setExpectedQueryParams(const QueryParams* expectedQueryParams) {
     m_expectedQueryParams = expectedQueryParams;
   }
   void setExpectedBatchOperations(
       const WebVector<BatchOperation>* expectedBatchOperations) {
     m_expectedBatchOperations = expectedBatchOperations;
   }
 
   // From WebServiceWorkerCache:
-  void dispatchMatch(CacheMatchCallbacks* callbacks,
+  void dispatchMatch(std::unique_ptr<CacheMatchCallbacks> callbacks,
                      const WebServiceWorkerRequest& webRequest,
                      const QueryParams& queryParams) override {
     m_lastErrorWebCacheMethodCalled = "dispatchMatch";
     checkUrlIfProvided(webRequest.url());
     checkQueryParamsIfProvided(queryParams);
 
-    std::unique_ptr<CacheMatchCallbacks> ownedCallbacks(wrapUnique(callbacks));
     return callbacks->onError(m_error);
   }
 
-  void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks,
+  void dispatchMatchAll(std::unique_ptr<CacheWithResponsesCallbacks> callbacks,
                         const WebServiceWorkerRequest& webRequest,
                         const QueryParams& queryParams) override {
     m_lastErrorWebCacheMethodCalled = "dispatchMatchAll";
     checkUrlIfProvided(webRequest.url());
     checkQueryParamsIfProvided(queryParams);
 
-    std::unique_ptr<CacheWithResponsesCallbacks> ownedCallbacks(
-        wrapUnique(callbacks));
     return callbacks->onError(m_error);
   }
 
-  void dispatchKeys(CacheWithRequestsCallbacks* callbacks,
+  void dispatchKeys(std::unique_ptr<CacheWithRequestsCallbacks> callbacks,
                     const WebServiceWorkerRequest& webRequest,
                     const QueryParams& queryParams) override {
     m_lastErrorWebCacheMethodCalled = "dispatchKeys";
     if (!webRequest.url().isEmpty()) {
       checkUrlIfProvided(webRequest.url());
       checkQueryParamsIfProvided(queryParams);
     }
 
-    std::unique_ptr<CacheWithRequestsCallbacks> ownedCallbacks(
-        wrapUnique(callbacks));
     return callbacks->onError(m_error);
   }
 
   void dispatchBatch(
-      CacheBatchCallbacks* callbacks,
+      std::unique_ptr<CacheBatchCallbacks> callbacks,
       const WebVector<BatchOperation>& batchOperations) override {
     m_lastErrorWebCacheMethodCalled = "dispatchBatch";
     checkBatchOperationsIfProvided(batchOperations);
 
-    std::unique_ptr<CacheBatchCallbacks> ownedCallbacks(wrapUnique(callbacks));
     return callbacks->onError(m_error);
   }
 
  protected:
   void checkUrlIfProvided(const KURL& url) {
     if (!m_expectedUrl)
       return;
     EXPECT_EQ(*m_expectedUrl, url);
   }
 
@@ skipping 344 matching lines @@
   EXPECT_EQ(kNotImplementedString, getRejectString(stringPutResult));
 
   // FIXME: test add & addAll.
 }
 
 class MatchTestCache : public NotImplementedErrorCache {
  public:
   MatchTestCache(WebServiceWorkerResponse& response) : m_response(response) {}
 
   // From WebServiceWorkerCache:
-  void dispatchMatch(CacheMatchCallbacks* callbacks,
+  void dispatchMatch(std::unique_ptr<CacheMatchCallbacks> callbacks,
                      const WebServiceWorkerRequest& webRequest,
                      const QueryParams& queryParams) override {
-    std::unique_ptr<CacheMatchCallbacks> ownedCallbacks(wrapUnique(callbacks));
     return callbacks->onSuccess(m_response);
   }
 
  private:
   WebServiceWorkerResponse& m_response;
 };
 
 TEST_F(CacheStorageTest, MatchResponseTest) {
   ScriptState::Scope scope(getScriptState());
   NonThrowableExceptionState exceptionState;
@@ skipping 16 matching lines @@
       V8Response::toImplWithTypeCheck(isolate(), scriptValue.v8Value());
   ASSERT_TRUE(response);
   EXPECT_EQ(responseUrl, response->url());
 }
 
 class KeysTestCache : public NotImplementedErrorCache {
  public:
   KeysTestCache(WebVector<WebServiceWorkerRequest>& requests)
       : m_requests(requests) {}
 
-  void dispatchKeys(CacheWithRequestsCallbacks* callbacks,
+  void dispatchKeys(std::unique_ptr<CacheWithRequestsCallbacks> callbacks,
                     const WebServiceWorkerRequest& webRequest,
                     const QueryParams& queryParams) override {
-    std::unique_ptr<CacheWithRequestsCallbacks> ownedCallbacks(
-        wrapUnique(callbacks));
     return callbacks->onSuccess(m_requests);
   }
 
  private:
   WebVector<WebServiceWorkerRequest>& m_requests;
 };
 
 TEST_F(CacheStorageTest, KeysResponseTest) {
   ScriptState::Scope scope(getScriptState());
   NonThrowableExceptionState exceptionState;
@@ skipping 25 matching lines @@
     if (request)
       EXPECT_EQ(expectedUrls[i], request->url());
   }
 }
 
 class MatchAllAndBatchTestCache : public NotImplementedErrorCache {
  public:
   MatchAllAndBatchTestCache(WebVector<WebServiceWorkerResponse>& responses)
       : m_responses(responses) {}
 
-  void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks,
+  void dispatchMatchAll(std::unique_ptr<CacheWithResponsesCallbacks> callbacks,
                         const WebServiceWorkerRequest& webRequest,
                         const QueryParams& queryParams) override {
-    std::unique_ptr<CacheWithResponsesCallbacks> ownedCallbacks(
-        wrapUnique(callbacks));
     return callbacks->onSuccess(m_responses);
   }
 
   void dispatchBatch(
-      CacheBatchCallbacks* callbacks,
+      std::unique_ptr<CacheBatchCallbacks> callbacks,
       const WebVector<BatchOperation>& batchOperations) override {
-    std::unique_ptr<CacheBatchCallbacks> ownedCallbacks(wrapUnique(callbacks));
     return callbacks->onSuccess();
   }
 
  private:
   WebVector<WebServiceWorkerResponse>& m_responses;
 };
 
 TEST_F(CacheStorageTest, MatchAllAndBatchResponseTest) {
   ScriptState::Scope scope(getScriptState());
   NonThrowableExceptionState exceptionState;
@@ skipping 79 matching lines @@
 
   EXPECT_EQ(kNotImplementedString, getRejectString(addResult));
   EXPECT_EQ(1, fetcher->fetchCount());
   EXPECT_EQ("dispatchBatch",
             testCache->getAndClearLastErrorWebCacheMethodCalled());
 }
 
 }  // namespace
 
 }  // namespace blink