Use string16 for cache_name in the back end of CacheStorage.

content/browser/cache_storage/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/cache_storage/cache_storage.h"
 
 #include <stddef.h>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sha1.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
@@ skipping 28 matching lines @@
 }  // namespace
 
 const char CacheStorage::kIndexFileName[] = "index.txt";
 
 // Handles the loading and clean up of CacheStorageCache objects.
 class CacheStorage::CacheLoader {
  public:
   typedef base::Callback<void(const scoped_refptr<CacheStorageCache>&)>
       CacheCallback;
   typedef base::Callback<void(bool)> BoolCallback;
-  typedef base::Callback<void(scoped_ptr<std::vector<std::string>>)>
+  typedef base::Callback<void(scoped_ptr<std::vector<base::string16>>)>
       StringVectorCallback;
 
   CacheLoader(
       base::SequencedTaskRunner* cache_task_runner,
       const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin)
       : cache_task_runner_(cache_task_runner),
         request_context_getter_(request_context_getter),
         quota_manager_proxy_(quota_manager_proxy),
         blob_context_(blob_context),
         origin_(origin) {
     DCHECK(!origin_.is_empty());
   }
 
   virtual ~CacheLoader() {}
 
   // Creates a CacheStorageCache with the given name. It does not attempt to
   // load the backend, that happens lazily when the cache is used.
   virtual scoped_refptr<CacheStorageCache> CreateCache(
-      const std::string& cache_name) = 0;
+      const base::string16& cache_name) = 0;
 
   // Deletes any pre-existing cache of the same name and then loads it.
-  virtual void PrepareNewCacheDestination(const std::string& cache_name,
+  virtual void PrepareNewCacheDestination(const base::string16& cache_name,
                                           const CacheCallback& callback) = 0;
 
   // After the backend has been deleted, do any extra house keeping such as
   // removing the cache's directory.
-  virtual void CleanUpDeletedCache(const std::string& key,
+  virtual void CleanUpDeletedCache(const base::string16& cache_name,
                                    const BoolCallback& callback) = 0;
 
   // Writes the cache names (and sizes) to disk if applicable.
   virtual void WriteIndex(const StringVector& cache_names,
                           const BoolCallback& callback) = 0;
 
   // Loads the cache names from disk if applicable.
-  virtual void LoadIndex(scoped_ptr<std::vector<std::string>> cache_names,
+  virtual void LoadIndex(scoped_ptr<std::vector<base::string16>> cache_names,
                          const StringVectorCallback& callback) = 0;
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
   GURL origin_;
 };
 
 // Creates memory-only ServiceWorkerCaches. Because these caches have no
 // persistent storage it is not safe to free them from memory if they might be
 // used again. Therefore this class holds a reference to each cache until the
 // cache is deleted.
 class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
  public:
   MemoryLoader(
       base::SequencedTaskRunner* cache_task_runner,
       const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin)
       : CacheLoader(cache_task_runner,
                     request_context,
                     quota_manager_proxy,
                     blob_context,
                     origin) {}
 
   scoped_refptr<CacheStorageCache> CreateCache(
-      const std::string& cache_name) override {
+      const base::string16& cache_name) override {
     return CacheStorageCache::CreateMemoryCache(
         origin_, request_context_getter_, quota_manager_proxy_, blob_context_);
   }
 
-  void PrepareNewCacheDestination(const std::string& cache_name,
+  void PrepareNewCacheDestination(const base::string16& cache_name,
                                   const CacheCallback& callback) override {
     scoped_refptr<CacheStorageCache> cache = CreateCache(cache_name);
     cache_refs_.insert(std::make_pair(cache_name, cache));
     callback.Run(cache);
   }
 
-  void CleanUpDeletedCache(const std::string& cache_name,
+  void CleanUpDeletedCache(const base::string16& cache_name,
                            const BoolCallback& callback) override {
     CacheRefMap::iterator it = cache_refs_.find(cache_name);
     DCHECK(it != cache_refs_.end());
     cache_refs_.erase(it);
     callback.Run(true);
   }
 
   void WriteIndex(const StringVector& cache_names,
                   const BoolCallback& callback) override {
     callback.Run(false);
   }
 
-  void LoadIndex(scoped_ptr<std::vector<std::string>> cache_names,
+  void LoadIndex(scoped_ptr<std::vector<base::string16>> cache_names,
                  const StringVectorCallback& callback) override {
     callback.Run(std::move(cache_names));
   }
 
  private:
-  typedef std::map<std::string, scoped_refptr<CacheStorageCache>> CacheRefMap;
+  typedef std::map<base::string16, scoped_refptr<CacheStorageCache>>
+      CacheRefMap;
   ~MemoryLoader() override {}
 
   // Keep a reference to each cache to ensure that it's not freed before the
   // client calls CacheStorage::Delete or the CacheStorage is
   // freed.
   CacheRefMap cache_refs_;
 };
 
 class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
  public:
   SimpleCacheLoader(
       const base::FilePath& origin_path,
       base::SequencedTaskRunner* cache_task_runner,
       const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin)
       : CacheLoader(cache_task_runner,
                     request_context,
                     quota_manager_proxy,
                     blob_context,
                     origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
   scoped_refptr<CacheStorageCache> CreateCache(
-      const std::string& cache_name) override {
+      const base::string16& cache_name) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(ContainsKey(cache_name_to_cache_dir_, cache_name));
 
     std::string cache_dir = cache_name_to_cache_dir_[cache_name];
     base::FilePath cache_path = origin_path_.AppendASCII(cache_dir);
     return CacheStorageCache::CreatePersistentCache(
         origin_, cache_path, request_context_getter_, quota_manager_proxy_,
         blob_context_);
   }
 
-  void PrepareNewCacheDestination(const std::string& cache_name,
+  void PrepareNewCacheDestination(const base::string16& cache_name,
                                   const CacheCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     PostTaskAndReplyWithResult(
         cache_task_runner_.get(), FROM_HERE,
         base::Bind(&SimpleCacheLoader::PrepareNewCacheDirectoryInPool,
                    origin_path_),
         base::Bind(&SimpleCacheLoader::PrepareNewCacheCreateCache,
                    weak_ptr_factory_.GetWeakPtr(), cache_name, callback));
   }
 
   // Runs on the cache_task_runner_.
   static std::string PrepareNewCacheDirectoryInPool(
       const base::FilePath& origin_path) {
     std::string cache_dir;
     base::FilePath cache_path;
     do {
       cache_dir = base::GenerateGUID();
       cache_path = origin_path.AppendASCII(cache_dir);
     } while (base::PathExists(cache_path));
 
     return base::CreateDirectory(cache_path) ? cache_dir : "";
   }
 
-  void PrepareNewCacheCreateCache(const std::string& cache_name,
+  void PrepareNewCacheCreateCache(const base::string16& cache_name,
                                   const CacheCallback& callback,
                                   const std::string& cache_dir) {
     if (cache_dir.empty()) {
       callback.Run(scoped_refptr<CacheStorageCache>());
       return;
     }
 
     cache_name_to_cache_dir_[cache_name] = cache_dir;
     callback.Run(CreateCache(cache_name));
   }
 
-  void CleanUpDeletedCache(const std::string& cache_name,
+  void CleanUpDeletedCache(const base::string16& cache_name,
                            const BoolCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(ContainsKey(cache_name_to_cache_dir_, cache_name));
 
     base::FilePath cache_path =
         origin_path_.AppendASCII(cache_name_to_cache_dir_[cache_name]);
     cache_name_to_cache_dir_.erase(cache_name);
 
     cache_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 16 matching lines @@
     // 1. Create the index file as a string. (WriteIndex)
     // 2. Write the file to disk. (WriteIndexWriteToFileInPool)
 
     CacheStorageIndex index;
     index.set_origin(origin_.spec());
 
     for (size_t i = 0u, max = cache_names.size(); i < max; ++i) {
       DCHECK(ContainsKey(cache_name_to_cache_dir_, cache_names[i]));
 
       CacheStorageIndex::Cache* index_cache = index.add_cache();
-      index_cache->set_name(cache_names[i]);
+      // We use |name_utf16| to store the cache name. But we set |name| here for
+      // forward compatibility.
+      // TODO(horo): Stop setting |name| when M51 becomes stable.
+      index_cache->set_name(base::UTF16ToUTF8(cache_names[i]));
       index_cache->set_cache_dir(cache_name_to_cache_dir_[cache_names[i]]);
+      index_cache->set_name_utf16(
+          cache_names[i].data(),
+          cache_names[i].length() * sizeof(base::char16));
     }
 
     std::string serialized;
     bool success = index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
     base::FilePath index_path =
         origin_path_.AppendASCII(CacheStorage::kIndexFileName);
 
@@ skipping 13 matching lines @@
     if (bytes_written != base::checked_cast<int>(data.size())) {
       base::DeleteFile(tmp_path, /* recursive */ false);
       original_task_runner->PostTask(FROM_HERE, base::Bind(callback, false));
     }
 
     // Atomically rename the temporary index file to become the real one.
     bool rv = base::ReplaceFile(tmp_path, index_path, NULL);
     original_task_runner->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
-  void LoadIndex(scoped_ptr<std::vector<std::string>> names,
+  void LoadIndex(scoped_ptr<std::vector<base::string16>> names,
                  const StringVectorCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Read the file from disk. (LoadIndexReadFileInPool)
     // 2. Parse file and return the names of the caches (LoadIndexDidReadFile)
 
     base::FilePath index_path =
         origin_path_.AppendASCII(CacheStorage::kIndexFileName);
 
     PostTaskAndReplyWithResult(
         cache_task_runner_.get(), FROM_HERE,
         base::Bind(&SimpleCacheLoader::ReadAndMigrateIndexInPool, index_path),
         base::Bind(&SimpleCacheLoader::LoadIndexDidReadFile,
                    weak_ptr_factory_.GetWeakPtr(), base::Passed(&names),
                    callback));
   }
 
-  void LoadIndexDidReadFile(scoped_ptr<std::vector<std::string>> names,
+  void LoadIndexDidReadFile(scoped_ptr<std::vector<base::string16>> names,
                             const StringVectorCallback& callback,
                             const std::string& serialized) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     scoped_ptr<std::set<std::string>> cache_dirs(new std::set<std::string>);
 
     CacheStorageIndex index;
     if (index.ParseFromString(serialized)) {
       for (int i = 0, max = index.cache_size(); i < max; ++i) {
         const CacheStorageIndex::Cache& cache = index.cache(i);
         DCHECK(cache.has_cache_dir());
-        names->push_back(cache.name());
-        cache_name_to_cache_dir_[cache.name()] = cache.cache_dir();
+        // After M51 we use |name_utf16| instead of |name|. We check |name|
+        // first for backward compatibility.
+        base::string16 cache_name(base::UTF8ToUTF16(cache.name()));
+        if (cache.has_name_utf16()) {
+          cache_name = base::string16(
+              reinterpret_cast<const base::char16*>(cache.name_utf16().data()),
+              cache.name_utf16().size() / sizeof(base::char16));
+        }
+        names->push_back(cache_name);
+        cache_name_to_cache_dir_[cache_name] = cache.cache_dir();
         cache_dirs->insert(cache.cache_dir());
       }
     }
 
     cache_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DeleteUnreferencedCachesInPool, origin_path_,
                               base::Passed(&cache_dirs)));
     callback.Run(std::move(names));
   }
 
@@ skipping 74 matching lines @@
   // Runs on cache_task_runner_
   static std::string ReadAndMigrateIndexInPool(
       const base::FilePath& index_path) {
     std::string body;
     base::ReadFileToString(index_path, &body);
 
     return MigrateCachesIfNecessaryInPool(body, index_path);
   }
 
   const base::FilePath origin_path_;
-  std::map<std::string, std::string> cache_name_to_cache_dir_;
+  std::map<base::string16, std::string> cache_name_to_cache_dir_;
 
   base::WeakPtrFactory<SimpleCacheLoader> weak_ptr_factory_;
 };
 
 CacheStorage::CacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
@@ skipping 14 matching lines @@
                                          blob_context, origin));
   else
     cache_loader_.reset(new SimpleCacheLoader(
         origin_path_, cache_task_runner_.get(), request_context,
         quota_manager_proxy, blob_context, origin));
 }
 
 CacheStorage::~CacheStorage() {
 }
 
-void CacheStorage::OpenCache(const std::string& cache_name,
+void CacheStorage::OpenCache(const base::string16& cache_name,
                              const CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   CacheAndErrorCallback pending_callback =
       base::Bind(&CacheStorage::PendingCacheAndErrorCallback,
                  weak_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorage::OpenCacheImpl,
                                            weak_factory_.GetWeakPtr(),
                                            cache_name, pending_callback));
 }
 
-void CacheStorage::HasCache(const std::string& cache_name,
+void CacheStorage::HasCache(const base::string16& cache_name,
                             const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   BoolAndErrorCallback pending_callback =
       base::Bind(&CacheStorage::PendingBoolAndErrorCallback,
                  weak_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorage::HasCacheImpl,
                                            weak_factory_.GetWeakPtr(),
                                            cache_name, pending_callback));
 }
 
-void CacheStorage::DeleteCache(const std::string& cache_name,
+void CacheStorage::DeleteCache(const base::string16& cache_name,
                                const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   BoolAndErrorCallback pending_callback =
       base::Bind(&CacheStorage::PendingBoolAndErrorCallback,
                  weak_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorage::DeleteCacheImpl,
                                            weak_factory_.GetWeakPtr(),
                                            cache_name, pending_callback));
 }
 
 void CacheStorage::EnumerateCaches(const StringsAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   StringsAndErrorCallback pending_callback =
       base::Bind(&CacheStorage::PendingStringsAndErrorCallback,
                  weak_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorage::EnumerateCachesImpl,
                                            weak_factory_.GetWeakPtr(),
                                            pending_callback));
 }
 
 void CacheStorage::MatchCache(
-    const std::string& cache_name,
+    const base::string16& cache_name,
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   CacheStorageCache::ResponseCallback pending_callback =
       base::Bind(&CacheStorage::PendingResponseCallback,
                  weak_factory_.GetWeakPtr(), callback);
@@ skipping 71 matching lines @@
 void CacheStorage::LazyInitImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!initialized_);
   DCHECK(initializing_);
 
   // 1. Get the list of cache names (async call)
   // 2. For each cache name, load the cache (async call)
   // 3. Once each load is complete, update the map variables.
   // 4. Call the list of waiting callbacks.
 
-  scoped_ptr<std::vector<std::string>> indexed_cache_names(
-      new std::vector<std::string>());
+  scoped_ptr<std::vector<base::string16>> indexed_cache_names(
+      new std::vector<base::string16>());
 
   cache_loader_->LoadIndex(std::move(indexed_cache_names),
                            base::Bind(&CacheStorage::LazyInitDidLoadIndex,
                                       weak_factory_.GetWeakPtr()));
 }
 
 void CacheStorage::LazyInitDidLoadIndex(
-    scoped_ptr<std::vector<std::string>> indexed_cache_names) {
+    scoped_ptr<std::vector<base::string16>> indexed_cache_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (size_t i = 0u, max = indexed_cache_names->size(); i < max; ++i) {
     cache_map_.insert(std::make_pair(indexed_cache_names->at(i),
                                      base::WeakPtr<CacheStorageCache>()));
     ordered_cache_names_.push_back(indexed_cache_names->at(i));
   }
 
   initializing_ = false;
   initialized_ = true;
 
   scheduler_->CompleteOperationAndRunNext();
 }
 
-void CacheStorage::OpenCacheImpl(const std::string& cache_name,
+void CacheStorage::OpenCacheImpl(const base::string16& cache_name,
                                  const CacheAndErrorCallback& callback) {
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
   if (cache.get()) {
     callback.Run(cache, CACHE_STORAGE_OK);
     return;
   }
 
   cache_loader_->PrepareNewCacheDestination(
       cache_name, base::Bind(&CacheStorage::CreateCacheDidCreateCache,
                              weak_factory_.GetWeakPtr(), cache_name, callback));
 }
 
 void CacheStorage::CreateCacheDidCreateCache(
-    const std::string& cache_name,
+    const base::string16& cache_name,
     const CacheAndErrorCallback& callback,
     const scoped_refptr<CacheStorageCache>& cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   UMA_HISTOGRAM_BOOLEAN("ServiceWorkerCache.CreateCacheStorageResult",
                         cache != nullptr);
 
   if (!cache.get()) {
     callback.Run(scoped_refptr<CacheStorageCache>(),
                  CACHE_STORAGE_ERROR_STORAGE);
@@ skipping 16 matching lines @@
     const scoped_refptr<CacheStorageCache>& cache,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache.get());
 
   // TODO(jkarlin): Handle !success.
 
   callback.Run(cache, CACHE_STORAGE_OK);
 }
 
-void CacheStorage::HasCacheImpl(const std::string& cache_name,
+void CacheStorage::HasCacheImpl(const base::string16& cache_name,
                                 const BoolAndErrorCallback& callback) {
   bool has_cache = ContainsKey(cache_map_, cache_name);
   callback.Run(has_cache, CACHE_STORAGE_OK);
 }
 
-void CacheStorage::DeleteCacheImpl(const std::string& cache_name,
+void CacheStorage::DeleteCacheImpl(const base::string16& cache_name,
                                    const BoolAndErrorCallback& callback) {
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
   if (!cache.get()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, false, CACHE_STORAGE_ERROR_NOT_FOUND));
     return;
   }
 
   CacheMap::iterator map_iter = cache_map_.find(cache_name);
   cache_map_.erase(map_iter);
 
   // Delete the name from ordered_cache_names_.
   StringVector::iterator iter = std::find(
       ordered_cache_names_.begin(), ordered_cache_names_.end(), cache_name);
   DCHECK(iter != ordered_cache_names_.end());
   ordered_cache_names_.erase(iter);
 
   cache->GetSizeThenClose(base::Bind(&CacheStorage::DeleteCacheDidClose,
                                      weak_factory_.GetWeakPtr(), cache_name,
                                      callback, ordered_cache_names_, cache));
 }
 
 void CacheStorage::DeleteCacheDidClose(
-    const std::string& cache_name,
+    const base::string16& cache_name,
     const BoolAndErrorCallback& callback,
     const StringVector& ordered_cache_names,
     const scoped_refptr<CacheStorageCache>& cache,
     int64_t cache_size) {
   cache_loader_->WriteIndex(
       ordered_cache_names,
       base::Bind(&CacheStorage::DeleteCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(), cache_name, callback, cache_size));
 }
 
 void CacheStorage::DeleteCacheDidWriteIndex(
-    const std::string& cache_name,
+    const base::string16& cache_name,
     const BoolAndErrorCallback& callback,
     int cache_size,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   quota_manager_proxy_->NotifyStorageModified(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary, -1 * cache_size);
 
   cache_loader_->CleanUpDeletedCache(
       cache_name, base::Bind(&CacheStorage::DeleteCacheDidCleanUp,
                              weak_factory_.GetWeakPtr(), callback));
 }
 
 void CacheStorage::DeleteCacheDidCleanUp(const BoolAndErrorCallback& callback,
                                          bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(true, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::EnumerateCachesImpl(
     const StringsAndErrorCallback& callback) {
   callback.Run(ordered_cache_names_, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::MatchCacheImpl(
-    const std::string& cache_name,
+    const base::string16& cache_name,
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
 
   if (!cache.get()) {
     callback.Run(CACHE_STORAGE_ERROR_CACHE_NAME_NOT_FOUND,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
@@ skipping 20 matching lines @@
   scoped_ptr<CacheStorageCache::ResponseCallback> callback_copy(
       new CacheStorageCache::ResponseCallback(callback));
 
   CacheStorageCache::ResponseCallback* callback_ptr = callback_copy.get();
   base::Closure barrier_closure =
       base::BarrierClosure(ordered_cache_names_.size(),
                            base::Bind(&CacheStorage::MatchAllCachesDidMatchAll,
                                       weak_factory_.GetWeakPtr(),
                                       base::Passed(std::move(callback_copy))));
 
-  for (const std::string& cache_name : ordered_cache_names_) {
+  for (const base::string16& cache_name : ordered_cache_names_) {
     scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
     DCHECK(cache.get());
 
     cache->Match(make_scoped_ptr(new ServiceWorkerFetchRequest(*request)),
                  base::Bind(&CacheStorage::MatchAllCachesDidMatch,
                             weak_factory_.GetWeakPtr(), cache, barrier_closure,
                             callback_ptr));
   }
 }
 
@@ skipping 17 matching lines @@
 void CacheStorage::MatchAllCachesDidMatchAll(
     scoped_ptr<CacheStorageCache::ResponseCallback> callback) {
   if (!callback->is_null()) {
     callback->Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                   scoped_ptr<ServiceWorkerResponse>(),
                   scoped_ptr<storage::BlobDataHandle>());
   }
 }
 
 scoped_refptr<CacheStorageCache> CacheStorage::GetLoadedCache(
-    const std::string& cache_name) {
+    const base::string16& 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<CacheStorageCache>();
 
   base::WeakPtr<CacheStorageCache> cache = map_iter->second;
 
   if (!cache) {
@@ skipping 40 matching lines @@
   DCHECK(initialized_);
 
   scoped_ptr<int64_t> accumulator(new int64_t(0));
   int64_t* accumulator_ptr = accumulator.get();
 
   base::Closure barrier_closure = base::BarrierClosure(
       ordered_cache_names_.size(),
       base::Bind(&SizeRetrievedFromAllCaches,
                  base::Passed(std::move(accumulator)), callback));
 
-  for (const std::string& cache_name : ordered_cache_names_) {
+  for (const base::string16& cache_name : ordered_cache_names_) {
     scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
     cache->GetSizeThenClose(base::Bind(&SizeRetrievedFromCache, cache,
                                        barrier_closure, accumulator_ptr));
   }
 }
 
 void CacheStorage::SizeImpl(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
   scoped_ptr<int64_t> accumulator(new int64_t(0));
   int64_t* accumulator_ptr = accumulator.get();
 
   base::Closure barrier_closure = base::BarrierClosure(
       ordered_cache_names_.size(),
       base::Bind(&SizeRetrievedFromAllCaches,
                  base::Passed(std::move(accumulator)), callback));
 
-  for (const std::string& cache_name : ordered_cache_names_) {
+  for (const base::string16& cache_name : ordered_cache_names_) {
     scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
     cache->Size(base::Bind(&SizeRetrievedFromCache, cache, barrier_closure,
                            accumulator_ptr));
   }
 }
 
 void CacheStorage::PendingClosure(const base::Closure& callback) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run();
@@ skipping 49 matching lines @@
 void CacheStorage::PendingSizeCallback(const SizeCallback& callback,
                                        int64_t size) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run(size);
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content