[Storage] Blob Storage Refactoring pt 1

content/browser/service_worker/service_worker_cache_storage.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/browser/service_worker/service_worker_cache_storage.h"
 
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
@@ skipping 498 matching lines @@
                         weak_factory_.GetWeakPtr(), cache_name,
                         base::Passed(request.Pass()), callback));
     return;
   }
 
   scoped_refptr<ServiceWorkerCache> cache = GetLoadedCache(cache_name);
 
   if (!cache.get()) {
     callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
                  scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
+                 scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   // Pass the cache along to the callback to keep the cache open until match is
   // done.
   cache->Match(request.Pass(),
                base::Bind(&ServiceWorkerCacheStorage::MatchCacheDidMatch,
                           weak_factory_.GetWeakPtr(), cache, callback));
 }
 
@@ skipping 189 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(true, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::MatchCacheDidMatch(
     const scoped_refptr<ServiceWorkerCache>& cache,
     const ServiceWorkerCache::ResponseCallback& callback,
     ServiceWorkerCache::ErrorType error,
     scoped_ptr<ServiceWorkerResponse> response,
-    scoped_ptr<storage::BlobDataHandle> handle) {
+    scoped_ptr<storage::BlobDataSnapshotHandle> handle) {
   callback.Run(error, response.Pass(), handle.Pass());
 }
 
 void ServiceWorkerCacheStorage::MatchAllCachesDidMatch(
     scoped_refptr<ServiceWorkerCache> cache,
     const base::Closure& barrier_closure,
     ServiceWorkerCache::ResponseCallback* callback,
     ServiceWorkerCache::ErrorType error,
     scoped_ptr<ServiceWorkerResponse> response,
-    scoped_ptr<storage::BlobDataHandle> handle) {
+    scoped_ptr<storage::BlobDataSnapshotHandle> handle) {
   if (callback->is_null() || error == ServiceWorkerCache::ErrorTypeNotFound) {
     barrier_closure.Run();
     return;
   }
   callback->Run(error, response.Pass(), handle.Pass());
   callback->Reset();  // Only call the callback once.
 
   barrier_closure.Run();
 }
 
 void ServiceWorkerCacheStorage::MatchAllCachesDidMatchAll(
     scoped_ptr<ServiceWorkerCache::ResponseCallback> callback) {
   if (!callback->is_null()) {
     callback->Run(ServiceWorkerCache::ErrorTypeNotFound,
                   scoped_ptr<ServiceWorkerResponse>(),
-                  scoped_ptr<storage::BlobDataHandle>());
+                  scoped_ptr<storage::BlobDataSnapshotHandle>());
   }
 }
 
 scoped_refptr<ServiceWorkerCache> ServiceWorkerCacheStorage::GetLoadedCache(
     const std::string& cache_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
   CacheMap::iterator map_iter = cache_map_.find(cache_name);
   if (map_iter == cache_map_.end())
     return scoped_refptr<ServiceWorkerCache>();
 
   base::WeakPtr<ServiceWorkerCache> cache = map_iter->second;
 
   if (!cache) {
     scoped_refptr<ServiceWorkerCache> new_cache =
         cache_loader_->CreateServiceWorkerCache(cache_name);
     map_iter->second = new_cache->AsWeakPtr();
     return new_cache;
   }
 
   return make_scoped_refptr(cache.get());
 }
 
 }  // namespace content