Use string16 for cache_name in the back end of CacheStorage.

content/browser/cache_storage/cache_storage_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.

[nhiroki, 2016/03/02 05:43:13]

Can we have a test for the case where the protobuf schema is updated?

[horo, 2016/03/02 08:35:27]

Added in cache_storage_unittest.cc

 // 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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.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_quota_client.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cache_storage_usage_info.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ skipping 88 matching lines @@
 
   void CacheAndErrorCallback(base::RunLoop* run_loop,
                              const scoped_refptr<CacheStorageCache>& cache,
                              CacheStorageError error) {
     callback_cache_ = cache;
     callback_error_ = error;
     run_loop->Quit();
   }
 
   void StringsAndErrorCallback(base::RunLoop* run_loop,
-                               const std::vector<std::string>& strings,
+                               const std::vector<base::string16>& strings,
                                CacheStorageError error) {
-    callback_strings_ = strings;
+    callback_strings_.clear();
+    for (const auto& name : strings) {
+      callback_strings_.push_back(base::UTF16ToUTF8(name));
+    }
     callback_error_ = error;
     run_loop->Quit();
   }
 
   void CachePutCallback(base::RunLoop* run_loop, CacheStorageError error) {
     callback_error_ = error;
     run_loop->Quit();
   }
 
   void CacheMatchCallback(
       base::RunLoop* run_loop,
       CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
     callback_error_ = error;
     callback_cache_response_ = std::move(response);
     callback_data_handle_ = std::move(blob_data_handle);
     run_loop->Quit();
   }
 
   bool Open(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->OpenCache(
-        origin, cache_name,
+        origin, base::UTF8ToUTF16(cache_name),
         base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     bool error = callback_error_ != CACHE_STORAGE_OK;
     if (error)
       EXPECT_TRUE(!callback_cache_.get());
     else
       EXPECT_TRUE(callback_cache_.get());
     return !error;
   }
 
   bool Has(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->HasCache(
-        origin, cache_name,
+        origin, base::UTF8ToUTF16(cache_name),
         base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_bool_;
   }
 
   bool Delete(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->DeleteCache(
-        origin, cache_name,
+        origin, base::UTF8ToUTF16(cache_name),
         base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_bool_;
   }
 
   bool Keys(const GURL& origin) {
     base::RunLoop loop;
     cache_manager_->EnumerateCaches(
         origin, base::Bind(&CacheStorageManagerTest::StringsAndErrorCallback,
                            base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool StorageMatch(const GURL& origin,
                     const std::string& cache_name,
                     const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
     base::RunLoop loop;
     cache_manager_->MatchCache(
-        origin, cache_name, std::move(request),
+        origin, base::UTF8ToUTF16(cache_name), std::move(request),
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool StorageMatchAll(const GURL& origin, const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
@@ skipping 386 matching lines @@
   EXPECT_TRUE(callback_cache_->AsWeakPtr());
 }
 
 TEST_P(CacheStorageManagerTestP, OpenRunsSerially) {
   EXPECT_FALSE(Delete(origin1_, "tmp"));  // Init storage.
   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
   cache_storage->StartAsyncOperationForTesting();
 
   base::RunLoop open_loop;
   cache_manager_->OpenCache(
-      origin1_, "foo",
+      origin1_, base::UTF8ToUTF16("foo"),
       base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
                  base::Unretained(this), base::Unretained(&open_loop)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_cache_);
 
   cache_storage->CompleteAsyncOperationForTesting();
   open_loop.Run();
   EXPECT_TRUE(callback_cache_);
 }
@@ skipping 442 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content