[CacheStorage] Use appopriate type parameters for 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 110 matching lines @@
   operation.response = ResponseFromWebResponse(web_operation.response);
   operation.match_params =
       QueryParamsFromWebQueryParams(web_operation.matchParams);
   return operation;
 }
 
 template <typename T>
 void ClearCallbacksMapWithErrors(T* callbacks_map) {
   typename T::iterator iter(callbacks_map);
   while (!iter.IsAtEnd()) {
-    iter.GetCurrentValue()->onError(
-        new blink::WebServiceWorkerCacheError(
-            blink::WebServiceWorkerCacheErrorNotFound));
+    iter.GetCurrentValue()->onError(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:
@@ skipping 52 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_);
-  ClearCallbacksMapWithErrorsNonPtr(&cache_batch_callbacks_);
+  ClearCallbacksMapWithErrors(&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 65 matching lines @@
       has_callbacks_.Lookup(request_id);
   callbacks->onSuccess();
   has_callbacks_.Remove(request_id);
   has_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageOpenSuccess(int thread_id,
                                                        int request_id,
                                                        int cache_id) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
-  WebCache* web_cache = new WebCache(weak_factory_.GetWeakPtr(), cache_id);
-  web_caches_.AddWithID(web_cache, cache_id);
+  scoped_ptr<WebCache> web_cache(
+      new WebCache(weak_factory_.GetWeakPtr(), cache_id));
+  web_caches_.AddWithID(web_cache.get(), cache_id);
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.CacheStorage.Open",
                       TimeTicks::Now() - open_times_[request_id]);
   WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks* callbacks =
       open_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(web_cache);
+  callbacks->onSuccess(blink::adoptWebPtr(web_cache.release()));
   open_callbacks_.Remove(request_id);
   open_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageDeleteSuccess(int thread_id,
                                                          int request_id) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.CacheStorage.Delete",
                       TimeTicks::Now() - delete_times_[request_id]);
   WebServiceWorkerCacheStorage::CacheStorageCallbacks* callbacks =
       delete_callbacks_.Lookup(request_id);
   callbacks->onSuccess();
   delete_callbacks_.Remove(request_id);
   delete_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageKeysSuccess(
     int thread_id,
     int request_id,
     const std::vector<base::string16>& keys) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebVector<blink::WebString> webKeys(keys.size());
   for (size_t i = 0; i < keys.size(); ++i)
     webKeys[i] = keys[i];
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.CacheStorage.Keys",
                       TimeTicks::Now() - keys_times_[request_id]);
   WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks* callbacks =
       keys_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(&webKeys);
+  callbacks->onSuccess(webKeys);
   keys_callbacks_.Remove(request_id);
   keys_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageMatchSuccess(
     int thread_id,
     int request_id,
     const ServiceWorkerResponse& response) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebServiceWorkerResponse web_response;
   PopulateWebResponseFromResponse(response, &web_response);
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.CacheStorage.Match",
                       TimeTicks::Now() - match_times_[request_id]);
   WebServiceWorkerCacheStorage::CacheStorageMatchCallbacks* callbacks =
       match_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(&web_response);
+  callbacks->onSuccess(web_response);
   match_callbacks_.Remove(request_id);
   match_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageHasError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebServiceWorkerCacheStorage::CacheStorageCallbacks* callbacks =
       has_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   has_callbacks_.Remove(request_id);
   has_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageOpenError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks* callbacks =
       open_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   open_callbacks_.Remove(request_id);
   open_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageDeleteError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebServiceWorkerCacheStorage::CacheStorageCallbacks* callbacks =
       delete_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   delete_callbacks_.Remove(request_id);
   delete_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageKeysError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks* callbacks =
       keys_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   keys_callbacks_.Remove(request_id);
   keys_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageMatchError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebServiceWorkerCacheStorage::CacheStorageMatchCallbacks* callbacks =
       match_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   match_callbacks_.Remove(request_id);
   match_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheMatchSuccess(
     int thread_id,
     int request_id,
     const ServiceWorkerResponse& response) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebServiceWorkerResponse web_response;
   PopulateWebResponseFromResponse(response, &web_response);
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.Cache.Match",
                       TimeTicks::Now() - cache_match_times_[request_id]);
   blink::WebServiceWorkerCache::CacheMatchCallbacks* callbacks =
       cache_match_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(&web_response);
+  callbacks->onSuccess(web_response);
   cache_match_callbacks_.Remove(request_id);
   cache_match_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheMatchAllSuccess(
     int thread_id,
     int request_id,
     const std::vector<ServiceWorkerResponse>& responses) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
-  blink::WebVector<blink::WebServiceWorkerResponse> web_responses =
-      WebResponsesFromResponses(responses);
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.Cache.MatchAll",
                       TimeTicks::Now() - cache_match_all_times_[request_id]);
   blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks =
       cache_match_all_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(&web_responses);
+  callbacks->onSuccess(WebResponsesFromResponses(responses));
   cache_match_all_callbacks_.Remove(request_id);
   cache_match_all_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheKeysSuccess(
     int thread_id,
     int request_id,
     const std::vector<ServiceWorkerFetchRequest>& requests) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
-  blink::WebVector<blink::WebServiceWorkerRequest> web_requests =
-      WebRequestsFromRequests(requests);
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.Cache.Keys",
                       TimeTicks::Now() - cache_keys_times_[request_id]);
   blink::WebServiceWorkerCache::CacheWithRequestsCallbacks* callbacks =
       cache_keys_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(&web_requests);
+  callbacks->onSuccess(WebRequestsFromRequests(requests));
   cache_keys_callbacks_.Remove(request_id);
   cache_keys_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheBatchSuccess(
     int thread_id,
     int request_id) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.Cache.Batch",
                       TimeTicks::Now() - cache_batch_times_[request_id]);
   blink::WebServiceWorkerCache::CacheBatchCallbacks* callbacks =
       cache_batch_callbacks_.Lookup(request_id);
   callbacks->onSuccess();
   cache_batch_callbacks_.Remove(request_id);
   cache_batch_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheMatchError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebServiceWorkerCache::CacheMatchCallbacks* callbacks =
       cache_match_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   cache_match_callbacks_.Remove(request_id);
   cache_match_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheMatchAllError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks =
       cache_match_all_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   cache_match_all_callbacks_.Remove(request_id);
   cache_match_all_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheKeysError(
     int thread_id,
     int request_id,
     blink::WebServiceWorkerCacheError reason) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   blink::WebServiceWorkerCache::CacheWithRequestsCallbacks* callbacks =
       cache_keys_callbacks_.Lookup(request_id);
-  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+  callbacks->onError(reason);
   cache_keys_callbacks_.Remove(request_id);
   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 =
@@ skipping 147 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