| // 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.h" |
| |
| #include "base/files/file_path.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/message_loop/message_loop_proxy.h" |
| #include "base/run_loop.h" |
| #include "content/browser/fileapi/chrome_blob_storage_context.h" |
| #include "content/browser/fileapi/mock_url_request_delegate.h" |
| #include "content/browser/quota/mock_quota_manager_proxy.h" |
| #include "content/common/service_worker/service_worker_types.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/common/referrer.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_data_snapshot.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 { |
| |
| namespace { |
| const char kTestData[] = "Hello World"; |
| |
| // Returns a BlobProtocolHandler that uses |blob_storage_context|. Caller owns |
| // the memory. |
| storage::BlobProtocolHandler* CreateMockBlobProtocolHandler( |
| storage::BlobStorageContext* blob_storage_context) { |
| // The FileSystemContext and MessageLoopProxy are not actually used but a |
| // MessageLoopProxy is needed to avoid a DCHECK in BlobURLRequestJob ctor. |
| return new storage::BlobProtocolHandler( |
| blob_storage_context, NULL, base::MessageLoopProxy::current().get()); |
| } |
| |
| // A disk_cache::Backend wrapper that can delay operations. |
| class DelayableBackend : public disk_cache::Backend { |
| public: |
| DelayableBackend(scoped_ptr<disk_cache::Backend> backend) |
| : backend_(backend.Pass()), delay_open_(false) {} |
| |
| // disk_cache::Backend overrides |
| net::CacheType GetCacheType() const override { |
| return backend_->GetCacheType(); |
| } |
| int32 GetEntryCount() const override { return backend_->GetEntryCount(); } |
| int OpenEntry(const std::string& key, |
| disk_cache::Entry** entry, |
| const CompletionCallback& callback) override { |
| if (delay_open_) { |
| open_entry_callback_ = |
| base::Bind(&DelayableBackend::OpenEntryDelayedImpl, |
| base::Unretained(this), key, entry, callback); |
| return net::ERR_IO_PENDING; |
| } |
| |
| return backend_->OpenEntry(key, entry, callback); |
| } |
| int CreateEntry(const std::string& key, |
| disk_cache::Entry** entry, |
| const CompletionCallback& callback) override { |
| return backend_->CreateEntry(key, entry, callback); |
| } |
| int DoomEntry(const std::string& key, |
| const CompletionCallback& callback) override { |
| return backend_->DoomEntry(key, callback); |
| } |
| int DoomAllEntries(const CompletionCallback& callback) override { |
| return backend_->DoomAllEntries(callback); |
| } |
| int DoomEntriesBetween(base::Time initial_time, |
| base::Time end_time, |
| const CompletionCallback& callback) override { |
| return backend_->DoomEntriesBetween(initial_time, end_time, callback); |
| } |
| int DoomEntriesSince(base::Time initial_time, |
| const CompletionCallback& callback) override { |
| return backend_->DoomEntriesSince(initial_time, callback); |
| } |
| scoped_ptr<Iterator> CreateIterator() override { |
| return backend_->CreateIterator(); |
| } |
| void GetStats( |
| std::vector<std::pair<std::string, std::string>>* stats) override { |
| return backend_->GetStats(stats); |
| } |
| void OnExternalCacheHit(const std::string& key) override { |
| return backend_->OnExternalCacheHit(key); |
| } |
| |
| // Call to continue a delayed open. |
| void OpenEntryContinue() { |
| EXPECT_FALSE(open_entry_callback_.is_null()); |
| open_entry_callback_.Run(); |
| } |
| |
| void set_delay_open(bool value) { delay_open_ = value; } |
| |
| private: |
| void OpenEntryDelayedImpl(const std::string& key, |
| disk_cache::Entry** entry, |
| const CompletionCallback& callback) { |
| int rv = backend_->OpenEntry(key, entry, callback); |
| if (rv != net::ERR_IO_PENDING) |
| callback.Run(rv); |
| } |
| |
| scoped_ptr<disk_cache::Backend> backend_; |
| bool delay_open_; |
| base::Closure open_entry_callback_; |
| }; |
| |
| } // namespace |
| |
| // A ServiceWorkerCache that can optionally delay during backend creation. |
| class TestServiceWorkerCache : public ServiceWorkerCache { |
| public: |
| TestServiceWorkerCache( |
| const GURL& origin, |
| const base::FilePath& path, |
| net::URLRequestContext* request_context, |
| const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy, |
| base::WeakPtr<storage::BlobStorageContext> blob_context) |
| : ServiceWorkerCache(origin, |
| path, |
| request_context, |
| quota_manager_proxy, |
| blob_context), |
| delay_backend_creation_(false) {} |
| |
| void CreateBackend(const ErrorCallback& callback) override { |
| backend_creation_callback_ = callback; |
| if (delay_backend_creation_) |
| return; |
| ContinueCreateBackend(); |
| } |
| |
| void ContinueCreateBackend() { |
| ServiceWorkerCache::CreateBackend(backend_creation_callback_); |
| } |
| |
| void set_delay_backend_creation(bool delay) { |
| delay_backend_creation_ = delay; |
| } |
| |
| // Swap the existing backend with a delayable one. The backend must have been |
| // created before calling this. |
| DelayableBackend* UseDelayableBackend() { |
| EXPECT_TRUE(backend_); |
| DelayableBackend* delayable_backend = new DelayableBackend(backend_.Pass()); |
| backend_.reset(delayable_backend); |
| return delayable_backend; |
| } |
| |
| private: |
| ~TestServiceWorkerCache() override {} |
| |
| bool delay_backend_creation_; |
| ErrorCallback backend_creation_callback_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestServiceWorkerCache); |
| }; |
| |
| class ServiceWorkerCacheTest : public testing::Test { |
| public: |
| ServiceWorkerCacheTest() |
| : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP), |
| callback_error_(ServiceWorkerCache::ErrorTypeOK), |
| callback_closed_(false) {} |
| |
| void SetUp() override { |
| ChromeBlobStorageContext* blob_storage_context = |
| ChromeBlobStorageContext::GetFor(&browser_context_); |
| // Wait for chrome_blob_storage_context to finish initializing. |
| base::RunLoop().RunUntilIdle(); |
| blob_storage_context_ = blob_storage_context->context(); |
| |
| quota_manager_proxy_ = new MockQuotaManagerProxy( |
| nullptr, base::MessageLoopProxy::current().get()); |
| |
| 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()); |
| |
| CreateRequests(blob_storage_context); |
| |
| if (!MemoryOnly()) |
| ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
| base::FilePath path = MemoryOnly() ? base::FilePath() : temp_dir_.path(); |
| |
| cache_ = make_scoped_refptr(new TestServiceWorkerCache( |
| GURL("http://example.com"), path, url_request_context, |
| quota_manager_proxy_, blob_storage_context->context()->AsWeakPtr())); |
| } |
| |
| void TearDown() override { |
| quota_manager_proxy_->SimulateQuotaManagerDestroyed(); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| void CreateRequests(ChromeBlobStorageContext* blob_storage_context) { |
| ServiceWorkerHeaderMap headers; |
| headers.insert(std::make_pair("a", "a")); |
| headers.insert(std::make_pair("b", "b")); |
| body_request_ = |
| ServiceWorkerFetchRequest(GURL("http://example.com/body.html"), "GET", |
| headers, Referrer(), false); |
| no_body_request_ = |
| ServiceWorkerFetchRequest(GURL("http://example.com/no_body.html"), |
| "GET", |
| headers, |
| Referrer(), |
| false); |
| |
| std::string expected_response; |
| for (int i = 0; i < 100; ++i) |
| expected_blob_data_ += kTestData; |
| |
| scoped_ptr<storage::BlobDataBuilder> blob_data( |
| new storage::BlobDataBuilder("blob-id:myblob")); |
| blob_data->AppendData(expected_blob_data_); |
| |
| blob_handle_ = |
| blob_storage_context->context()->AddFinishedBlob(blob_data.get()); |
| |
| body_response_ = |
| ServiceWorkerResponse(GURL("http://example.com/body.html"), |
| 200, |
| "OK", |
| blink::WebServiceWorkerResponseTypeDefault, |
| headers, |
| blob_handle_->uuid(), |
| expected_blob_data_.size(), |
| GURL()); |
| |
| no_body_response_ = |
| ServiceWorkerResponse(GURL("http://example.com/no_body.html"), |
| 200, |
| "OK", |
| blink::WebServiceWorkerResponseTypeDefault, |
| headers, |
| "", |
| 0, |
| GURL()); |
| } |
| |
| scoped_ptr<ServiceWorkerFetchRequest> CopyFetchRequest( |
| const ServiceWorkerFetchRequest& request) { |
| return make_scoped_ptr(new ServiceWorkerFetchRequest(request.url, |
| request.method, |
| request.headers, |
| request.referrer, |
| request.is_reload)); |
| } |
| |
| scoped_ptr<ServiceWorkerResponse> CopyFetchResponse( |
| const ServiceWorkerResponse& response) { |
| scoped_ptr<ServiceWorkerResponse> sw_response( |
| new ServiceWorkerResponse(response.url, |
| response.status_code, |
| response.status_text, |
| response.response_type, |
| response.headers, |
| response.blob_uuid, |
| response.blob_size, |
| response.stream_url)); |
| return sw_response.Pass(); |
| } |
| |
| bool Put(const ServiceWorkerFetchRequest& request, |
| const ServiceWorkerResponse& response) { |
| scoped_ptr<base::RunLoop> loop(new base::RunLoop()); |
| |
| cache_->Put(CopyFetchRequest(request), |
| CopyFetchResponse(response), |
| base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback, |
| base::Unretained(this), |
| base::Unretained(loop.get()))); |
| // TODO(jkarlin): These functions should use base::RunLoop().RunUntilIdle() |
| // once the cache uses a passed in MessageLoopProxy instead of the CACHE |
| // thread. |
| loop->Run(); |
| |
| return callback_error_ == ServiceWorkerCache::ErrorTypeOK; |
| } |
| |
| bool Match(const ServiceWorkerFetchRequest& request) { |
| scoped_ptr<base::RunLoop> loop(new base::RunLoop()); |
| |
| cache_->Match(CopyFetchRequest(request), |
| base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback, |
| base::Unretained(this), |
| base::Unretained(loop.get()))); |
| loop->Run(); |
| |
| return callback_error_ == ServiceWorkerCache::ErrorTypeOK; |
| } |
| |
| bool Delete(const ServiceWorkerFetchRequest& request) { |
| scoped_ptr<base::RunLoop> loop(new base::RunLoop()); |
| |
| cache_->Delete(CopyFetchRequest(request), |
| base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback, |
| base::Unretained(this), |
| base::Unretained(loop.get()))); |
| loop->Run(); |
| |
| return callback_error_ == ServiceWorkerCache::ErrorTypeOK; |
| } |
| |
| bool Keys() { |
| scoped_ptr<base::RunLoop> loop(new base::RunLoop()); |
| |
| cache_->Keys(base::Bind(&ServiceWorkerCacheTest::RequestsCallback, |
| base::Unretained(this), |
| base::Unretained(loop.get()))); |
| loop->Run(); |
| |
| return callback_error_ == ServiceWorkerCache::ErrorTypeOK; |
| } |
| |
| bool Close() { |
| scoped_ptr<base::RunLoop> loop(new base::RunLoop()); |
| |
| cache_->Close(base::Bind(&ServiceWorkerCacheTest::CloseCallback, |
| base::Unretained(this), |
| base::Unretained(loop.get()))); |
| loop->Run(); |
| return callback_closed_; |
| } |
| |
| void RequestsCallback(base::RunLoop* run_loop, |
| ServiceWorkerCache::ErrorType error, |
| scoped_ptr<ServiceWorkerCache::Requests> requests) { |
| callback_error_ = error; |
| callback_strings_.clear(); |
| if (requests) { |
| for (size_t i = 0u; i < requests->size(); ++i) |
| callback_strings_.push_back(requests->at(i).url.spec()); |
| } |
| if (run_loop) |
| run_loop->Quit(); |
| } |
| |
| void ErrorTypeCallback(base::RunLoop* run_loop, |
| ServiceWorkerCache::ErrorType error) { |
| callback_error_ = error; |
| if (run_loop) |
| run_loop->Quit(); |
| } |
| |
| void ResponseAndErrorCallback( |
| base::RunLoop* run_loop, |
| ServiceWorkerCache::ErrorType error, |
| scoped_ptr<ServiceWorkerResponse> response, |
| scoped_ptr<storage::BlobDataHandle> body_handle) { |
| callback_error_ = error; |
| callback_response_ = response.Pass(); |
| callback_response_data_.reset(); |
| if (error == ServiceWorkerCache::ErrorTypeOK && |
| !callback_response_->blob_uuid.empty()) { |
| callback_response_data_ = body_handle.Pass(); |
| } |
| |
| if (run_loop) |
| run_loop->Quit(); |
| } |
| |
| void CloseCallback(base::RunLoop* run_loop) { |
| EXPECT_FALSE(callback_closed_); |
| callback_closed_ = true; |
| if (run_loop) |
| run_loop->Quit(); |
| } |
| |
| void CopyBody(storage::BlobDataHandle* blob_handle, std::string* output) { |
| scoped_ptr<storage::BlobDataSnapshot> data = blob_handle->CreateSnapshot(); |
| const auto& items = data->items(); |
| for (const auto& item : items) { |
| output->append(item->bytes(), item->length()); |
| } |
| } |
| |
| bool VerifyKeys(const std::vector<std::string>& expected_keys) { |
| if (expected_keys.size() != callback_strings_.size()) |
| return false; |
| |
| std::set<std::string> found_set; |
| for (int i = 0, max = callback_strings_.size(); i < max; ++i) |
| found_set.insert(callback_strings_[i]); |
| |
| for (int i = 0, max = expected_keys.size(); i < max; ++i) { |
| if (found_set.find(expected_keys[i]) == found_set.end()) |
| return false; |
| } |
| return true; |
| } |
| |
| bool TestResponseType(blink::WebServiceWorkerResponseType response_type) { |
| body_response_.response_type = response_type; |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_TRUE(Delete(body_request_)); |
| return response_type == callback_response_->response_type; |
| } |
| |
| void VerifyAllOpsFail() { |
| EXPECT_FALSE(Put(no_body_request_, no_body_response_)); |
| EXPECT_FALSE(Match(no_body_request_)); |
| EXPECT_FALSE(Delete(body_request_)); |
| EXPECT_FALSE(Keys()); |
| } |
| |
| virtual bool MemoryOnly() { return false; } |
| |
| protected: |
| TestBrowserContext browser_context_; |
| TestBrowserThreadBundle browser_thread_bundle_; |
| scoped_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_; |
| scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_; |
| storage::BlobStorageContext* blob_storage_context_; |
| |
| base::ScopedTempDir temp_dir_; |
| scoped_refptr<TestServiceWorkerCache> cache_; |
| |
| ServiceWorkerFetchRequest body_request_; |
| ServiceWorkerResponse body_response_; |
| ServiceWorkerFetchRequest no_body_request_; |
| ServiceWorkerResponse no_body_response_; |
| scoped_ptr<storage::BlobDataHandle> blob_handle_; |
| std::string expected_blob_data_; |
| |
| ServiceWorkerCache::ErrorType callback_error_; |
| scoped_ptr<ServiceWorkerResponse> callback_response_; |
| scoped_ptr<storage::BlobDataHandle> callback_response_data_; |
| std::vector<std::string> callback_strings_; |
| bool callback_closed_; |
| }; |
| |
| class ServiceWorkerCacheTestP : public ServiceWorkerCacheTest, |
| public testing::WithParamInterface<bool> { |
| bool MemoryOnly() override { return !GetParam(); } |
| }; |
| |
| class ServiceWorkerCacheMemoryOnlyTest |
| : public ServiceWorkerCacheTest, |
| public testing::WithParamInterface<bool> { |
| bool MemoryOnly() override { return true; } |
| }; |
| |
| TEST_P(ServiceWorkerCacheTestP, PutNoBody) { |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(callback_response_); |
| EXPECT_STREQ(no_body_response_.url.spec().c_str(), |
| callback_response_->url.spec().c_str()); |
| EXPECT_FALSE(callback_response_data_); |
| EXPECT_STREQ("", callback_response_->blob_uuid.c_str()); |
| EXPECT_EQ(0u, callback_response_->blob_size); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, PutBody) { |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(callback_response_); |
| EXPECT_STREQ(body_response_.url.spec().c_str(), |
| callback_response_->url.spec().c_str()); |
| EXPECT_TRUE(callback_response_data_); |
| EXPECT_STRNE("", callback_response_->blob_uuid.c_str()); |
| EXPECT_EQ(expected_blob_data_.size(), callback_response_->blob_size); |
| |
| std::string response_body; |
| CopyBody(callback_response_data_.get(), &response_body); |
| EXPECT_STREQ(expected_blob_data_.c_str(), response_body.c_str()); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, ResponseURLDiffersFromRequestURL) { |
| no_body_response_.url = GURL("http://example.com/foobar"); |
| EXPECT_STRNE("http://example.com/foobar", |
| no_body_request_.url.spec().c_str()); |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(no_body_request_)); |
| EXPECT_STREQ("http://example.com/foobar", |
| callback_response_->url.spec().c_str()); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, ResponseURLEmpty) { |
| no_body_response_.url = GURL(); |
| EXPECT_STRNE("", no_body_request_.url.spec().c_str()); |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(no_body_request_)); |
| EXPECT_STREQ("", callback_response_->url.spec().c_str()); |
| } |
| |
| TEST_F(ServiceWorkerCacheTest, PutBodyDropBlobRef) { |
| scoped_ptr<base::RunLoop> loop(new base::RunLoop()); |
| cache_->Put(CopyFetchRequest(body_request_), |
| CopyFetchResponse(body_response_), |
| base::Bind(&ServiceWorkerCacheTestP::ResponseAndErrorCallback, |
| base::Unretained(this), |
| base::Unretained(loop.get()))); |
| // The handle should be held by the cache now so the deref here should be |
| // okay. |
| blob_handle_.reset(); |
| loop->Run(); |
| |
| EXPECT_EQ(ServiceWorkerCache::ErrorTypeOK, callback_error_); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, PutReplace) { |
| EXPECT_TRUE(Put(body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_FALSE(callback_response_data_); |
| |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_TRUE(callback_response_data_); |
| |
| EXPECT_TRUE(Put(body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_FALSE(callback_response_data_); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, MatchNoBody) { |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(no_body_request_)); |
| EXPECT_EQ(200, callback_response_->status_code); |
| EXPECT_STREQ("OK", callback_response_->status_text.c_str()); |
| EXPECT_STREQ("http://example.com/no_body.html", |
| callback_response_->url.spec().c_str()); |
| EXPECT_STREQ("", callback_response_->blob_uuid.c_str()); |
| EXPECT_EQ(0u, callback_response_->blob_size); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, MatchBody) { |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_EQ(200, callback_response_->status_code); |
| EXPECT_STREQ("OK", callback_response_->status_text.c_str()); |
| EXPECT_STREQ("http://example.com/body.html", |
| callback_response_->url.spec().c_str()); |
| EXPECT_STRNE("", callback_response_->blob_uuid.c_str()); |
| EXPECT_EQ(expected_blob_data_.size(), callback_response_->blob_size); |
| |
| std::string response_body; |
| CopyBody(callback_response_data_.get(), &response_body); |
| EXPECT_STREQ(expected_blob_data_.c_str(), response_body.c_str()); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, Vary) { |
| body_request_.headers["vary_foo"] = "foo"; |
| body_response_.headers["vary"] = "vary_foo"; |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| |
| body_request_.headers["vary_foo"] = "bar"; |
| EXPECT_FALSE(Match(body_request_)); |
| |
| body_request_.headers.erase("vary_foo"); |
| EXPECT_FALSE(Match(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, EmptyVary) { |
| body_response_.headers["vary"] = ""; |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| |
| body_request_.headers["zoo"] = "zoo"; |
| EXPECT_TRUE(Match(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, NoVaryButDiffHeaders) { |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| |
| body_request_.headers["zoo"] = "zoo"; |
| EXPECT_TRUE(Match(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, VaryMultiple) { |
| body_request_.headers["vary_foo"] = "foo"; |
| body_request_.headers["vary_bar"] = "bar"; |
| body_response_.headers["vary"] = " vary_foo , vary_bar"; |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| |
| body_request_.headers["vary_bar"] = "foo"; |
| EXPECT_FALSE(Match(body_request_)); |
| |
| body_request_.headers.erase("vary_bar"); |
| EXPECT_FALSE(Match(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, VaryNewHeader) { |
| body_request_.headers["vary_foo"] = "foo"; |
| body_response_.headers["vary"] = " vary_foo, vary_bar"; |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| |
| body_request_.headers["vary_bar"] = "bar"; |
| EXPECT_FALSE(Match(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, VaryStar) { |
| body_response_.headers["vary"] = "*"; |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_FALSE(Match(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, EmptyKeys) { |
| EXPECT_TRUE(Keys()); |
| EXPECT_EQ(0u, callback_strings_.size()); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, TwoKeys) { |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Keys()); |
| EXPECT_EQ(2u, callback_strings_.size()); |
| std::vector<std::string> expected_keys; |
| expected_keys.push_back(no_body_request_.url.spec()); |
| expected_keys.push_back(body_request_.url.spec()); |
| EXPECT_TRUE(VerifyKeys(expected_keys)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, TwoKeysThenOne) { |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Keys()); |
| EXPECT_EQ(2u, callback_strings_.size()); |
| std::vector<std::string> expected_keys; |
| expected_keys.push_back(no_body_request_.url.spec()); |
| expected_keys.push_back(body_request_.url.spec()); |
| EXPECT_TRUE(VerifyKeys(expected_keys)); |
| |
| EXPECT_TRUE(Delete(body_request_)); |
| EXPECT_TRUE(Keys()); |
| EXPECT_EQ(1u, callback_strings_.size()); |
| std::vector<std::string> expected_key; |
| expected_key.push_back(no_body_request_.url.spec()); |
| EXPECT_TRUE(VerifyKeys(expected_key)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, DeleteNoBody) { |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(no_body_request_)); |
| EXPECT_TRUE(Delete(no_body_request_)); |
| EXPECT_FALSE(Match(no_body_request_)); |
| EXPECT_FALSE(Delete(no_body_request_)); |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(no_body_request_)); |
| EXPECT_TRUE(Delete(no_body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, DeleteBody) { |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_TRUE(Delete(body_request_)); |
| EXPECT_FALSE(Match(body_request_)); |
| EXPECT_FALSE(Delete(body_request_)); |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Match(body_request_)); |
| EXPECT_TRUE(Delete(body_request_)); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, QuickStressNoBody) { |
| for (int i = 0; i < 100; ++i) { |
| EXPECT_FALSE(Match(no_body_request_)); |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_TRUE(Match(no_body_request_)); |
| EXPECT_TRUE(Delete(no_body_request_)); |
| } |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, QuickStressBody) { |
| for (int i = 0; i < 100; ++i) { |
| ASSERT_FALSE(Match(body_request_)); |
| ASSERT_TRUE(Put(body_request_, body_response_)); |
| ASSERT_TRUE(Match(body_request_)); |
| ASSERT_TRUE(Delete(body_request_)); |
| } |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, PutResponseType) { |
| EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeBasic)); |
| EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeCORS)); |
| EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeDefault)); |
| EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeError)); |
| EXPECT_TRUE(TestResponseType(blink::WebServiceWorkerResponseTypeOpaque)); |
| } |
| |
| TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerResponseHeaders) { |
| // ServiceWorkerCache depends on ServiceWorkerResponse having caseless |
| // headers so that it can quickly lookup vary headers. |
| ServiceWorkerResponse response(GURL("http://www.example.com"), |
| 200, |
| "OK", |
| blink::WebServiceWorkerResponseTypeDefault, |
| ServiceWorkerHeaderMap(), |
| "", |
| 0, |
| GURL()); |
| response.headers["content-type"] = "foo"; |
| response.headers["Content-Type"] = "bar"; |
| EXPECT_EQ("bar", response.headers["content-type"]); |
| } |
| |
| TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerFetchRequestHeaders) { |
| // ServiceWorkerCache depends on ServiceWorkerFetchRequest having caseless |
| // headers so that it can quickly lookup vary headers. |
| ServiceWorkerFetchRequest request(GURL("http://www.example.com"), |
| "GET", |
| ServiceWorkerHeaderMap(), |
| Referrer(), |
| false); |
| request.headers["content-type"] = "foo"; |
| request.headers["Content-Type"] = "bar"; |
| EXPECT_EQ("bar", request.headers["content-type"]); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, QuotaManagerModified) { |
| EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count()); |
| |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_EQ(1, quota_manager_proxy_->notify_storage_modified_count()); |
| EXPECT_LT(0, quota_manager_proxy_->last_notified_delta()); |
| int64 sum_delta = quota_manager_proxy_->last_notified_delta(); |
| |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_EQ(2, quota_manager_proxy_->notify_storage_modified_count()); |
| EXPECT_LT(sum_delta, quota_manager_proxy_->last_notified_delta()); |
| sum_delta += quota_manager_proxy_->last_notified_delta(); |
| |
| EXPECT_TRUE(Delete(body_request_)); |
| EXPECT_EQ(3, quota_manager_proxy_->notify_storage_modified_count()); |
| sum_delta += quota_manager_proxy_->last_notified_delta(); |
| |
| EXPECT_TRUE(Delete(no_body_request_)); |
| EXPECT_EQ(4, quota_manager_proxy_->notify_storage_modified_count()); |
| sum_delta += quota_manager_proxy_->last_notified_delta(); |
| |
| EXPECT_EQ(0, sum_delta); |
| } |
| |
| TEST_F(ServiceWorkerCacheMemoryOnlyTest, MemoryBackedSize) { |
| EXPECT_EQ(0, cache_->MemoryBackedSize()); |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_LT(0, cache_->MemoryBackedSize()); |
| int64 no_body_size = cache_->MemoryBackedSize(); |
| |
| EXPECT_TRUE(Delete(no_body_request_)); |
| EXPECT_EQ(0, cache_->MemoryBackedSize()); |
| |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_LT(no_body_size, cache_->MemoryBackedSize()); |
| |
| EXPECT_TRUE(Delete(body_request_)); |
| EXPECT_EQ(0, cache_->MemoryBackedSize()); |
| } |
| |
| TEST_F(ServiceWorkerCacheTest, MemoryBackedSizePersistent) { |
| EXPECT_EQ(0, cache_->MemoryBackedSize()); |
| EXPECT_TRUE(Put(no_body_request_, no_body_response_)); |
| EXPECT_EQ(0, cache_->MemoryBackedSize()); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, OpsFailOnClosedBackendNeverCreated) { |
| cache_->set_delay_backend_creation( |
| true); // Will hang the test if a backend is created. |
| EXPECT_TRUE(Close()); |
| VerifyAllOpsFail(); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, OpsFailOnClosedBackend) { |
| // Create the backend and put something in it. |
| EXPECT_TRUE(Put(body_request_, body_response_)); |
| EXPECT_TRUE(Close()); |
| VerifyAllOpsFail(); |
| } |
| |
| TEST_P(ServiceWorkerCacheTestP, VerifySerialScheduling) { |
| // Start two operations, the first one is delayed but the second isn't. The |
| // second should wait for the first. |
| EXPECT_TRUE(Keys()); // Opens the backend. |
| DelayableBackend* delayable_backend = cache_->UseDelayableBackend(); |
| delayable_backend->set_delay_open(true); |
| |
| scoped_ptr<ServiceWorkerResponse> response1 = |
| CopyFetchResponse(body_response_); |
| response1->status_code = 1; |
| |
| scoped_ptr<base::RunLoop> close_loop1(new base::RunLoop()); |
| cache_->Put(CopyFetchRequest(body_request_), response1.Pass(), |
| base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback, |
| base::Unretained(this), close_loop1.get())); |
| |
| // Blocks on opening the cache entry. |
| base::RunLoop().RunUntilIdle(); |
| |
| delayable_backend->set_delay_open(false); |
| scoped_ptr<ServiceWorkerResponse> response2 = |
| CopyFetchResponse(body_response_); |
| response2->status_code = 2; |
| scoped_ptr<base::RunLoop> close_loop2(new base::RunLoop()); |
| cache_->Put(CopyFetchRequest(body_request_), response2.Pass(), |
| base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback, |
| base::Unretained(this), close_loop2.get())); |
| |
| // The second put operation should wait for the first to complete. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(callback_response_); |
| |
| delayable_backend->OpenEntryContinue(); |
| close_loop1->Run(); |
| EXPECT_EQ(1, callback_response_->status_code); |
| close_loop2->Run(); |
| EXPECT_EQ(2, callback_response_->status_code); |
| } |
| |
| INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest, |
| ServiceWorkerCacheTestP, |
| ::testing::Values(false, true)); |
| |
| } // namespace content |
