CacheStorage: Pass an error object allocated on heap to WebCallbacks::onError (1)

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 108 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()) {
+#ifdef CRBUG_494884
+    iter.GetCurrentValue()->onError(
+        new blink::WebServiceWorkerCacheError(
+            blink::WebServiceWorkerCacheErrorNotFound));
+#else
     blink::WebServiceWorkerCacheError reason =
         blink::WebServiceWorkerCacheErrorNotFound;
     iter.GetCurrentValue()->onError(&reason);
+#endif
     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
@@ skipping 206 matching lines @@
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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;
@@ skipping 56 matching lines @@
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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 =
       cache_batch_callbacks_.Lookup(request_id);
+#ifdef CRBUG_494884
+  callbacks->onError(new blink::WebServiceWorkerCacheError(reason));
+#else
   callbacks->onError(&reason);
+#endif
   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