Use string16 for cache_name in the back end of CacheStorage.

content/browser/cache_storage/cache_storage_unittest.cc

 // Copyright 2015 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 "base/bind.h"
 #include "base/callback.h"
+#include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/guid.h"
 #include "base/run_loop.h"
 #include "base/stl_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/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 const char kOrigin[] = "http://example.com/";
+
+void EnumerateCachesCallback(CacheStorage::StringVector* cache_names_out,
+                             CacheStorageError* error_out,
+                             const CacheStorage::StringVector& cache_names,
+                             CacheStorageError error) {
+  *cache_names_out = cache_names;
+  *error_out = error;
+}
 }
 
 class TestCacheStorage : public CacheStorage {
  public:
   explicit TestCacheStorage(const base::FilePath& file_path)
       : CacheStorage(file_path,
                      false /* memory_only */,
                      base::ThreadTaskRunnerHandle::Get().get(),
                      scoped_refptr<net::URLRequestContextGetter>(),
                      scoped_refptr<storage::QuotaManagerProxy>(),
@@ skipping 31 matching lines @@
 class CacheStorageTest : public testing::Test {
  protected:
   CacheStorageTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     test_cache_storage_.reset(new TestCacheStorage(temp_dir_.path()));
   }
 
-  bool OpenCache(const std::string& cache_name) {
+  bool OpenCache(const base::string16& cache_name) {
     bool callback_called = false;
     test_cache_storage_->OpenCache(
         cache_name, base::Bind(&CacheStorageTest::OpenCacheCallback,
                                base::Unretained(this), &callback_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(callback_called);
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   void OpenCacheCallback(bool* callback_called,
                          const scoped_refptr<CacheStorageCache>& cache,
                          CacheStorageError error) {
     *callback_called = true;
     callback_cache_ = cache;
     callback_error_ = error;
   }
 
+  bool EnumerateCaches(CacheStorage::StringVector* cache_names) {
+    CacheStorageError error = CACHE_STORAGE_ERROR_NOT_FOUND;
+    test_cache_storage_->EnumerateCaches(
+        base::Bind(&EnumerateCachesCallback, base::Unretained(cache_names),
+                   base::Unretained(&error)));
+    base::RunLoop().RunUntilIdle();
+    return error == CACHE_STORAGE_OK;
+  }
+
   base::ScopedTempDir temp_dir_;
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<TestCacheStorage> test_cache_storage_;
 
   scoped_refptr<CacheStorageCache> callback_cache_;
   CacheStorageError callback_error_;
 };
 
 TEST_F(CacheStorageTest, PreserveCache) {
   test_cache_storage_->set_delay_preserved_cache_callback(true);
-  EXPECT_TRUE(OpenCache("foo"));
+  EXPECT_TRUE(OpenCache(base::UTF8ToUTF16("foo")));
   EXPECT_TRUE(test_cache_storage_->IsPreservingCache(callback_cache_.get()));
   test_cache_storage_->RunPreservedCacheCallback();
   EXPECT_FALSE(test_cache_storage_->IsPreservingCache(callback_cache_.get()));
 
   // Try opening it again, since the cache is already open (callback_cache_ is
   // referencing it) the cache shouldn't be preserved again.
-  EXPECT_TRUE(OpenCache("foo"));
+  EXPECT_TRUE(OpenCache(base::UTF8ToUTF16("foo")));
   EXPECT_FALSE(test_cache_storage_->IsPreservingCache(callback_cache_.get()));
 
   // Remove the reference to the cache so that it's deleted. After that, the
   // next time it's opened will require the cache to be created again and
   // preserved.
   callback_cache_ = nullptr;
-  EXPECT_TRUE(OpenCache("foo"));
+  EXPECT_TRUE(OpenCache(base::UTF8ToUTF16("foo")));
   EXPECT_TRUE(test_cache_storage_->IsPreservingCache(callback_cache_.get()));
   test_cache_storage_->RunPreservedCacheCallback();
   EXPECT_FALSE(test_cache_storage_->IsPreservingCache(callback_cache_.get()));
 }
 
+// Until M50 we didn't use |name_utf16| but used |name| in CacheStorageIndex.
+// This test checks the backward compatibility.
+TEST_F(CacheStorageTest, ReadOldIndex) {
+  CacheStorageIndex index;
+  index.set_origin(kOrigin);
+  CacheStorageIndex::Cache* index_cache1 = index.add_cache();
+  index_cache1->set_name("aaa");
+  index_cache1->set_cache_dir(
+      temp_dir_.path().AppendASCII(base::GenerateGUID()).value());
+  CacheStorageIndex::Cache* index_cache2 = index.add_cache();
+  index_cache2->set_name("bbb");
+  index_cache2->set_cache_dir(
+      temp_dir_.path().AppendASCII(base::GenerateGUID()).value());
+
+  std::string serialized;
+  ASSERT_TRUE(index.SerializeToString(&serialized));
+  base::WriteFile(temp_dir_.path().AppendASCII(CacheStorage::kIndexFileName),
+                  serialized.c_str(), serialized.size());
+
+  CacheStorage::StringVector cache_names;
+  EXPECT_TRUE(EnumerateCaches(&cache_names));
+  EXPECT_EQ(2u, cache_names.size());
+  EXPECT_EQ(base::UTF8ToUTF16("aaa"), cache_names[0]);
+  EXPECT_EQ(base::UTF8ToUTF16("bbb"), cache_names[1]);
+}
+
 }  // namespace content