Skip to content

GitLab

T
tangled
Commit 08ab4773 authored by Kenichi Ishibashi's avatar Kenichi Ishibashi Committed by Commit Bot
Browse files
Options

Stop using AppCacheResponseMetadataWriter from service workers 

This CL removes AppCacheResponseMetadataWriter dependency from
ServiceWorkerResourceMetadataWriter by re-implementing the writer.
See [1] for the reasoning of the rewrite.

This CL should not have behavior changes, and existing tests cover
this change.

[1] https://docs.google.com/document/d/1UhdZnaeEP8GywZR0Gik6wF6jKmNY3je6aDhPfJ05YhU/edit?usp=sharing

Bug: 1117369
Change-Id: I47ce15de539eb23746f1154377f3d8650d951b7a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2440321
Commit-Queue: Victor Costan <pwnall@chromium.org>
Reviewed-by: default avatarMakoto Shimazu <shimazu@chromium.org>
Reviewed-by: default avatarVictor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#815776}
parent fa264619
Show whitespace changes
Inline Side-by-side
Showing with 254 additions and 193 deletions
content/browser/service_worker/service_worker_disk_cache.cc
View file @ 08ab4773
...@@ -14,9 +14,4 @@ namespace content { ...@@ -14,9 +14,4 @@ namespace content {
ServiceWorkerDiskCache::ServiceWorkerDiskCache() ServiceWorkerDiskCache::ServiceWorkerDiskCache()
: AppCacheDiskCache(/*use_simple_cache=*/true) {} : AppCacheDiskCache(/*use_simple_cache=*/true) {}
ServiceWorkerResponseMetadataWriter::ServiceWorkerResponseMetadataWriter(
int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache)
: AppCacheResponseMetadataWriter(resource_id, std::move(disk_cache)) {}
} // namespace content } // namespace content
content/browser/service_worker/service_worker_disk_cache.h
View file @ 08ab4773
...@@ -5,13 +5,8 @@ ...@@ -5,13 +5,8 @@
#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_ #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_
#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_ #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_
#include <stdint.h>
#include "base/memory/weak_ptr.h"
#include "content/browser/appcache/appcache_disk_cache.h" #include "content/browser/appcache/appcache_disk_cache.h"
#include "content/browser/appcache/appcache_disk_cache_ops.h"
#include "content/common/content_export.h" #include "content/common/content_export.h"
#include "services/network/public/mojom/url_response_head.mojom.h"
namespace content { namespace content {
...@@ -26,19 +21,6 @@ class CONTENT_EXPORT ServiceWorkerDiskCache : public AppCacheDiskCache { ...@@ -26,19 +21,6 @@ class CONTENT_EXPORT ServiceWorkerDiskCache : public AppCacheDiskCache {
ServiceWorkerDiskCache(); ServiceWorkerDiskCache();
}; };
// TODO(crbug.com/1117369): Migrate to
// storage::mojom::ServiceWorkerResourceMetadataWriter.
class CONTENT_EXPORT ServiceWorkerResponseMetadataWriter
: public AppCacheResponseMetadataWriter {
protected:
// Should only be constructed by the storage class.
friend class ServiceWorkerStorage;
ServiceWorkerResponseMetadataWriter(
int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache);
};
} // namespace content } // namespace content
#endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_ #endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_
content/browser/service_worker/service_worker_resource_ops.cc
View file @ 08ab4773
...@@ -124,20 +124,20 @@ mojo_base::BigBuffer BigIOBuffer::TakeBuffer() { ...@@ -124,20 +124,20 @@ mojo_base::BigBuffer BigIOBuffer::TakeBuffer() {
return std::move(buffer_); return std::move(buffer_);
} }
DiskEntryManager::DiskEntryManager(int64_t resource_id, DiskEntryCreator::DiskEntryCreator(int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache) base::WeakPtr<AppCacheDiskCache> disk_cache)
: resource_id_(resource_id), disk_cache_(std::move(disk_cache)) { : resource_id_(resource_id), disk_cache_(std::move(disk_cache)) {
DCHECK_NE(resource_id_, blink::mojom::kInvalidServiceWorkerResourceId); DCHECK_NE(resource_id_, blink::mojom::kInvalidServiceWorkerResourceId);
DCHECK(disk_cache_); DCHECK(disk_cache_);
} }
DiskEntryManager::~DiskEntryManager() { DiskEntryCreator::~DiskEntryCreator() {
if (entry_) { if (entry_) {
entry_->Close(); entry_->Close();
} }
} }
void DiskEntryManager::EnsureEntryIsCreated(base::OnceClosure callback) { void DiskEntryCreator::EnsureEntryIsCreated(base::OnceClosure callback) {
DCHECK(creation_phase_ == CreationPhase::kNoAttempt || DCHECK(creation_phase_ == CreationPhase::kNoAttempt ||
creation_phase_ == CreationPhase::kDone); creation_phase_ == CreationPhase::kDone);
DCHECK(!ensure_entry_is_created_callback_); DCHECK(!ensure_entry_is_created_callback_);
...@@ -166,22 +166,22 @@ void DiskEntryManager::EnsureEntryIsCreated(base::OnceClosure callback) { ...@@ -166,22 +166,22 @@ void DiskEntryManager::EnsureEntryIsCreated(base::OnceClosure callback) {
} }
// static // static
void DiskEntryManager::DidCreateEntryForFirstAttempt( void DiskEntryCreator::DidCreateEntryForFirstAttempt(
base::WeakPtr<DiskEntryManager> entry_manager, base::WeakPtr<DiskEntryCreator> entry_creator,
AppCacheDiskCacheEntry** entry, AppCacheDiskCacheEntry** entry,
int rv) { int rv) {
if (!entry_manager) { if (!entry_creator) {
delete entry; delete entry;
return; return;
} }
DCHECK_EQ(entry_manager->creation_phase_, CreationPhase::kInitialAttempt); DCHECK_EQ(entry_creator->creation_phase_, CreationPhase::kInitialAttempt);
DCHECK(!entry_manager->entry_); DCHECK(!entry_creator->entry_);
if (!entry_manager->disk_cache_) { if (!entry_creator->disk_cache_) {
delete entry; delete entry;
entry_manager->entry_ = nullptr; entry_creator->entry_ = nullptr;
entry_manager->RunEnsureEntryIsCreatedCallback(); entry_creator->RunEnsureEntryIsCreatedCallback();
return; return;
} }
...@@ -189,89 +189,144 @@ void DiskEntryManager::DidCreateEntryForFirstAttempt( ...@@ -189,89 +189,144 @@ void DiskEntryManager::DidCreateEntryForFirstAttempt(
// The first attempt to create an entry is failed. Try to overwrite the // The first attempt to create an entry is failed. Try to overwrite the
// existing entry. // existing entry.
delete entry; delete entry;
entry_manager->creation_phase_ = CreationPhase::kDoomExisting; entry_creator->creation_phase_ = CreationPhase::kDoomExisting;
rv = entry_manager->disk_cache_->DoomEntry( rv = entry_creator->disk_cache_->DoomEntry(
entry_manager->resource_id_, entry_creator->resource_id_,
base::BindOnce(&DiskEntryManager::DidDoomExistingEntry, entry_manager)); base::BindOnce(&DiskEntryCreator::DidDoomExistingEntry, entry_creator));
if (rv != net::ERR_IO_PENDING) { if (rv != net::ERR_IO_PENDING) {
DidDoomExistingEntry(entry_manager, rv); DidDoomExistingEntry(entry_creator, rv);
} }
return; return;
} }
DCHECK(entry); DCHECK(entry);
entry_manager->entry_ = *entry; entry_creator->entry_ = *entry;
delete entry; delete entry;
entry_manager->RunEnsureEntryIsCreatedCallback(); entry_creator->RunEnsureEntryIsCreatedCallback();
} }
// static // static
void DiskEntryManager::DidDoomExistingEntry( void DiskEntryCreator::DidDoomExistingEntry(
base::WeakPtr<DiskEntryManager> entry_manager, base::WeakPtr<DiskEntryCreator> entry_creator,
int rv) { int rv) {
if (!entry_manager) { if (!entry_creator) {
return; return;
} }
DCHECK_EQ(entry_manager->creation_phase_, CreationPhase::kDoomExisting); DCHECK_EQ(entry_creator->creation_phase_, CreationPhase::kDoomExisting);
DCHECK(!entry_manager->entry_); DCHECK(!entry_creator->entry_);
if (!entry_manager->disk_cache_) { if (!entry_creator->disk_cache_) {
entry_manager->entry_ = nullptr; entry_creator->entry_ = nullptr;
entry_manager->RunEnsureEntryIsCreatedCallback(); entry_creator->RunEnsureEntryIsCreatedCallback();
return; return;
} }
entry_manager->creation_phase_ = CreationPhase::kSecondAttempt; entry_creator->creation_phase_ = CreationPhase::kSecondAttempt;
auto** entry_ptr = new AppCacheDiskCacheEntry*; auto** entry_ptr = new AppCacheDiskCacheEntry*;
rv = entry_manager->disk_cache_->CreateEntry( rv = entry_creator->disk_cache_->CreateEntry(
entry_manager->resource_id_, entry_ptr, entry_creator->resource_id_, entry_ptr,
base::BindOnce(&DiskEntryManager::DidCreateEntryForSecondAttempt, base::BindOnce(&DiskEntryCreator::DidCreateEntryForSecondAttempt,
entry_manager, entry_ptr)); entry_creator, entry_ptr));
if (rv != net::ERR_IO_PENDING) { if (rv != net::ERR_IO_PENDING) {
DidCreateEntryForSecondAttempt(entry_manager, entry_ptr, rv); DidCreateEntryForSecondAttempt(entry_creator, entry_ptr, rv);
} }
} }
// static // static
void DiskEntryManager::DidCreateEntryForSecondAttempt( void DiskEntryCreator::DidCreateEntryForSecondAttempt(
base::WeakPtr<DiskEntryManager> entry_manager, base::WeakPtr<DiskEntryCreator> entry_creator,
AppCacheDiskCacheEntry** entry, AppCacheDiskCacheEntry** entry,
int rv) { int rv) {
if (!entry_manager) { if (!entry_creator) {
delete entry; delete entry;
return; return;
} }
DCHECK_EQ(entry_manager->creation_phase_, CreationPhase::kSecondAttempt); DCHECK_EQ(entry_creator->creation_phase_, CreationPhase::kSecondAttempt);
if (!entry_manager->disk_cache_) { if (!entry_creator->disk_cache_) {
delete entry; delete entry;
entry_manager->entry_ = nullptr; entry_creator->entry_ = nullptr;
entry_manager->RunEnsureEntryIsCreatedCallback(); entry_creator->RunEnsureEntryIsCreatedCallback();
return; return;
} }
if (rv != net::OK) { if (rv != net::OK) {
// The second attempt is also failed. Give up creating an entry. // The second attempt is also failed. Give up creating an entry.
delete entry; delete entry;
entry_manager->entry_ = nullptr; entry_creator->entry_ = nullptr;
entry_manager->RunEnsureEntryIsCreatedCallback(); entry_creator->RunEnsureEntryIsCreatedCallback();
return; return;
} }
DCHECK(!entry_manager->entry_); DCHECK(!entry_creator->entry_);
DCHECK(entry); DCHECK(entry);
entry_manager->entry_ = *entry; entry_creator->entry_ = *entry;
entry_manager->RunEnsureEntryIsCreatedCallback(); entry_creator->RunEnsureEntryIsCreatedCallback();
delete entry; delete entry;
} }
void DiskEntryManager::RunEnsureEntryIsCreatedCallback() { void DiskEntryCreator::RunEnsureEntryIsCreatedCallback() {
creation_phase_ = CreationPhase::kDone; creation_phase_ = CreationPhase::kDone;
std::move(ensure_entry_is_created_callback_).Run(); std::move(ensure_entry_is_created_callback_).Run();
} }
DiskEntryOpener::DiskEntryOpener(int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache)
: resource_id_(resource_id), disk_cache_(std::move(disk_cache)) {
DCHECK_NE(resource_id_, blink::mojom::kInvalidServiceWorkerResourceId);
DCHECK(disk_cache_);
}
DiskEntryOpener::~DiskEntryOpener() {
if (entry_) {
entry_->Close();
}
}
void DiskEntryOpener::EnsureEntryIsOpen(base::OnceClosure callback) {
DCHECK(!ensure_entry_is_opened_callback_);
ensure_entry_is_opened_callback_ = std::move(callback);
int rv;
AppCacheDiskCacheEntry** entry_ptr = nullptr;
if (entry_) {
rv = net::OK;
} else if (!disk_cache_) {
rv = net::ERR_FAILED;
} else {
entry_ptr = new AppCacheDiskCacheEntry*;
rv = disk_cache_->OpenEntry(
resource_id_, entry_ptr,
base::BindOnce(&DiskEntryOpener::DidOpenEntry,
weak_factory_.GetWeakPtr(), entry_ptr));
}
if (rv != net::ERR_IO_PENDING) {
DidOpenEntry(weak_factory_.GetWeakPtr(), entry_ptr, rv);
}
}
// static
void DiskEntryOpener::DidOpenEntry(base::WeakPtr<DiskEntryOpener> entry_opener,
AppCacheDiskCacheEntry** entry,
int rv) {
if (!entry_opener) {
delete entry;
return;
}
if (!entry_opener->entry_ && rv == net::OK) {
DCHECK(entry);
entry_opener->entry_ = *entry;
}
delete entry;
DCHECK(entry_opener->ensure_entry_is_opened_callback_);
std::move(entry_opener->ensure_entry_is_opened_callback_).Run();
}
class ServiceWorkerResourceReaderImpl::DataReader { class ServiceWorkerResourceReaderImpl::DataReader {
public: public:
DataReader( DataReader(
...@@ -301,8 +356,8 @@ class ServiceWorkerResourceReaderImpl::DataReader { ...@@ -301,8 +356,8 @@ class ServiceWorkerResourceReaderImpl::DataReader {
state_ = State::kStarted; state_ = State::kStarted;
#endif #endif
owner_->EnsureEntryIsOpen(base::BindOnce(&DataReader::ContinueReadData, owner_->entry_opener_.EnsureEntryIsOpen(base::BindOnce(
weak_factory_.GetWeakPtr())); &DataReader::ContinueReadData, weak_factory_.GetWeakPtr()));
} }
private: private:
...@@ -317,7 +372,7 @@ class ServiceWorkerResourceReaderImpl::DataReader { ...@@ -317,7 +372,7 @@ class ServiceWorkerResourceReaderImpl::DataReader {
return; return;
} }
if (!owner_->entry_) { if (!owner_->entry_opener_.entry()) {
Complete(net::ERR_CACHE_MISS); Complete(net::ERR_CACHE_MISS);
return; return;
} }
...@@ -337,7 +392,7 @@ class ServiceWorkerResourceReaderImpl::DataReader { ...@@ -337,7 +392,7 @@ class ServiceWorkerResourceReaderImpl::DataReader {
DCHECK(producer_handle_.is_valid()); DCHECK(producer_handle_.is_valid());
DCHECK(!pending_buffer_); DCHECK(!pending_buffer_);
if (!owner_ || !owner_->entry_) { if (!owner_ || !owner_->entry_opener_.entry()) {
Complete(net::ERR_ABORTED); Complete(net::ERR_ABORTED);
return; return;
} }
...@@ -368,7 +423,7 @@ class ServiceWorkerResourceReaderImpl::DataReader { ...@@ -368,7 +423,7 @@ class ServiceWorkerResourceReaderImpl::DataReader {
base::MakeRefCounted<network::NetToMojoIOBuffer>(pending_buffer_.get()); base::MakeRefCounted<network::NetToMojoIOBuffer>(pending_buffer_.get());
net::IOBuffer* raw_buffer = buffer.get(); net::IOBuffer* raw_buffer = buffer.get();
int read_bytes = owner_->entry_->Read( int read_bytes = owner_->entry_opener_.entry()->Read(
kResponseContentIndex, current_bytes_read_, raw_buffer, num_bytes, kResponseContentIndex, current_bytes_read_, raw_buffer, num_bytes,
base::BindOnce(&DataReader::DidReadData, weak_factory_.GetWeakPtr(), base::BindOnce(&DataReader::DidReadData, weak_factory_.GetWeakPtr(),
buffer)); buffer));
...@@ -446,16 +501,9 @@ class ServiceWorkerResourceReaderImpl::DataReader { ...@@ -446,16 +501,9 @@ class ServiceWorkerResourceReaderImpl::DataReader {
ServiceWorkerResourceReaderImpl::ServiceWorkerResourceReaderImpl( ServiceWorkerResourceReaderImpl::ServiceWorkerResourceReaderImpl(
int64_t resource_id, int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache) base::WeakPtr<AppCacheDiskCache> disk_cache)
: resource_id_(resource_id), disk_cache_(std::move(disk_cache)) { : entry_opener_(resource_id, std::move(disk_cache)) {}
DCHECK_NE(resource_id_, blink::mojom::kInvalidServiceWorkerResourceId);
DCHECK(disk_cache_);
}
ServiceWorkerResourceReaderImpl::~ServiceWorkerResourceReaderImpl() { ServiceWorkerResourceReaderImpl::~ServiceWorkerResourceReaderImpl() = default;
if (entry_) {
entry_->Close();
}
}
void ServiceWorkerResourceReaderImpl::ReadResponseHead( void ServiceWorkerResourceReaderImpl::ReadResponseHead(
ReadResponseHeadCallback callback) { ReadResponseHeadCallback callback) {
...@@ -469,7 +517,7 @@ void ServiceWorkerResourceReaderImpl::ReadResponseHead( ...@@ -469,7 +517,7 @@ void ServiceWorkerResourceReaderImpl::ReadResponseHead(
DCHECK(!data_reader_); DCHECK(!data_reader_);
read_response_head_callback_ = std::move(callback); read_response_head_callback_ = std::move(callback);
EnsureEntryIsOpen( entry_opener_.EnsureEntryIsOpen(
base::BindOnce(&ServiceWorkerResourceReaderImpl::ContinueReadResponseHead, base::BindOnce(&ServiceWorkerResourceReaderImpl::ContinueReadResponseHead,
weak_factory_.GetWeakPtr())); weak_factory_.GetWeakPtr()));
} }
...@@ -517,12 +565,12 @@ void ServiceWorkerResourceReaderImpl::ContinueReadResponseHead() { ...@@ -517,12 +565,12 @@ void ServiceWorkerResourceReaderImpl::ContinueReadResponseHead() {
#endif #endif
DCHECK(read_response_head_callback_); DCHECK(read_response_head_callback_);
if (!entry_) { if (!entry_opener_.entry()) {
FailReadResponseHead(net::ERR_CACHE_MISS); FailReadResponseHead(net::ERR_CACHE_MISS);
return; return;
} }
int64_t size = entry_->GetSize(kResponseInfoIndex); int64_t size = entry_opener_.entry()->GetSize(kResponseInfoIndex);
if (size <= 0) { if (size <= 0) {
FailReadResponseHead(net::ERR_CACHE_MISS); FailReadResponseHead(net::ERR_CACHE_MISS);
return; return;
...@@ -530,7 +578,7 @@ void ServiceWorkerResourceReaderImpl::ContinueReadResponseHead() { ...@@ -530,7 +578,7 @@ void ServiceWorkerResourceReaderImpl::ContinueReadResponseHead() {
auto buffer = auto buffer =
base::MakeRefCounted<net::IOBuffer>(base::checked_cast<size_t>(size)); base::MakeRefCounted<net::IOBuffer>(base::checked_cast<size_t>(size));
int rv = entry_->Read( int rv = entry_opener_.entry()->Read(
kResponseInfoIndex, /*offset=*/0, buffer.get(), size, kResponseInfoIndex, /*offset=*/0, buffer.get(), size,
base::BindOnce(&ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo, base::BindOnce(&ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo,
weak_factory_.GetWeakPtr(), buffer)); weak_factory_.GetWeakPtr(), buffer));
...@@ -547,7 +595,7 @@ void ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo( ...@@ -547,7 +595,7 @@ void ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo(
state_ = State::kResponseInfoRead; state_ = State::kResponseInfoRead;
#endif #endif
DCHECK(read_response_head_callback_); DCHECK(read_response_head_callback_);
DCHECK(entry_); DCHECK(entry_opener_.entry());
if (status < 0) { if (status < 0) {
FailReadResponseHead(status); FailReadResponseHead(status);
...@@ -565,11 +613,13 @@ void ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo( ...@@ -565,11 +613,13 @@ void ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo(
} }
DCHECK(!response_truncated); DCHECK(!response_truncated);
int64_t response_data_size = entry_->GetSize(kResponseContentIndex); int64_t response_data_size =
entry_opener_.entry()->GetSize(kResponseContentIndex);
response_head_ = ConvertHttpResponseInfo(*http_info, response_data_size); response_head_ = ConvertHttpResponseInfo(*http_info, response_data_size);
int64_t metadata_size = entry_->GetSize(kResponseMetadataIndex); int64_t metadata_size =
entry_opener_.entry()->GetSize(kResponseMetadataIndex);
DCHECK_GE(metadata_size, 0); DCHECK_GE(metadata_size, 0);
if (metadata_size <= 0) { if (metadata_size <= 0) {
CompleteReadResponseHead(status); CompleteReadResponseHead(status);
...@@ -579,7 +629,7 @@ void ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo( ...@@ -579,7 +629,7 @@ void ServiceWorkerResourceReaderImpl::DidReadHttpResponseInfo(
// Read metadata. // Read metadata.
metadata_buffer_ = base::MakeRefCounted<BigIOBuffer>( metadata_buffer_ = base::MakeRefCounted<BigIOBuffer>(
mojo_base::BigBuffer(base::checked_cast<size_t>(metadata_size))); mojo_base::BigBuffer(base::checked_cast<size_t>(metadata_size)));
int rv = entry_->Read( int rv = entry_opener_.entry()->Read(
kResponseMetadataIndex, /*offset=*/0, metadata_buffer_.get(), kResponseMetadataIndex, /*offset=*/0, metadata_buffer_.get(),
metadata_size, metadata_size,
base::BindOnce(&ServiceWorkerResourceReaderImpl::DidReadMetadata, base::BindOnce(&ServiceWorkerResourceReaderImpl::DidReadMetadata,
...@@ -639,53 +689,10 @@ void ServiceWorkerResourceReaderImpl::DidReadDataComplete() { ...@@ -639,53 +689,10 @@ void ServiceWorkerResourceReaderImpl::DidReadDataComplete() {
data_reader_.reset(); data_reader_.reset();
} }
void ServiceWorkerResourceReaderImpl::EnsureEntryIsOpen(
base::OnceClosure callback) {
DCHECK(!open_entry_callback_);
open_entry_callback_ = std::move(callback);
int rv;
AppCacheDiskCacheEntry** entry_ptr = nullptr;
if (entry_) {
rv = net::OK;
} else if (!disk_cache_) {
rv = net::ERR_FAILED;
} else {
entry_ptr = new AppCacheDiskCacheEntry*;
rv = disk_cache_->OpenEntry(
resource_id_, entry_ptr,
base::BindOnce(&DidOpenEntry, weak_factory_.GetWeakPtr(), entry_ptr));
}
if (rv != net::ERR_IO_PENDING) {
DidOpenEntry(weak_factory_.GetWeakPtr(), entry_ptr, rv);
}
}
// static
void ServiceWorkerResourceReaderImpl::DidOpenEntry(
base::WeakPtr<ServiceWorkerResourceReaderImpl> reader,
AppCacheDiskCacheEntry** entry,
int rv) {
if (!reader) {
delete entry;
return;
}
if (!reader->entry_ && rv == net::OK) {
DCHECK(entry);
reader->entry_ = *entry;
}
delete entry;
DCHECK(reader->open_entry_callback_);
std::move(reader->open_entry_callback_).Run();
}
ServiceWorkerResourceWriterImpl::ServiceWorkerResourceWriterImpl( ServiceWorkerResourceWriterImpl::ServiceWorkerResourceWriterImpl(
int64_t resource_id, int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache) base::WeakPtr<AppCacheDiskCache> disk_cache)
: entry_manager_(resource_id, std::move(disk_cache)) {} : entry_creator_(resource_id, std::move(disk_cache)) {}
ServiceWorkerResourceWriterImpl::~ServiceWorkerResourceWriterImpl() = default; ServiceWorkerResourceWriterImpl::~ServiceWorkerResourceWriterImpl() = default;
...@@ -696,7 +703,7 @@ void ServiceWorkerResourceWriterImpl::WriteResponseHead( ...@@ -696,7 +703,7 @@ void ServiceWorkerResourceWriterImpl::WriteResponseHead(
DCHECK_EQ(state_, State::kIdle); DCHECK_EQ(state_, State::kIdle);
state_ = State::kWriteResponseHeadStarted; state_ = State::kWriteResponseHeadStarted;
#endif #endif
entry_manager_.EnsureEntryIsCreated( entry_creator_.EnsureEntryIsCreated(
base::BindOnce(&ServiceWorkerResourceWriterImpl::WriteResponseHeadToEntry, base::BindOnce(&ServiceWorkerResourceWriterImpl::WriteResponseHeadToEntry,
weak_factory_.GetWeakPtr(), std::move(response_head), weak_factory_.GetWeakPtr(), std::move(response_head),
std::move(callback))); std::move(callback)));
...@@ -708,7 +715,7 @@ void ServiceWorkerResourceWriterImpl::WriteData(mojo_base::BigBuffer data, ...@@ -708,7 +715,7 @@ void ServiceWorkerResourceWriterImpl::WriteData(mojo_base::BigBuffer data,
DCHECK_EQ(state_, State::kIdle); DCHECK_EQ(state_, State::kIdle);
state_ = State::kWriteDataStarted; state_ = State::kWriteDataStarted;
#endif #endif
entry_manager_.EnsureEntryIsCreated(base::BindOnce( entry_creator_.EnsureEntryIsCreated(base::BindOnce(
&ServiceWorkerResourceWriterImpl::WriteDataToEntry, &ServiceWorkerResourceWriterImpl::WriteDataToEntry,
weak_factory_.GetWeakPtr(), std::move(data), std::move(callback))); weak_factory_.GetWeakPtr(), std::move(data), std::move(callback)));
} }
...@@ -720,7 +727,7 @@ void ServiceWorkerResourceWriterImpl::WriteResponseHeadToEntry( ...@@ -720,7 +727,7 @@ void ServiceWorkerResourceWriterImpl::WriteResponseHeadToEntry(
DCHECK_EQ(state_, State::kWriteResponseHeadStarted); DCHECK_EQ(state_, State::kWriteResponseHeadStarted);
state_ = State::kWriteResponseHeadHasEntry; state_ = State::kWriteResponseHeadHasEntry;
#endif #endif
if (!entry_manager_.entry()) { if (!entry_creator_.entry()) {
std::move(callback).Run(net::ERR_FAILED); std::move(callback).Run(net::ERR_FAILED);
return; return;
} }
...@@ -733,7 +740,7 @@ void ServiceWorkerResourceWriterImpl::WriteResponseHeadToEntry( ...@@ -733,7 +740,7 @@ void ServiceWorkerResourceWriterImpl::WriteResponseHeadToEntry(
auto buffer = base::MakeRefCounted<WrappedPickleIOBuffer>(std::move(pickle)); auto buffer = base::MakeRefCounted<WrappedPickleIOBuffer>(std::move(pickle));
size_t write_amount = buffer->size(); size_t write_amount = buffer->size();
int rv = entry_manager_.entry()->Write( int rv = entry_creator_.entry()->Write(
kResponseInfoIndex, /*offset=*/0, buffer.get(), write_amount, kResponseInfoIndex, /*offset=*/0, buffer.get(), write_amount,
base::BindOnce(&ServiceWorkerResourceWriterImpl::DidWriteResponseHead, base::BindOnce(&ServiceWorkerResourceWriterImpl::DidWriteResponseHead,
weak_factory_.GetWeakPtr(), buffer, write_amount)); weak_factory_.GetWeakPtr(), buffer, write_amount));
...@@ -762,7 +769,7 @@ void ServiceWorkerResourceWriterImpl::WriteDataToEntry( ...@@ -762,7 +769,7 @@ void ServiceWorkerResourceWriterImpl::WriteDataToEntry(
DCHECK_EQ(state_, State::kWriteDataStarted); DCHECK_EQ(state_, State::kWriteDataStarted);
state_ = State::kWriteDataHasEntry; state_ = State::kWriteDataHasEntry;
#endif #endif
if (!entry_manager_.entry()) { if (!entry_creator_.entry()) {
std::move(callback).Run(net::ERR_FAILED); std::move(callback).Run(net::ERR_FAILED);
return; return;
} }
...@@ -772,7 +779,7 @@ void ServiceWorkerResourceWriterImpl::WriteDataToEntry( ...@@ -772,7 +779,7 @@ void ServiceWorkerResourceWriterImpl::WriteDataToEntry(
size_t write_amount = data.size(); size_t write_amount = data.size();
auto buffer = base::MakeRefCounted<BigIOBuffer>(std::move(data)); auto buffer = base::MakeRefCounted<BigIOBuffer>(std::move(data));
int rv = entry_manager_.entry()->Write( int rv = entry_creator_.entry()->Write(
kResponseContentIndex, write_position_, buffer.get(), write_amount, kResponseContentIndex, write_position_, buffer.get(), write_amount,
base::BindOnce(&ServiceWorkerResourceWriterImpl::DidWriteData, base::BindOnce(&ServiceWorkerResourceWriterImpl::DidWriteData,
weak_factory_.GetWeakPtr(), buffer, write_amount)); weak_factory_.GetWeakPtr(), buffer, write_amount));
...@@ -799,10 +806,9 @@ void ServiceWorkerResourceWriterImpl::DidWriteData( ...@@ -799,10 +806,9 @@ void ServiceWorkerResourceWriterImpl::DidWriteData(
ServiceWorkerResourceMetadataWriterImpl:: ServiceWorkerResourceMetadataWriterImpl::
ServiceWorkerResourceMetadataWriterImpl( ServiceWorkerResourceMetadataWriterImpl(
std::unique_ptr<ServiceWorkerResponseMetadataWriter> writer) int64_t resource_id,
: writer_(std::move(writer)) { base::WeakPtr<AppCacheDiskCache> disk_cache)
DCHECK(writer_); : entry_opener_(resource_id, std::move(disk_cache)) {}
}
ServiceWorkerResourceMetadataWriterImpl:: ServiceWorkerResourceMetadataWriterImpl::
~ServiceWorkerResourceMetadataWriterImpl() = default; ~ServiceWorkerResourceMetadataWriterImpl() = default;
...@@ -810,9 +816,51 @@ ServiceWorkerResourceMetadataWriterImpl:: ...@@ -810,9 +816,51 @@ ServiceWorkerResourceMetadataWriterImpl::
void ServiceWorkerResourceMetadataWriterImpl::WriteMetadata( void ServiceWorkerResourceMetadataWriterImpl::WriteMetadata(
mojo_base::BigBuffer data, mojo_base::BigBuffer data,
WriteMetadataCallback callback) { WriteMetadataCallback callback) {
int buf_len = data.size(); #if DCHECK_IS_ON()
DCHECK_EQ(state_, State::kIdle);
state_ = State::kWriteMetadataStarted;
#endif
entry_opener_.EnsureEntryIsOpen(base::BindOnce(
&ServiceWorkerResourceMetadataWriterImpl::ContinueWriteMetadata,
weak_factory_.GetWeakPtr(), std::move(data), std::move(callback)));
}
void ServiceWorkerResourceMetadataWriterImpl::ContinueWriteMetadata(
mojo_base::BigBuffer data,
WriteMetadataCallback callback) {
#if DCHECK_IS_ON()
DCHECK_EQ(state_, State::kWriteMetadataStarted);
state_ = State::kWriteMetadataHasEntry;
#endif
if (!entry_opener_.entry()) {
std::move(callback).Run(net::ERR_FAILED);
return;
}
DCHECK(!write_metadata_callback_);
write_metadata_callback_ = std::move(callback);
size_t write_amount = data.size();
auto buffer = base::MakeRefCounted<BigIOBuffer>(std::move(data)); auto buffer = base::MakeRefCounted<BigIOBuffer>(std::move(data));
writer_->WriteMetadata(buffer.get(), buf_len, std::move(callback)); int rv = entry_opener_.entry()->Write(
kResponseMetadataIndex, /*offset=*/0, buffer.get(), write_amount,
base::BindOnce(&ServiceWorkerResourceMetadataWriterImpl::DidWriteMetadata,
weak_factory_.GetWeakPtr(), buffer, write_amount));
if (rv != net::ERR_IO_PENDING) {
DidWriteMetadata(std::move(buffer), write_amount, rv);
}
}
void ServiceWorkerResourceMetadataWriterImpl::DidWriteMetadata(
scoped_refptr<net::IOBuffer> buffer,
size_t write_amount,
int rv) {
#if DCHECK_IS_ON()
DCHECK_EQ(state_, State::kWriteMetadataHasEntry);
state_ = State::kIdle;
#endif
DCHECK(rv < 0 || base::checked_cast<size_t>(rv) == write_amount);
DCHECK(write_metadata_callback_);
std::move(write_metadata_callback_).Run(rv);
} }
} // namespace content } // namespace content
content/browser/service_worker/service_worker_resource_ops.h
View file @ 08ab4773
...@@ -13,16 +13,15 @@ namespace content { ...@@ -13,16 +13,15 @@ namespace content {
class BigIOBuffer; class BigIOBuffer;
// Manages a service worker disk cache entry. Creates and owns an entry. // Creates and owns a service worker disk cacke entry.
// TODO(bashi): Used by resource writers. Use in readers as well. class DiskEntryCreator {
class DiskEntryManager {
public: public:
DiskEntryManager(int64_t resource_id, DiskEntryCreator(int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache); base::WeakPtr<AppCacheDiskCache> disk_cache);
~DiskEntryManager(); ~DiskEntryCreator();
DiskEntryManager(const DiskEntryManager&) = delete; DiskEntryCreator(const DiskEntryCreator&) = delete;
DiskEntryManager& operator=(const DiskEntryManager&) = delete; DiskEntryCreator& operator=(const DiskEntryCreator&) = delete;
// Can be nullptr when a disk cache error occurs. // Can be nullptr when a disk cache error occurs.
AppCacheDiskCacheEntry* entry() { AppCacheDiskCacheEntry* entry() {
...@@ -58,14 +57,14 @@ class DiskEntryManager { ...@@ -58,14 +57,14 @@ class DiskEntryManager {
// TODO(crbug.com/586174): Refactor service worker's disk cache to use // TODO(crbug.com/586174): Refactor service worker's disk cache to use
// disk_cache::EntryResult to make these callbacks non-static. // disk_cache::EntryResult to make these callbacks non-static.
static void DidCreateEntryForFirstAttempt( static void DidCreateEntryForFirstAttempt(
base::WeakPtr<DiskEntryManager> entry_manager, base::WeakPtr<DiskEntryCreator> entry_creator,
AppCacheDiskCacheEntry** entry, AppCacheDiskCacheEntry** entry,
int rv); int rv);
static void DidDoomExistingEntry( static void DidDoomExistingEntry(
base::WeakPtr<DiskEntryManager> entry_manager, base::WeakPtr<DiskEntryCreator> entry_creator,
int rv); int rv);
static void DidCreateEntryForSecondAttempt( static void DidCreateEntryForSecondAttempt(
base::WeakPtr<DiskEntryManager> entry_manager, base::WeakPtr<DiskEntryCreator> entry_creator,
AppCacheDiskCacheEntry** entry, AppCacheDiskCacheEntry** entry,
int rv); int rv);
...@@ -80,7 +79,44 @@ class DiskEntryManager { ...@@ -80,7 +79,44 @@ class DiskEntryManager {
// Stored as a data member to handle //net-style maybe-async methods. // Stored as a data member to handle //net-style maybe-async methods.
base::OnceClosure ensure_entry_is_created_callback_; base::OnceClosure ensure_entry_is_created_callback_;
base::WeakPtrFactory<DiskEntryManager> weak_factory_{this}; base::WeakPtrFactory<DiskEntryCreator> weak_factory_{this};
};
// Opens and owns a service worker disk cache entry.
class DiskEntryOpener {
public:
DiskEntryOpener(int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache);
~DiskEntryOpener();
DiskEntryOpener(const DiskEntryOpener&) = delete;
DiskEntryOpener& operator=(const DiskEntryOpener&) = delete;
// Can be nullptr when a disk cache error occurs.
AppCacheDiskCacheEntry* entry() { return entry_; }
// Calls the callback when entry() is opened and can be used.
//
// If necessary, opens a disk cache entry for the `resource_id` passed to the
// constructor. After the callback is called, `entry()` can be safely called
// to obtain the created entry.
void EnsureEntryIsOpen(base::OnceClosure callback);
private:
// TODO(crbug.com/586174): Refactor service worker's disk cache to use
// disk_cache::EntryResult to make this callback non-static.
static void DidOpenEntry(base::WeakPtr<DiskEntryOpener> entry_creator,
AppCacheDiskCacheEntry** entry,
int rv);
const int64_t resource_id_;
base::WeakPtr<AppCacheDiskCache> disk_cache_;
AppCacheDiskCacheEntry* entry_ = nullptr;
// Stored as a data member to handle //net-style maybe-async methods.
base::OnceClosure ensure_entry_is_opened_callback_;
base::WeakPtrFactory<DiskEntryOpener> weak_factory_{this};
}; };
// The implementation of storage::mojom::ServiceWorkerResourceReader. // The implementation of storage::mojom::ServiceWorkerResourceReader.
...@@ -120,18 +156,7 @@ class ServiceWorkerResourceReaderImpl ...@@ -120,18 +156,7 @@ class ServiceWorkerResourceReaderImpl
// data. // data.
void DidReadDataComplete(); void DidReadDataComplete();
// Opens a disk cache entry associated with `resource_id_`, if it isn't DiskEntryOpener entry_opener_;
// opened yet.
void EnsureEntryIsOpen(base::OnceClosure callback);
static void DidOpenEntry(
base::WeakPtr<ServiceWorkerResourceReaderImpl> reader,
AppCacheDiskCacheEntry** entry,
int rv);
const int64_t resource_id_;
base::WeakPtr<AppCacheDiskCache> disk_cache_;
AppCacheDiskCacheEntry* entry_ = nullptr;
// Used to read metadata from disk cache. // Used to read metadata from disk cache.
scoped_refptr<BigIOBuffer> metadata_buffer_; scoped_refptr<BigIOBuffer> metadata_buffer_;
...@@ -145,10 +170,6 @@ class ServiceWorkerResourceReaderImpl ...@@ -145,10 +170,6 @@ class ServiceWorkerResourceReaderImpl
// Helper for ReadData(). // Helper for ReadData().
std::unique_ptr<DataReader> data_reader_; std::unique_ptr<DataReader> data_reader_;
// Holds the callback of EnsureEntryIsOpen(). Stored as a data member to
// handle //net-style maybe-async methods.
base::OnceClosure open_entry_callback_;
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
enum class State { enum class State {
kIdle, kIdle,
...@@ -199,7 +220,7 @@ class ServiceWorkerResourceWriterImpl ...@@ -199,7 +220,7 @@ class ServiceWorkerResourceWriterImpl
size_t write_amount, size_t write_amount,
int rv); int rv);
DiskEntryManager entry_manager_; DiskEntryCreator entry_creator_;
// Points the current write position of WriteData(). // Points the current write position of WriteData().
size_t write_position_ = 0; size_t write_position_ = 0;
...@@ -223,15 +244,12 @@ class ServiceWorkerResourceWriterImpl ...@@ -223,15 +244,12 @@ class ServiceWorkerResourceWriterImpl
}; };
// The implementation of storage::mojom::ServiceWorkerResourceMetadataWriter. // The implementation of storage::mojom::ServiceWorkerResourceMetadataWriter.
// Currently this class is an adaptor that uses
// ServiceWorkerResponseMetadataWriter internally.
// TODO(crbug.com/1055677): Fork the implementation of
// ServiceWorkerResponseMetadataWriter and stop using it.
class ServiceWorkerResourceMetadataWriterImpl class ServiceWorkerResourceMetadataWriterImpl
: public storage::mojom::ServiceWorkerResourceMetadataWriter { : public storage::mojom::ServiceWorkerResourceMetadataWriter {
public: public:
explicit ServiceWorkerResourceMetadataWriterImpl( ServiceWorkerResourceMetadataWriterImpl(
std::unique_ptr<ServiceWorkerResponseMetadataWriter> writer); int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache);
ServiceWorkerResourceMetadataWriterImpl( ServiceWorkerResourceMetadataWriterImpl(
const ServiceWorkerResourceMetadataWriterImpl&) = delete; const ServiceWorkerResourceMetadataWriterImpl&) = delete;
...@@ -240,12 +258,34 @@ class ServiceWorkerResourceMetadataWriterImpl ...@@ -240,12 +258,34 @@ class ServiceWorkerResourceMetadataWriterImpl
~ServiceWorkerResourceMetadataWriterImpl() override; ~ServiceWorkerResourceMetadataWriterImpl() override;
private:
// storage::mojom::ServiceWorkerResourceMetadataWriter implementations: // storage::mojom::ServiceWorkerResourceMetadataWriter implementations:
void WriteMetadata(mojo_base::BigBuffer data, void WriteMetadata(mojo_base::BigBuffer data,
WriteMetadataCallback callback) override; WriteMetadataCallback callback) override;
const std::unique_ptr<ServiceWorkerResponseMetadataWriter> writer_; private:
// Called while executing WriteMetadata().
void ContinueWriteMetadata(mojo_base::BigBuffer data,
WriteMetadataCallback callback);
void DidWriteMetadata(scoped_refptr<net::IOBuffer> buffer,
size_t write_amount,
int rv);
DiskEntryOpener entry_opener_;
// Stored as a data member to handle //net-style maybe-async methods.
WriteMetadataCallback write_metadata_callback_;
#if DCHECK_IS_ON()
enum class State {
kIdle,
kWriteMetadataStarted,
kWriteMetadataHasEntry,
};
State state_ = State::kIdle;
#endif // DCHECK_IS_ON()
base::WeakPtrFactory<ServiceWorkerResourceMetadataWriterImpl> weak_factory_{
this};
}; };
} // namespace content } // namespace content
......
content/browser/service_worker/service_worker_storage.cc
View file @ 08ab4773
...@@ -598,10 +598,10 @@ ServiceWorkerStorage::CreateResourceWriter(int64_t resource_id) { ...@@ -598,10 +598,10 @@ ServiceWorkerStorage::CreateResourceWriter(int64_t resource_id) {
resource_id, disk_cache()->GetWeakPtr()); resource_id, disk_cache()->GetWeakPtr());
} }
std::unique_ptr<ServiceWorkerResponseMetadataWriter> std::unique_ptr<ServiceWorkerResourceMetadataWriterImpl>
ServiceWorkerStorage::CreateResponseMetadataWriter(int64_t resource_id) { ServiceWorkerStorage::CreateResourceMetadataWriter(int64_t resource_id) {
return base::WrapUnique(new ServiceWorkerResponseMetadataWriter( return std::make_unique<ServiceWorkerResourceMetadataWriterImpl>(
resource_id, disk_cache()->GetWeakPtr())); resource_id, disk_cache()->GetWeakPtr());
} }
void ServiceWorkerStorage::StoreUncommittedResourceId( void ServiceWorkerStorage::StoreUncommittedResourceId(
......
content/browser/service_worker/service_worker_storage.h
View file @ 08ab4773
...@@ -38,8 +38,6 @@ class QuotaManagerProxy; ...@@ -38,8 +38,6 @@ class QuotaManagerProxy;
namespace content { namespace content {
class ServiceWorkerDiskCache;
class ServiceWorkerResponseMetadataWriter;
class ServiceWorkerStorageControlImplTest; class ServiceWorkerStorageControlImplTest;
namespace service_worker_storage_unittest { namespace service_worker_storage_unittest {
...@@ -188,8 +186,8 @@ class CONTENT_EXPORT ServiceWorkerStorage { ...@@ -188,8 +186,8 @@ class CONTENT_EXPORT ServiceWorkerStorage {
int64_t resource_id); int64_t resource_id);
std::unique_ptr<ServiceWorkerResourceWriterImpl> CreateResourceWriter( std::unique_ptr<ServiceWorkerResourceWriterImpl> CreateResourceWriter(
int64_t resource_id); int64_t resource_id);
std::unique_ptr<ServiceWorkerResponseMetadataWriter> std::unique_ptr<ServiceWorkerResourceMetadataWriterImpl>
CreateResponseMetadataWriter(int64_t resource_id); CreateResourceMetadataWriter(int64_t resource_id);
// Adds |resource_id| to the set of resources that are in the disk cache // Adds |resource_id| to the set of resources that are in the disk cache
// but not yet stored with a registration. // but not yet stored with a registration.
......
content/browser/service_worker/service_worker_storage_control_impl.cc
View file @ 08ab4773
...@@ -272,9 +272,7 @@ void ServiceWorkerStorageControlImpl::CreateResourceMetadataWriter( ...@@ -272,9 +272,7 @@ void ServiceWorkerStorageControlImpl::CreateResourceMetadataWriter(
writer) { writer) {
DCHECK_NE(resource_id, blink::mojom::kInvalidServiceWorkerResourceId); DCHECK_NE(resource_id, blink::mojom::kInvalidServiceWorkerResourceId);
mojo::MakeSelfOwnedReceiver( mojo::MakeSelfOwnedReceiver(
std::make_unique<ServiceWorkerResourceMetadataWriterImpl>( storage_->CreateResourceMetadataWriter(resource_id), std::move(writer));
storage_->CreateResponseMetadataWriter(resource_id)),
std::move(writer));
} }
void ServiceWorkerStorageControlImpl::StoreUncommittedResourceId( void ServiceWorkerStorageControlImpl::StoreUncommittedResourceId(
......
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