CallbackPromiseAdapter types should be more compatible with WebCallbacks (2/3).

content/renderer/cache_storage/cache_storage_dispatcher.cc

 // 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 "content/renderer/cache_storage/cache_storage_dispatcher.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 118 matching lines @@
   typename T::iterator iter(callbacks_map);
   while (!iter.IsAtEnd()) {
     iter.GetCurrentValue()->onError(
         new blink::WebServiceWorkerCacheError(
             blink::WebServiceWorkerCacheErrorNotFound));
     callbacks_map->Remove(iter.GetCurrentKey());
     iter.Advance();
   }
 }
 
+template <typename T>
+void ClearCallbacksMapWithErrorsNonPtr(T* callbacks_map) {
+  typename T::iterator iter(callbacks_map);
+  while (!iter.IsAtEnd()) {
+    iter.GetCurrentValue()->onError(blink::WebServiceWorkerCacheError(
+        blink::WebServiceWorkerCacheErrorNotFound));
+    callbacks_map->Remove(iter.GetCurrentKey());
+    iter.Advance();
+  }
+}
+
 }  // namespace
 
 // The WebCache object is the Chromium side implementation of the Blink
 // WebServiceWorkerCache API. Most of its methods delegate directly to the
 // ServiceWorkerStorage object, which is able to assign unique IDs as well
 // as have a lifetime longer than the requests.
 class CacheStorageDispatcher::WebCache : public blink::WebServiceWorkerCache {
  public:
   WebCache(base::WeakPtr<CacheStorageDispatcher> dispatcher, int cache_id)
       : dispatcher_(dispatcher), cache_id_(cache_id) {}
@@ skipping 50 matching lines @@
 CacheStorageDispatcher::~CacheStorageDispatcher() {
   ClearCallbacksMapWithErrors(&has_callbacks_);
   ClearCallbacksMapWithErrors(&open_callbacks_);
   ClearCallbacksMapWithErrors(&delete_callbacks_);
   ClearCallbacksMapWithErrors(&keys_callbacks_);
   ClearCallbacksMapWithErrors(&match_callbacks_);
 
   ClearCallbacksMapWithErrors(&cache_match_callbacks_);
   ClearCallbacksMapWithErrors(&cache_match_all_callbacks_);
   ClearCallbacksMapWithErrors(&cache_keys_callbacks_);
-  ClearCallbacksMapWithErrors(&cache_batch_callbacks_);
+  ClearCallbacksMapWithErrorsNonPtr(&cache_batch_callbacks_);
 
   g_cache_storage_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
 }
 
 CacheStorageDispatcher* CacheStorageDispatcher::ThreadSpecificInstance(
     ThreadSafeSender* thread_safe_sender) {
   if (g_cache_storage_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS CacheStorageDispatcher.";
     g_cache_storage_dispatcher_tls.Pointer()->Set(NULL);
   }
@@ skipping 291 matching lines @@
   cache_keys_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheBatchError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebServiceWorkerCache::CacheBatchCallbacks* callbacks =
       cache_batch_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(blink::WebServiceWorkerCacheError(reason));
   cache_batch_callbacks_.Remove(request_id);
   cache_batch_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::dispatchHas(
     WebServiceWorkerCacheStorage::CacheStorageCallbacks* callbacks,
     const GURL& origin,
     const blink::WebString& cacheName) {
   int request_id = has_callbacks_.Add(callbacks);
   has_times_[request_id] = base::TimeTicks::Now();
@@ skipping 135 matching lines @@
 CacheStorageDispatcher::WebResponsesFromResponses(
     const std::vector<ServiceWorkerResponse>& responses) {
   blink::WebVector<blink::WebServiceWorkerResponse> web_responses(
       responses.size());
   for (size_t i = 0; i < responses.size(); ++i)
     PopulateWebResponseFromResponse(responses[i], &(web_responses[i]));
   return web_responses;
 }
 
 }  // namespace content