[ServiceWorkerCacheStorage] Delete unused get/create functions.

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/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 333 matching lines @@
     cache_loader_.reset(new MemoryLoader(
         cache_task_runner_.get(), request_context, blob_context));
   else
     cache_loader_.reset(new SimpleCacheLoader(
         origin_path_, cache_task_runner_.get(), request_context, blob_context));
 }
 
 ServiceWorkerCacheStorage::~ServiceWorkerCacheStorage() {
 }
 
-void ServiceWorkerCacheStorage::CreateCache(
-    const std::string& cache_name,
-    const CacheAndErrorCallback& callback) {
-  if (!initialized_) {
-    LazyInit(base::Bind(&ServiceWorkerCacheStorage::CreateCache,
-                        weak_factory_.GetWeakPtr(),
-                        cache_name,
-                        callback));
-    return;
-  }
-
-  if (cache_map_.find(cache_name) != cache_map_.end()) {
-    callback.Run(scoped_refptr<ServiceWorkerCache>(),
-                 CACHE_STORAGE_ERROR_EXISTS);
-    return;
-  }
-
-  cache_loader_->CreateCache(
-      cache_name,
-      base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidCreateCache,
-                 weak_factory_.GetWeakPtr(),
-                 cache_name,
-                 callback));
-}
-
 void ServiceWorkerCacheStorage::OpenCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::OpenCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
   scoped_refptr<ServiceWorkerCache> cache = GetLoadedCache(cache_name);
   if (cache.get()) {
     callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
     return;
   }
 
   cache_loader_->CreateCache(
       cache_name,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidCreateCache,
                  weak_factory_.GetWeakPtr(),
                  cache_name,
                  callback));
 }
 
-void ServiceWorkerCacheStorage::GetCache(
-    const std::string& cache_name,
-    const CacheAndErrorCallback& callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (!initialized_) {
-    LazyInit(base::Bind(&ServiceWorkerCacheStorage::GetCache,
-                        weak_factory_.GetWeakPtr(),
-                        cache_name,
-                        callback));
-    return;
-  }
-
-  scoped_refptr<ServiceWorkerCache> cache = GetLoadedCache(cache_name);
-  if (!cache.get()) {
-    callback.Run(scoped_refptr<ServiceWorkerCache>(),
-                 CACHE_STORAGE_ERROR_NOT_FOUND);
-    return;
-  }
-
-  callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
-}
-
 void ServiceWorkerCacheStorage::HasCache(const std::string& cache_name,
                                          const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::HasCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
@@ skipping 174 matching lines @@
     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