Skip to content

GitLab

T
tangled
Commit 9f0f48cb authored by jkarlin's avatar jkarlin Committed by Commit bot
Browse files
Options

Change ownership of the parameters to ServiceWorkerCache:: Put and Match. 

These functions used to take unowned raw pointers as arguments.  Now the functions own them and they're scoped_ptrs.  This both makes ownership clearer and allows for the functions to terminate early without calling their callbacks (needed for a downstream change to run CreateBackend lazily).

Related CLs:
* 1. https://crrev.com/542703002: Change ownership of the parameters to ServiceWorkerCache:: Put and Match.
2. https://crrev.com/545533002: Move ServiceWorkerCache backend creation to a lazy init function.
3. https://crrev.com/548533002: Make ServiceWorkerCacheStorage::CacheLoader::LoadCache synchronous
4. https://crrev.com/549493002: Expose ServiceWorkerCache objects to ServiceWorkerCacheStorageManager clients.

BUG=392621

Review URL: https://codereview.chromium.org/542703002

Cr-Commit-Position: refs/heads/master@{#294366}
parent 9d84bde1
Show whitespace changes
Inline Side-by-side
Showing with 135 additions and 109 deletions
content/browser/service_worker/service_worker_cache.cc
View file @ 9f0f48cb
......@@ -162,14 +162,14 @@ class BlobReader : public net::URLRequest::Delegate {
};
// Put callbacks
void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
ServiceWorkerResponse* response,
void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
scoped_ptr<ServiceWorkerResponse> response,
const ServiceWorkerCache::ErrorCallback& callback,
scoped_ptr<disk_cache::Entry*> entryptr,
scoped_ptr<storage::BlobDataHandle> blob_data_handle,
net::URLRequestContext* request_context,
int rv);
void PutDidWriteHeaders(ServiceWorkerResponse* response,
void PutDidWriteHeaders(scoped_ptr<ServiceWorkerResponse> response,
const ServiceWorkerCache::ErrorCallback& callback,
disk_cache::ScopedEntryPtr entry,
scoped_ptr<storage::BlobDataHandle> blob_data_handle,
......@@ -182,33 +182,33 @@ void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
bool success);
// Match callbacks
void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
scoped_ptr<disk_cache::Entry*> entryptr,
int rv);
void MatchDidReadHeaderData(
ServiceWorkerFetchRequest* request,
scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
disk_cache::ScopedEntryPtr entry,
scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
void MatchDidReadResponseBodyData(
ServiceWorkerFetchRequest* request,
scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
disk_cache::ScopedEntryPtr entry,
scoped_ptr<ServiceWorkerResponse> response,
scoped_ptr<ResponseReadContext> response_context,
int rv);
void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
scoped_ptr<ServiceWorkerResponse> response,
scoped_ptr<ResponseReadContext> response_context);
// Delete callbacks
void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ErrorCallback& callback,
scoped_ptr<disk_cache::Entry*> entryptr,
int rv);
......@@ -228,8 +228,8 @@ void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
base::WeakPtr<ServiceWorkerCache> cache,
int rv);
void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
ServiceWorkerResponse* response,
void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
scoped_ptr<ServiceWorkerResponse> response,
const ServiceWorkerCache::ErrorCallback& callback,
scoped_ptr<disk_cache::Entry*> entryptr,
scoped_ptr<storage::BlobDataHandle> blob_data_handle,
......@@ -282,7 +282,7 @@ void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
net::CompletionCallback write_headers_callback =
base::Bind(PutDidWriteHeaders,
response,
base::Passed(response.Pass()),
callback,
base::Passed(entry.Pass()),
base::Passed(blob_data_handle.Pass()),
......@@ -300,7 +300,7 @@ void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
write_headers_callback.Run(rv);
}
void PutDidWriteHeaders(ServiceWorkerResponse* response,
void PutDidWriteHeaders(scoped_ptr<ServiceWorkerResponse> response,
const ServiceWorkerCache::ErrorCallback& callback,
disk_cache::ScopedEntryPtr entry,
scoped_ptr<storage::BlobDataHandle> blob_data_handle,
......@@ -346,7 +346,7 @@ void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
callback.Run(ServiceWorkerCache::ErrorTypeOK);
}
void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
scoped_ptr<disk_cache::Entry*> entryptr,
......@@ -365,7 +365,7 @@ void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
disk_cache::Entry* tmp_entry_ptr = entry.get();
HeadersCallback headers_callback = base::Bind(MatchDidReadHeaderData,
request,
base::Passed(request.Pass()),
callback,
blob_storage,
base::Passed(entry.Pass()));
......@@ -374,7 +374,7 @@ void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
}
void MatchDidReadHeaderData(
ServiceWorkerFetchRequest* request,
scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
disk_cache::ScopedEntryPtr entry,
......@@ -431,7 +431,7 @@ void MatchDidReadHeaderData(
net::CompletionCallback read_callback =
base::Bind(MatchDidReadResponseBodyData,
request,
base::Passed(request.Pass()),
callback,
blob_storage,
base::Passed(entry.Pass()),
......@@ -449,7 +449,7 @@ void MatchDidReadHeaderData(
}
void MatchDidReadResponseBodyData(
ServiceWorkerFetchRequest* request,
scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
disk_cache::ScopedEntryPtr entry,
......@@ -464,7 +464,7 @@ void MatchDidReadResponseBodyData(
}
if (rv == 0) {
MatchDoneWithBody(request,
MatchDoneWithBody(request.Pass(),
callback,
blob_storage,
response.Pass(),
......@@ -485,7 +485,7 @@ void MatchDidReadResponseBodyData(
net::CompletionCallback read_callback =
base::Bind(MatchDidReadResponseBodyData,
request,
base::Passed(request.Pass()),
callback,
blob_storage,
base::Passed(entry.Pass()),
......@@ -502,7 +502,7 @@ void MatchDidReadResponseBodyData(
read_callback.Run(read_rv);
}
void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ResponseCallback& callback,
base::WeakPtr<storage::BlobStorageContext> blob_storage,
scoped_ptr<ServiceWorkerResponse> response,
......@@ -522,7 +522,7 @@ void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
blob_data_handle.Pass());
}
void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
const ServiceWorkerCache::ErrorCallback& callback,
scoped_ptr<disk_cache::Entry*> entryptr,
int rv) {
......@@ -686,8 +686,8 @@ void ServiceWorkerCache::CreateBackend(const ErrorCallback& callback) {
create_cache_callback.Run(rv);
}
void ServiceWorkerCache::Put(ServiceWorkerFetchRequest* request,
ServiceWorkerResponse* response,
void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
scoped_ptr<ServiceWorkerResponse> response,
const ErrorCallback& callback) {
DCHECK(backend_);
......@@ -710,23 +710,25 @@ void ServiceWorkerCache::Put(ServiceWorkerFetchRequest* request,
}
}
ServiceWorkerFetchRequest* request_ptr = request.get();
net::CompletionCallback create_entry_callback =
base::Bind(PutDidCreateEntry,
request,
response,
base::Passed(request.Pass()),
base::Passed(response.Pass()),
callback,
base::Passed(entry.Pass()),
base::Passed(blob_data_handle.Pass()),
request_context_);
int rv = backend_->CreateEntry(
request->url.spec(), entry_ptr, create_entry_callback);
request_ptr->url.spec(), entry_ptr, create_entry_callback);
if (rv != net::ERR_IO_PENDING)
create_entry_callback.Run(rv);
}
void ServiceWorkerCache::Match(ServiceWorkerFetchRequest* request,
void ServiceWorkerCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
const ResponseCallback& callback) {
DCHECK(backend_);
......@@ -734,20 +736,22 @@ void ServiceWorkerCache::Match(ServiceWorkerFetchRequest* request,
disk_cache::Entry** entry_ptr = entry.get();
ServiceWorkerFetchRequest* request_ptr = request.get();
net::CompletionCallback open_entry_callback =
base::Bind(MatchDidOpenEntry,
request,
base::Passed(request.Pass()),
callback,
blob_storage_context_,
base::Passed(entry.Pass()));
int rv =
backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
int rv = backend_->OpenEntry(
request_ptr->url.spec(), entry_ptr, open_entry_callback);
if (rv != net::ERR_IO_PENDING)
open_entry_callback.Run(rv);
}
void ServiceWorkerCache::Delete(ServiceWorkerFetchRequest* request,
void ServiceWorkerCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
const ErrorCallback& callback) {
DCHECK(backend_);
......@@ -755,11 +759,16 @@ void ServiceWorkerCache::Delete(ServiceWorkerFetchRequest* request,
disk_cache::Entry** entry_ptr = entry.get();
net::CompletionCallback open_entry_callback = base::Bind(
DeleteDidOpenEntry, request, callback, base::Passed(entry.Pass()));
ServiceWorkerFetchRequest* request_ptr = request.get();
net::CompletionCallback open_entry_callback =
base::Bind(DeleteDidOpenEntry,
base::Passed(request.Pass()),
callback,
base::Passed(entry.Pass()));
int rv =
backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
int rv = backend_->OpenEntry(
request_ptr->url.spec(), entry_ptr, open_entry_callback);
if (rv != net::ERR_IO_PENDING)
open_entry_callback.Run(rv);
}
......
content/browser/service_worker/service_worker_cache.h
View file @ 9f0f48cb
......@@ -68,21 +68,21 @@ class CONTENT_EXPORT ServiceWorkerCache {
// Returns ErrorTypeNotFound if not found. The callback will always be called.
// |request| must remain valid until the callback is called.
void Match(ServiceWorkerFetchRequest* request,
void Match(scoped_ptr<ServiceWorkerFetchRequest> request,
const ResponseCallback& callback);
// Puts the request and response object in the cache. The response body (if
// present) is stored in the cache, but not the request body. Returns
// ErrorTypeOK on success. The callback will always be called. |request| and
// |response| must remain valid until the callback is called.
void Put(ServiceWorkerFetchRequest* request,
ServiceWorkerResponse* response,
void Put(scoped_ptr<ServiceWorkerFetchRequest> request,
scoped_ptr<ServiceWorkerResponse> response,
const ErrorCallback& callback);
// Returns ErrorNotFound if not found. Otherwise deletes and returns
// ErrorTypeOK. The callback will always be called. |request| must remain
// valid until the callback is called.
void Delete(ServiceWorkerFetchRequest* request,
void Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
const ErrorCallback& callback);
// TODO(jkarlin): Have keys take an optional ServiceWorkerFetchRequest.
......
content/browser/service_worker/service_worker_cache_unittest.cc
View file @ 9f0f48cb
......@@ -93,14 +93,14 @@ class ServiceWorkerCacheTest : public testing::Test {
std::map<std::string, std::string> headers;
headers.insert(std::make_pair("a", "a"));
headers.insert(std::make_pair("b", "b"));
body_request_.reset(new ServiceWorkerFetchRequest(
GURL("http://example.com/body.html"), "GET", headers, GURL(""), false));
no_body_request_.reset(
new ServiceWorkerFetchRequest(GURL("http://example.com/no_body.html"),
body_request_ = ServiceWorkerFetchRequest(
GURL("http://example.com/body.html"), "GET", headers, GURL(""), false);
no_body_request_ =
ServiceWorkerFetchRequest(GURL("http://example.com/no_body.html"),
"GET",
headers,
GURL(""),
false));
false);
std::string expected_response;
for (int i = 0; i < 100; ++i)
......@@ -113,15 +113,14 @@ class ServiceWorkerCacheTest : public testing::Test {
blob_handle_ =
blob_storage_context->context()->AddFinishedBlob(blob_data.get());
body_response_.reset(
new ServiceWorkerResponse(GURL("http://example.com/body.html"),
body_response_ = ServiceWorkerResponse(GURL("http://example.com/body.html"),
200,
"OK",
headers,
blob_handle_->uuid()));
blob_handle_->uuid());
no_body_response_.reset(new ServiceWorkerResponse(
GURL("http://example.com/no_body.html"), 200, "OK", headers, ""));
no_body_response_ = ServiceWorkerResponse(
GURL("http://example.com/no_body.html"), 200, "OK", headers, "");
}
void CreateBackend() {
......@@ -133,12 +132,30 @@ class ServiceWorkerCacheTest : public testing::Test {
EXPECT_EQ(ServiceWorkerCache::ErrorTypeOK, callback_error_);
}
bool Put(ServiceWorkerFetchRequest* request,
ServiceWorkerResponse* response) {
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) {
return make_scoped_ptr(new ServiceWorkerResponse(response.url,
response.status_code,
response.status_text,
response.headers,
response.blob_uuid));
}
bool Put(const ServiceWorkerFetchRequest& request,
const ServiceWorkerResponse& response) {
scoped_ptr<base::RunLoop> loop(new base::RunLoop());
cache_->Put(request,
response,
cache_->Put(CopyFetchRequest(request),
CopyFetchResponse(response),
base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback,
base::Unretained(this),
base::Unretained(loop.get())));
......@@ -150,10 +167,10 @@ class ServiceWorkerCacheTest : public testing::Test {
return callback_error_ == ServiceWorkerCache::ErrorTypeOK;
}
bool Match(ServiceWorkerFetchRequest* request) {
bool Match(const ServiceWorkerFetchRequest& request) {
scoped_ptr<base::RunLoop> loop(new base::RunLoop());
cache_->Match(request,
cache_->Match(CopyFetchRequest(request),
base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback,
base::Unretained(this),
base::Unretained(loop.get())));
......@@ -162,10 +179,10 @@ class ServiceWorkerCacheTest : public testing::Test {
return callback_error_ == ServiceWorkerCache::ErrorTypeOK;
}
bool Delete(ServiceWorkerFetchRequest* request) {
bool Delete(const ServiceWorkerFetchRequest& request) {
scoped_ptr<base::RunLoop> loop(new base::RunLoop());
cache_->Delete(request,
cache_->Delete(CopyFetchRequest(request),
base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback,
base::Unretained(this),
base::Unretained(loop.get())));
......@@ -250,10 +267,10 @@ class ServiceWorkerCacheTest : public testing::Test {
base::ScopedTempDir temp_dir_;
scoped_ptr<ServiceWorkerCache> cache_;
scoped_ptr<ServiceWorkerFetchRequest> body_request_;
scoped_ptr<ServiceWorkerResponse> body_response_;
scoped_ptr<ServiceWorkerFetchRequest> no_body_request_;
scoped_ptr<ServiceWorkerResponse> no_body_response_;
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_;
......@@ -269,17 +286,17 @@ class ServiceWorkerCacheTestP : public ServiceWorkerCacheTest,
};
TEST_P(ServiceWorkerCacheTestP, PutNoBody) {
EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
EXPECT_TRUE(Put(no_body_request_, no_body_response_));
}
TEST_P(ServiceWorkerCacheTestP, PutBody) {
EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
EXPECT_TRUE(Put(body_request_, body_response_));
}
TEST_P(ServiceWorkerCacheTestP, PutBodyDropBlobRef) {
scoped_ptr<base::RunLoop> loop(new base::RunLoop());
cache_->Put(body_request_.get(),
body_response_.get(),
cache_->Put(CopyFetchRequest(body_request_),
CopyFetchResponse(body_response_),
base::Bind(&ServiceWorkerCacheTestP::ErrorTypeCallback,
base::Unretained(this),
base::Unretained(loop.get())));
......@@ -292,8 +309,8 @@ TEST_P(ServiceWorkerCacheTestP, PutBodyDropBlobRef) {
}
TEST_P(ServiceWorkerCacheTestP, MatchNoBody) {
EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
EXPECT_TRUE(Match(no_body_request_.get()));
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",
......@@ -301,8 +318,8 @@ TEST_P(ServiceWorkerCacheTestP, MatchNoBody) {
}
TEST_P(ServiceWorkerCacheTestP, MatchBody) {
EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
EXPECT_TRUE(Match(body_request_.get()));
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",
......@@ -318,31 +335,31 @@ TEST_P(ServiceWorkerCacheTestP, EmptyKeys) {
}
TEST_P(ServiceWorkerCacheTestP, TwoKeys) {
EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
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());
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_.get(), no_body_response_.get()));
EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
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());
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_.get()));
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());
expected_key.push_back(no_body_request_.url.spec());
EXPECT_TRUE(VerifyKeys(expected_key));
}
......@@ -351,42 +368,42 @@ TEST_P(ServiceWorkerCacheTestP, TwoKeysThenOne) {
// flaky (though not crashy). See https://crbug.com/409109
#ifndef OS_WIN
TEST_P(ServiceWorkerCacheTestP, DeleteNoBody) {
EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
EXPECT_TRUE(Match(no_body_request_.get()));
EXPECT_TRUE(Delete(no_body_request_.get()));
EXPECT_FALSE(Match(no_body_request_.get()));
EXPECT_FALSE(Delete(no_body_request_.get()));
EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
EXPECT_TRUE(Match(no_body_request_.get()));
EXPECT_TRUE(Delete(no_body_request_.get()));
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_.get(), body_response_.get()));
EXPECT_TRUE(Match(body_request_.get()));
EXPECT_TRUE(Delete(body_request_.get()));
EXPECT_FALSE(Match(body_request_.get()));
EXPECT_FALSE(Delete(body_request_.get()));
EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
EXPECT_TRUE(Match(body_request_.get()));
EXPECT_TRUE(Delete(body_request_.get()));
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_.get()));
EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
EXPECT_TRUE(Match(no_body_request_.get()));
EXPECT_TRUE(Delete(no_body_request_.get()));
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_.get()));
ASSERT_TRUE(Put(body_request_.get(), body_response_.get()));
ASSERT_TRUE(Match(body_request_.get()));
ASSERT_TRUE(Delete(body_request_.get()));
ASSERT_FALSE(Match(body_request_));
ASSERT_TRUE(Put(body_request_, body_response_));
ASSERT_TRUE(Match(body_request_));
ASSERT_TRUE(Delete(body_request_));
}
}
#endif // OS_WIN
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment