Service Workers: Allow empty string as cache name

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/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 387 matching lines @@
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::CreateCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  if (cache_name.empty()) {
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_EMPTY_KEY);
-    return;
-  }
-
   if (GetLoadedCache(cache_name)) {
     callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_EXISTS);
     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;
   }
 
-  if (cache_name.empty()) {
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_EMPTY_KEY);
-    return;
-  }
-
   CacheContext* cache_context = GetLoadedCache(cache_name);
   if (!cache_context) {
     callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   ServiceWorkerCache* cache = cache_context->cache.get();
 
   if (cache->HasCreatedBackend())
     return callback.Run(cache_context->id, CACHE_STORAGE_ERROR_NO_ERROR);
@@ skipping 10 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::HasCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  if (cache_name.empty()) {
-    callback.Run(false, CACHE_STORAGE_ERROR_EMPTY_KEY);
-    return;
-  }
-
   bool has_cache = GetLoadedCache(cache_name) != NULL;
 
   callback.Run(has_cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DeleteCache(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::DeleteCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  if (cache_name.empty()) {
-    callback.Run(false, CACHE_STORAGE_ERROR_EMPTY_KEY);
-    return;
-  }
-
   scoped_ptr<CacheContext> cache_context(GetLoadedCache(cache_name));
   if (!cache_context) {
     callback.Run(false, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   name_map_.erase(cache_name);
   cache_map_.erase(cache_context->id);
   cache_context.reset();
 
@@ skipping 212 matching lines @@
   NameMap::const_iterator name_iter = name_map_.find(cache_name);
   if (name_iter == name_map_.end())
     return NULL;
 
   CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
   DCHECK(map_iter != cache_map_.end());
   return map_iter->second;
 }
 
 }  // namespace content