[CacheStorage] Give cache directories unique names

content/browser/cache_storage/cache_storage_manager_unittest.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_manager.h"
 
 #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/run_loop.h"
+#include "base/sha1.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_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/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_job_factory_impl.h"
+#include "storage/browser/blob/blob_data_builder.h"
+#include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
+// Returns a BlobProtocolHandler that uses |blob_storage_context|. Caller owns
+// the memory.
+scoped_ptr<storage::BlobProtocolHandler> CreateMockBlobProtocolHandler(
+    storage::BlobStorageContext* blob_storage_context) {
+  // The FileSystemContext and thread task runner are not actually used but a
+  // task runner is needed to avoid a DCHECK in BlobURLRequestJob ctor.
+  return make_scoped_ptr(new storage::BlobProtocolHandler(
+      blob_storage_context, NULL, base::ThreadTaskRunnerHandle::Get().get()));
+}
+
 class CacheStorageManagerTest : public testing::Test {
  public:
   CacheStorageManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
+        blob_storage_context_(nullptr),
         callback_bool_(false),
         callback_error_(CACHE_STORAGE_OK),
         origin1_("http://example1.com"),
         origin2_("http://example2.com") {}
 
   void SetUp() override {
     ChromeBlobStorageContext* blob_storage_context(
         ChromeBlobStorageContext::GetFor(&browser_context_));
     // Wait for ChromeBlobStorageContext to finish initializing.
     base::RunLoop().RunUntilIdle();
 
+    blob_storage_context_ = blob_storage_context->context();
+
+    url_request_job_factory_.reset(new net::URLRequestJobFactoryImpl);
+    url_request_job_factory_->SetProtocolHandler(
+        "blob", CreateMockBlobProtocolHandler(blob_storage_context->context()));
+
+    net::URLRequestContext* url_request_context =
+        browser_context_.GetRequestContext()->GetURLRequestContext();
+
+    url_request_context->set_job_factory(url_request_job_factory_.get());
+
     quota_manager_proxy_ = new MockQuotaManagerProxy(
         nullptr, base::ThreadTaskRunnerHandle::Get().get());
 
     if (MemoryOnly()) {
       cache_manager_ = CacheStorageManager::Create(
           base::FilePath(), base::ThreadTaskRunnerHandle::Get(),
           quota_manager_proxy_);
     } else {
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
       cache_manager_ = CacheStorageManager::Create(
@@ skipping 42 matching lines @@
     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_ = response.Pass();
-    // Deliberately drop the data handle as only the url is being tested.
+    callback_data_handle_ = blob_data_handle.Pass();
     run_loop->Quit();
   }
 
   bool Open(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->OpenCache(
         origin, cache_name,
         base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
@@ skipping 64 matching lines @@
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CachePut(const scoped_refptr<CacheStorageCache>& cache,
                 const GURL& url) {
     ServiceWorkerFetchRequest request;
-    ServiceWorkerResponse response;
     request.url = url;
-    response.url = url;
+
+    scoped_ptr<storage::BlobDataBuilder> blob_data(
+        new storage::BlobDataBuilder(base::GenerateGUID()));
+    blob_data->AppendData(url.spec());
+
+    scoped_ptr<storage::BlobDataHandle> blob_handle =
+        blob_storage_context_->AddFinishedBlob(blob_data.get());
+    ServiceWorkerResponse response(
+        url, 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
+        ServiceWorkerHeaderMap(), blob_handle->uuid(), url.spec().size(),
+        GURL(), blink::WebServiceWorkerResponseErrorUnknown);
 
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
     base::RunLoop loop;
     cache->BatchOperation(
         std::vector<CacheStorageBatchOperation>(1, operation),
         base::Bind(&CacheStorageManagerTest::CachePutCallback,
@@ skipping 47 matching lines @@
   void AllOriginsUsageCallback(
       base::RunLoop* run_loop,
       const std::vector<CacheStorageUsageInfo>& usage) {
     callback_all_origins_usage_ = usage;
     run_loop->Quit();
   }
 
  protected:
   TestBrowserContext browser_context_;
   TestBrowserThreadBundle browser_thread_bundle_;
+  scoped_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_;
+  storage::BlobStorageContext* blob_storage_context_;
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_ptr<CacheStorageManager> cache_manager_;
 
   scoped_refptr<CacheStorageCache> callback_cache_;
   int callback_bool_;
   CacheStorageError callback_error_;
   scoped_ptr<ServiceWorkerResponse> callback_cache_response_;
+  scoped_ptr<storage::BlobDataHandle> callback_data_handle_;
   std::vector<std::string> callback_strings_;
 
   const GURL origin1_;
   const GURL origin2_;
 
   int64 callback_usage_;
   std::vector<CacheStorageUsageInfo> callback_all_origins_usage_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
@@ skipping 128 matching lines @@
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/bar")));
   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllNoCaches) {
   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 }
 
+TEST_F(CacheStorageManagerTest, StorageReuseCacheName) {
+  // Deleting a cache and creating one with the same name and adding an entry
+  // with the same URL should work. (see crbug.com/542668)
+  const GURL kTestURL = GURL("http://example.com/foo");
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_, kTestURL));
+  EXPECT_TRUE(CacheMatch(callback_cache_, kTestURL));
+  scoped_ptr<storage::BlobDataHandle> data_handle =
+      callback_data_handle_.Pass();
+
+  EXPECT_TRUE(Delete(origin1_, "foo"));
+  // The cache is deleted but the handle to one of its entries is still
+  // open. Creating a new cache in the same directory would fail on Windows.
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_, kTestURL));
+}
+
 TEST_P(CacheStorageManagerTestP, StorageMatchAllEntryExistsTwice) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_TRUE(Open(origin1_, "bar"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 
   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchInOneOfMany) {
@@ skipping 252 matching lines @@
   EXPECT_FALSE(base::DirectoryExists(legacy_path_));
   EXPECT_TRUE(base::DirectoryExists(new_path_));
 
   EXPECT_TRUE(Keys(origin1_));
   std::vector<std::string> expected_keys;
   expected_keys.push_back(cache1_);
   expected_keys.push_back(cache2_);
   EXPECT_EQ(expected_keys, callback_strings_);
 }
 
+// Tests that legacy caches created via a hash of the cache name instead of a
+// random name are migrated and continue to function in a new world of random
+// cache names.
+class MigratedLegacyCacheDirectoryNameTest : public CacheStorageManagerTest {
+ protected:
+  MigratedLegacyCacheDirectoryNameTest()
+      : legacy_cache_name_("foo"), stored_url_("http://example.com/foo") {}
+
+  void SetUp() override {
+    CacheStorageManagerTest::SetUp();
+
+    // Create a cache that is stored on disk with the legacy naming scheme (hash
+    // of the name) and without a directory name in the index.
+    base::FilePath origin_path = CacheStorageManager::ConstructOriginPath(
+        cache_manager_->root_path(), origin1_);
+
+    // Populate a legacy cache.
+    ASSERT_TRUE(Open(origin1_, legacy_cache_name_));
+    EXPECT_TRUE(CachePut(callback_cache_, stored_url_));
+    base::FilePath new_path = callback_cache_->path();
+
+    // Close the cache.
+    callback_cache_ = nullptr;
+    base::RunLoop().RunUntilIdle();
+
+    // Legacy index files didn't have the cache directory, so remove it from the
+    // index.
+    base::FilePath index_path = origin_path.AppendASCII("index.txt");
+    std::string index_contents;
+    base::ReadFileToString(index_path, &index_contents);
+    CacheStorageIndex index;
+    ASSERT_TRUE(index.ParseFromString(index_contents));
+    ASSERT_EQ(1, index.cache_size());
+    index.mutable_cache(0)->clear_cache_dir();
+    ASSERT_TRUE(index.SerializeToString(&index_contents));
+    index.ParseFromString(index_contents);
+    ASSERT_EQ(index_contents.size(),
+              (uint32_t)base::WriteFile(index_path, index_contents.c_str(),
+                                        index_contents.size()));
+
+    // Move the cache to the legacy location.
+    legacy_path_ = origin_path.AppendASCII(HexedHash(legacy_cache_name_));
+    ASSERT_FALSE(base::DirectoryExists(legacy_path_));
+    ASSERT_TRUE(base::Move(new_path, legacy_path_));
+
+    // Create a new manager to reread the index file and force migration.
+    quota_manager_proxy_->SimulateQuotaManagerDestroyed();
+    cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
+  }
+
+  static std::string HexedHash(const std::string& value) {
+    std::string value_hash = base::SHA1HashString(value);
+    std::string valued_hexed_hash = base::ToLowerASCII(
+        base::HexEncode(value_hash.c_str(), value_hash.length()));
+    return valued_hexed_hash;
+  }
+
+  base::FilePath legacy_path_;
+  const std::string legacy_cache_name_;
+  const GURL stored_url_;
+
+  DISALLOW_COPY_AND_ASSIGN(MigratedLegacyCacheDirectoryNameTest);
+};
+
+TEST_F(MigratedLegacyCacheDirectoryNameTest, LegacyCacheMigrated) {
+  EXPECT_TRUE(Open(origin1_, legacy_cache_name_));
+
+  // Verify that the cache migrated away from the legacy_path_ directory.
+  ASSERT_FALSE(base::DirectoryExists(legacy_path_));
+
+  // Verify that the existing entry still works.
+  EXPECT_TRUE(CacheMatch(callback_cache_, stored_url_));
+
+  // Verify that adding new entries works.
+  EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo2")));
+  EXPECT_TRUE(CacheMatch(callback_cache_, GURL("http://example.com/foo2")));
+}
+
+TEST_F(MigratedLegacyCacheDirectoryNameTest,
+       RandomDirectoryCacheSideBySideWithLegacy) {
+  EXPECT_TRUE(Open(origin1_, legacy_cache_name_));
+  EXPECT_TRUE(Open(origin1_, "bar"));
+  EXPECT_TRUE(CachePut(callback_cache_, stored_url_));
+  EXPECT_TRUE(CacheMatch(callback_cache_, stored_url_));
+}
+
+TEST_F(MigratedLegacyCacheDirectoryNameTest, DeleteLegacyCacheAndRecreateNew) {
+  EXPECT_TRUE(Delete(origin1_, legacy_cache_name_));
+  EXPECT_TRUE(Open(origin1_, legacy_cache_name_));
+  EXPECT_FALSE(CacheMatch(callback_cache_, stored_url_));
+  EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo2")));
+  EXPECT_TRUE(CacheMatch(callback_cache_, GURL("http://example.com/foo2")));
+}
+
 class CacheStorageQuotaClientTest : public CacheStorageManagerTest {
  protected:
   CacheStorageQuotaClientTest() {}
 
   void SetUp() override {
     CacheStorageManagerTest::SetUp();
     quota_client_.reset(
         new CacheStorageQuotaClient(cache_manager_->AsWeakPtr()));
   }
 
@@ skipping 132 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content