Skip to content

GitLab

T
tangled
Commit b9693954 authored by Victor Costan's avatar Victor Costan Committed by Commit Bot
Browse files
Options

AppCache: Merge AppCacheJob and AppCacheURLLoaderJob. 

AppCacheURLLoaderJob is the only subclass of AppCacheJob. This is a
vestige of the Network Service migration, which introduced the
AppCacheJob base class with two implementations.

This CL merges AppCacheJob and AppCacheURLLoaderJob, and renames the
result to AppCacheURLLoader. The new name is more appropriate in a
Network Service-only world, and removes the potential for confusion
with AppCacheUpdateJob.

The following replaces were done mechanically over the entire
repository:
* AppCacheURLLoaderJob -> AppCacheURLLoader
* AppCacheJob -> AppCacheURLLoader
* appcache_url_loader_job.h -> appcache_url_loader.h
* appcache_job.h -> appcache_url_loader.h
* GetDerivedWeakPtr -> GetWeakPtr
* appcache_url_loader_job -> appcache_url_loader

AppCacheJob::AsURLLoaderJob() was removed, as it became a no-op after
the class merger. The mechanical replaces above removed
AppCacheURLLoaderJob::GetDerivedWeakPtr(), which became a synonym for
GetWeakPtr().

When relevant, job / Job was replaced with loader / Loader in local
variable names and method names.

This CL does not introduce any functional change.

Change-Id: I5a508a8dcb14ec77da05dd345d280ea27fa12fa5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2066298
Commit-Queue: Victor Costan <pwnall@chromium.org>
Reviewed-by: default avatarJoshua Bell <jsbell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#743485}
parent f0b6e056
Hide whitespace changes
Inline Side-by-side
Showing with 378 additions and 468 deletions
content/browser/BUILD.gn
View file @ b9693954
......@@ -394,8 +394,6 @@ jumbo_source_set("browser") {
"appcache/appcache_host.h",
"appcache/appcache_internals_ui.cc",
"appcache/appcache_internals_ui.h",
"appcache/appcache_job.cc",
"appcache/appcache_job.h",
"appcache/appcache_manifest_parser.cc",
"appcache/appcache_manifest_parser.h",
"appcache/appcache_namespace.cc",
......@@ -430,8 +428,8 @@ jumbo_source_set("browser") {
"appcache/appcache_update_url_fetcher.h",
"appcache/appcache_update_url_loader_request.cc",
"appcache/appcache_update_url_loader_request.h",
"appcache/appcache_url_loader_job.cc",
"appcache/appcache_url_loader_job.h",
"appcache/appcache_url_loader.cc",
"appcache/appcache_url_loader.h",
"appcache/appcache_working_set.cc",
"appcache/appcache_working_set.h",
"appcache/chrome_appcache_service.cc",
......
content/browser/appcache/appcache_job.cc deleted 100644 → 0
View file @ f0b6e056
// Copyright (c) 2017 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/appcache/appcache_job.h"
#include "base/command_line.h"
#include "content/browser/appcache/appcache_request.h"
#include "content/browser/appcache/appcache_response.h"
#include "content/browser/appcache/appcache_url_loader_job.h"
#include "content/public/common/content_features.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_util.h"
namespace content {
AppCacheJob::~AppCacheJob() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
AppCacheURLLoaderJob* AppCacheJob::AsURLLoaderJob() {
return nullptr;
}
AppCacheJob::AppCacheJob()
: cache_entry_not_found_(false),
delivery_type_(DeliveryType::kAwaitingDeliverCall) {}
void AppCacheJob::InitializeRangeRequestInfo(
const net::HttpRequestHeaders& headers) {
std::string value;
std::vector<net::HttpByteRange> ranges;
if (!headers.GetHeader(net::HttpRequestHeaders::kRange, &value) ||
!net::HttpUtil::ParseRangeHeader(value, &ranges)) {
return;
}
// If multiple ranges are requested, we play dumb and
// return the entire response with 200 OK.
if (ranges.size() == 1U)
range_requested_ = ranges[0];
}
void AppCacheJob::SetupRangeResponse() {
DCHECK(is_range_request() && reader_.get() && IsDeliveringAppCacheResponse());
int resource_size = static_cast<int>(info_->response_data_size());
if (resource_size < 0 || !range_requested_.ComputeBounds(resource_size)) {
range_requested_ = net::HttpByteRange();
return;
}
DCHECK(range_requested_.IsValid());
int offset = static_cast<int>(range_requested_.first_byte_position());
int length = static_cast<int>(range_requested_.last_byte_position() -
range_requested_.first_byte_position() + 1);
// Tell the reader about the range to read.
reader_->SetReadRange(offset, length);
// Make a copy of the full response headers and fix them up
// for the range we'll be returning.
range_response_info_ =
std::make_unique<net::HttpResponseInfo>(info_->http_response_info());
net::HttpResponseHeaders* headers = range_response_info_->headers.get();
headers->UpdateWithNewRange(range_requested_, resource_size,
true /* replace status line */);
}
} // namespace content
content/browser/appcache/appcache_job.h deleted 100644 → 0
View file @ f0b6e056
// Copyright (c) 2017 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.
#ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_JOB_H_
#define CONTENT_BROWSER_APPCACHE_APPCACHE_JOB_H_
#include <memory>
#include "base/logging.h"
#include "base/memory/weak_ptr.h"
#include "base/sequence_checker.h"
#include "base/strings/string16.h"
#include "content/common/content_export.h"
#include "net/http/http_byte_range.h"
#include "url/gurl.h"
namespace net {
class HttpRequestHeaders;
class HttpResponseInfo;
}
namespace content {
class AppCacheEntry;
class AppCacheResponseInfo;
class AppCacheResponseReader;
class AppCacheURLLoaderJob;
// Interface for an AppCache job. This is used to send data stored in the
// AppCache to networking consumers.
// Subclasses implement this interface to wrap custom job objects like
// URLRequestJob, URLLoaderJob, etc to ensure that these dependencies stay out
// of the AppCache code.
class CONTENT_EXPORT AppCacheJob {
public:
enum class DeliveryType {
kAwaitingDeliverCall,
kAppCached,
kNetwork,
kError,
};
virtual ~AppCacheJob();
// True if the job was started.
virtual bool IsStarted() const = 0;
// True if the job is waiting for instructions.
bool IsWaiting() const {
return delivery_type_ == DeliveryType::kAwaitingDeliverCall;
}
// True if the job is delivering a response from the cache.
bool IsDeliveringAppCacheResponse() const {
return delivery_type_ == DeliveryType::kAppCached;
}
// Returns true if the job is delivering a response from the network.
bool IsDeliveringNetworkResponse() const {
return delivery_type_ == DeliveryType::kNetwork;
}
// Returns true if the job is delivering an error response.
bool IsDeliveringErrorResponse() const {
return delivery_type_ == DeliveryType::kError;
}
// Returns true if the cache entry was not found in the cache.
bool IsCacheEntryNotFound() const { return cache_entry_not_found_; }
// Informs the job of what response it should deliver. Only one of these
// methods should be called, and only once per job. A job will sit idle and
// wait indefinitely until one of the deliver methods is called.
virtual void DeliverAppCachedResponse(const GURL& manifest_url,
int64_t cache_id,
const AppCacheEntry& entry,
bool is_fallback) = 0;
// Informs the job that it should deliver the response from the network. This
// is generally controlled by the entries in the manifest file.
virtual void DeliverNetworkResponse() = 0;
// Informs the job that it should deliver an error response.
virtual void DeliverErrorResponse() = 0;
// Returns a weak pointer reference to the job.
virtual base::WeakPtr<AppCacheJob> GetWeakPtr() = 0;
// Returns the underlying ApppCacheURLLoaderJob if any. This only applies to
// AppCaches loaded via the URLRequest mechanism.
virtual AppCacheURLLoaderJob* AsURLLoaderJob();
void set_delivery_type(DeliveryType delivery_type) {
delivery_type_ = delivery_type;
}
protected:
AppCacheJob();
bool is_range_request() const { return range_requested_.IsValid(); }
void InitializeRangeRequestInfo(const net::HttpRequestHeaders& headers);
void SetupRangeResponse();
SEQUENCE_CHECKER(sequence_checker_);
// Set to true if the AppCache entry is not found.
bool cache_entry_not_found_;
// The jobs delivery status.
DeliveryType delivery_type_;
// Byte range request if any.
net::HttpByteRange range_requested_;
std::unique_ptr<net::HttpResponseInfo> range_response_info_;
// The response details.
scoped_refptr<AppCacheResponseInfo> info_;
// Used to read the cache.
std::unique_ptr<AppCacheResponseReader> reader_;
DISALLOW_COPY_AND_ASSIGN(AppCacheJob);
};
} // namespace content
#endif // CONTENT_BROWSER_APPCACHE_APPCACHE_JOB_H_
content/browser/appcache/appcache_request.h
View file @ b9693954
......@@ -82,8 +82,8 @@ class CONTENT_EXPORT AppCacheRequest {
protected:
friend class AppCacheRequestHandler;
// Enables the AppCacheJob to call GetResourceRequest().
friend class AppCacheJob;
// Enables the AppCacheURLLoader to call GetResourceRequest().
friend class AppCacheURLLoader;
// Returns the underlying ResourceRequest.
network::ResourceRequest* GetResourceRequest() { return &request_; }
......
content/browser/appcache/appcache_request_handler.cc
View file @ b9693954
......@@ -15,13 +15,11 @@
#include "content/browser/appcache/appcache_policy.h"
#include "content/browser/appcache/appcache_request.h"
#include "content/browser/appcache/appcache_subresource_url_factory.h"
#include "content/browser/appcache/appcache_url_loader_job.h"
#include "content/browser/appcache/appcache_url_loader.h"
#include "content/browser/frame_host/frame_tree_node.h"
#include "content/browser/frame_host/navigation_request.h"
#include "content/browser/navigation_subresource_loader_params.h"
#include "content/public/common/content_client.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_job.h"
#include "services/network/public/cpp/wrapper_shared_url_loader_factory.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/loader/resource_type_util.h"
......@@ -68,8 +66,8 @@ AppCacheRequestHandler::~AppCacheRequestHandler() {
if (service_)
service_->RemoveObserver(this);
if (job_ && job_->AsURLLoaderJob())
job_->AsURLLoaderJob()->DeleteIfNeeded();
if (loader_)
loader_->DeleteIfNeeded();
}
AppCacheStorage* AppCacheRequestHandler::storage() const {
......@@ -77,7 +75,7 @@ AppCacheStorage* AppCacheRequestHandler::storage() const {
return host_->storage();
}
AppCacheJob* AppCacheRequestHandler::MaybeLoadResource(
AppCacheURLLoader* AppCacheRequestHandler::MaybeLoadResource(
net::NetworkDelegate* network_delegate) {
maybe_load_resource_executed_ = true;
if (!host_ ||
......@@ -88,7 +86,7 @@ AppCacheJob* AppCacheRequestHandler::MaybeLoadResource(
// This method can get called multiple times over the life
// of a request. The case we detect here is having scheduled
// delivery of a "network response" using a job set up on an
// delivery of a "network response" using a loader set up on an
// earlier call through this method. To send the request through
// to the network involves restarting the request altogether,
// which will call through to our interception layer again.
......@@ -106,29 +104,25 @@ AppCacheJob* AppCacheRequestHandler::MaybeLoadResource(
found_manifest_url_ = GURL();
found_network_namespace_ = false;
std::unique_ptr<AppCacheJob> job;
std::unique_ptr<AppCacheURLLoader> loader;
if (is_main_resource())
job = MaybeLoadMainResource(network_delegate);
loader = MaybeLoadMainResource(network_delegate);
else
job = MaybeLoadSubResource(network_delegate);
loader = MaybeLoadSubResource(network_delegate);
// If its been setup to deliver a network response, we can just delete
// it now and return NULL instead to achieve that since it couldn't
// have been started yet.
if (job && job->IsDeliveringNetworkResponse()) {
DCHECK(!job->IsStarted());
if (job->AsURLLoaderJob()) {
job.release()->AsURLLoaderJob()->DeleteIfNeeded();
job_ = nullptr;
} else {
job.reset();
}
if (loader && loader->IsDeliveringNetworkResponse()) {
DCHECK(!loader->IsStarted());
loader.release()->DeleteIfNeeded();
loader_ = nullptr;
}
return job.release();
return loader.release();
}
AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
AppCacheURLLoader* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
net::NetworkDelegate* network_delegate,
const GURL& location) {
if (!host_ ||
......@@ -148,28 +142,28 @@ AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
if (request_->GetURL().GetOrigin() == location.GetOrigin())
return nullptr;
DCHECK(!job_.get()); // our jobs never generate redirects
DCHECK(!loader_.get()); // our jobs never generate redirects
std::unique_ptr<AppCacheJob> job;
std::unique_ptr<AppCacheURLLoader> loader;
if (found_fallback_entry_.has_response_id()) {
// 7.9.6, step 4: If this results in a redirect to another origin,
// get the resource of the fallback entry.
job = CreateJob(network_delegate);
loader = CreateLoader(network_delegate);
DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
found_manifest_url_, true,
found_namespace_entry_url_);
} else if (!found_network_namespace_) {
// 7.9.6, step 6: Fail the resource load.
job = CreateJob(network_delegate);
loader = CreateLoader(network_delegate);
DeliverErrorResponse();
} else {
// 7.9.6 step 3 and 5: Fetch the resource normally.
}
return job.release();
return loader.release();
}
AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
AppCacheURLLoader* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
net::NetworkDelegate* network_delegate) {
if (!host_ ||
!AppCacheRequest::IsSchemeAndMethodSupportedForAppCache(request_.get()) ||
......@@ -184,9 +178,9 @@ AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
}
// We don't fallback for responses that we delivered.
if (job_.get()) {
if (job_->IsDeliveringAppCacheResponse() ||
job_->IsDeliveringErrorResponse()) {
if (loader_.get()) {
if (loader_->IsDeliveringAppCacheResponse() ||
loader_->IsDeliveringErrorResponse()) {
return nullptr;
}
}
......@@ -210,12 +204,12 @@ AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
// 7.9.6, step 4: If this results in a 4xx or 5xx status code
// or there were network errors, get the resource of the fallback entry.
std::unique_ptr<AppCacheJob> job = CreateJob(network_delegate);
std::unique_ptr<AppCacheURLLoader> loader = CreateLoader(network_delegate);
DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
found_manifest_url_, true,
found_namespace_entry_url_);
return job.release();
return loader.release();
}
void AppCacheRequestHandler::GetExtraResponseInfo(int64_t* cache_id,
......@@ -253,17 +247,17 @@ void AppCacheRequestHandler::OnDestructionImminent(AppCacheHost* host) {
storage()->CancelDelegateCallbacks(this);
host_ = nullptr; // no need to RemoveObserver, the host is being deleted
// Since the host is being deleted, we don't have to complete any job
// that is current running. It's destined for the bit bucket anyway.
if (job_.get())
job_.reset();
// Since the host is being deleted, we don't have to drive an in-progress
// loader to completion. It's destined for the bit bucket anyway.
if (loader_.get())
loader_.reset();
}
void AppCacheRequestHandler::OnServiceDestructionImminent(
AppCacheServiceImpl* service) {
service_ = nullptr;
if (!host_) {
DCHECK(!job_);
DCHECK(!loader_);
return;
}
host_->RemoveObserver(this);
......@@ -276,7 +270,7 @@ void AppCacheRequestHandler::DeliverAppCachedResponse(
const GURL& manifest_url,
bool is_fallback,
const GURL& namespace_entry_url) {
DCHECK(host_ && job_.get() && job_->IsWaiting());
DCHECK(host_ && loader_.get() && loader_->IsWaiting());
DCHECK(entry.has_response_id());
// Cache information about the response, for use by GetExtraResponseInfo.
......@@ -287,37 +281,37 @@ void AppCacheRequestHandler::DeliverAppCachedResponse(
!namespace_entry_url.is_empty())
host_->NotifyMainResourceIsNamespaceEntry(namespace_entry_url);
job_->DeliverAppCachedResponse(manifest_url, cache_id, entry, is_fallback);
loader_->DeliverAppCachedResponse(manifest_url, cache_id, entry, is_fallback);
}
void AppCacheRequestHandler::DeliverErrorResponse() {
DCHECK(job_.get() && job_->IsWaiting());
DCHECK(loader_.get() && loader_->IsWaiting());
DCHECK_EQ(blink::mojom::kAppCacheNoCacheId, cache_id_);
DCHECK(manifest_url_.is_empty());
job_->DeliverErrorResponse();
loader_->DeliverErrorResponse();
}
void AppCacheRequestHandler::DeliverNetworkResponse() {
DCHECK(job_.get() && job_->IsWaiting());
DCHECK(loader_.get() && loader_->IsWaiting());
DCHECK_EQ(blink::mojom::kAppCacheNoCacheId, cache_id_);
DCHECK(manifest_url_.is_empty());
job_->DeliverNetworkResponse();
loader_->DeliverNetworkResponse();
}
std::unique_ptr<AppCacheJob> AppCacheRequestHandler::CreateJob(
std::unique_ptr<AppCacheURLLoader> AppCacheRequestHandler::CreateLoader(
net::NetworkDelegate* network_delegate) {
std::unique_ptr<AppCacheJob> job;
job = std::make_unique<AppCacheURLLoaderJob>(request_.get(), storage(),
std::move(loader_callback_));
job_ = job->GetWeakPtr();
return job;
auto loader = std::make_unique<AppCacheURLLoader>(
request_.get(), storage(), std::move(loader_callback_));
loader_ = loader->GetWeakPtr();
return loader;
}
// Main-resource handling ----------------------------------------------
std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeLoadMainResource(
std::unique_ptr<AppCacheURLLoader>
AppCacheRequestHandler::MaybeLoadMainResource(
net::NetworkDelegate* network_delegate) {
DCHECK(!job_.get());
DCHECK(!loader_.get());
DCHECK(host_);
if (storage()->IsInitialized() &&
......@@ -337,10 +331,10 @@ std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeLoadMainResource(
// We may have to wait for our storage query to complete, but
// this query can also complete syncrhonously.
std::unique_ptr<AppCacheJob> job = CreateJob(network_delegate);
std::unique_ptr<AppCacheURLLoader> loader = CreateLoader(network_delegate);
storage()->FindResponseForMainRequest(request_->GetURL(),
preferred_manifest_url, this);
return job;
return loader;
}
void AppCacheRequestHandler::OnMainResponseFound(
......@@ -359,7 +353,7 @@ void AppCacheRequestHandler::OnMainResponseFound(
// Request may have been canceled, but not yet deleted, while waiting on
// the cache.
if (!job_.get())
if (!loader_.get())
return;
AppCachePolicy* policy = host_->service()->appcache_policy();
......@@ -458,15 +452,15 @@ void AppCacheRequestHandler::RunLoaderCallbackForMainResource(
// Sub-resource handling ----------------------------------------------
std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeLoadSubResource(
std::unique_ptr<AppCacheURLLoader> AppCacheRequestHandler::MaybeLoadSubResource(
net::NetworkDelegate* network_delegate) {
DCHECK(!job_.get());
DCHECK(!loader_.get());
if (host_->is_selection_pending()) {
// We have to wait until cache selection is complete and the
// selected cache is loaded.
is_waiting_for_cache_selection_ = true;
return CreateJob(network_delegate);
return CreateLoader(network_delegate);
}
if (!host_->associated_cache() ||
......@@ -475,16 +469,16 @@ std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeLoadSubResource(
return nullptr;
}
std::unique_ptr<AppCacheJob> job = CreateJob(network_delegate);
std::unique_ptr<AppCacheURLLoader> loader = CreateLoader(network_delegate);
ContinueMaybeLoadSubResource();
return job;
return loader;
}
void AppCacheRequestHandler::ContinueMaybeLoadSubResource() {
// 7.9.6 Changes to the networking model
// If the resource is not to be fetched using the HTTP GET mechanism or
// equivalent ... then fetch the resource normally.
DCHECK(job_.get());
DCHECK(loader_.get());
DCHECK(host_->associated_cache() && host_->associated_cache()->is_complete());
const GURL& url = request_->GetURL();
......@@ -533,7 +527,7 @@ void AppCacheRequestHandler::OnCacheSelectionComplete(AppCacheHost* host) {
// Request may have been canceled, but not yet deleted, while waiting on
// the cache.
if (!job_.get())
if (!loader_.get())
return;
if (is_main_resource())
......@@ -653,7 +647,7 @@ AppCacheRequestHandler::MaybeCreateSubresourceLoaderParams() {
void AppCacheRequestHandler::MaybeCreateSubresourceLoader(
const network::ResourceRequest& resource_request,
AppCacheLoaderCallback loader_callback) {
DCHECK(!job_);
DCHECK(!loader_);
DCHECK(!is_main_resource());
// Subresource loads start out just like a main resource loads, but they go
// down different branches along the way to completion.
......@@ -663,7 +657,7 @@ void AppCacheRequestHandler::MaybeCreateSubresourceLoader(
void AppCacheRequestHandler::MaybeFallbackForSubresourceResponse(
network::mojom::URLResponseHeadPtr response,
AppCacheLoaderCallback loader_callback) {
DCHECK(!job_);
DCHECK(!loader_);
DCHECK(!is_main_resource());
loader_callback_ = std::move(loader_callback);
request_->set_response(std::move(response));
......@@ -675,7 +669,7 @@ void AppCacheRequestHandler::MaybeFallbackForSubresourceResponse(
void AppCacheRequestHandler::MaybeFallbackForSubresourceRedirect(
const net::RedirectInfo& redirect_info,
AppCacheLoaderCallback loader_callback) {
DCHECK(!job_);
DCHECK(!loader_);
DCHECK(!is_main_resource());
loader_callback_ = std::move(loader_callback);
MaybeLoadFallbackForRedirect(nullptr, redirect_info.new_url);
......@@ -686,7 +680,7 @@ void AppCacheRequestHandler::MaybeFallbackForSubresourceRedirect(
void AppCacheRequestHandler::MaybeFollowSubresourceRedirect(
const net::RedirectInfo& redirect_info,
AppCacheLoaderCallback loader_callback) {
DCHECK(!job_);
DCHECK(!loader_);
DCHECK(!is_main_resource());
loader_callback_ = std::move(loader_callback);
request_->UpdateWithRedirectInfo(redirect_info);
......
content/browser/appcache/appcache_request_handler.h
View file @ b9693954
......@@ -14,7 +14,6 @@
#include "base/memory/weak_ptr.h"
#include "content/browser/appcache/appcache_entry.h"
#include "content/browser/appcache/appcache_host.h"
#include "content/browser/appcache/appcache_request_handler.h"
#include "content/browser/appcache/appcache_service_impl.h"
#include "content/browser/loader/navigation_loader_interceptor.h"
#include "content/browser/loader/single_request_url_loader_factory.h"
......@@ -31,7 +30,7 @@ class URLRequest;
} // namespace net
namespace content {
class AppCacheJob;
class AppCacheURLLoader;
class AppCacheSubresourceURLFactory;
class AppCacheRequest;
class AppCacheRequestHandlerTest;
......@@ -136,9 +135,9 @@ class CONTENT_EXPORT AppCacheRequestHandler
void DeliverNetworkResponse();
void DeliverErrorResponse();
// Helper method to create an AppCacheJob and populate job_.
// Helper method to create an AppCacheURLLoader and populate job_.
// Caller takes ownership of returned value.
std::unique_ptr<AppCacheJob> CreateJob(
std::unique_ptr<AppCacheURLLoader> CreateLoader(
net::NetworkDelegate* network_delegate);
// Helper to retrieve a pointer to the storage object.
......@@ -150,11 +149,11 @@ class CONTENT_EXPORT AppCacheRequestHandler
// These are called on each request intercept opportunity, by the various
// MaybeCreateLoader methods in the public API.
AppCacheJob* MaybeLoadResource(net::NetworkDelegate* network_delegate);
AppCacheJob* MaybeLoadFallbackForRedirect(
AppCacheURLLoader* MaybeLoadResource(net::NetworkDelegate* network_delegate);
AppCacheURLLoader* MaybeLoadFallbackForRedirect(
net::NetworkDelegate* network_delegate,
const GURL& location);
AppCacheJob* MaybeLoadFallbackForResponse(
AppCacheURLLoader* MaybeLoadFallbackForResponse(
net::NetworkDelegate* network_delegate);
void GetExtraResponseInfo(int64_t* cache_id, GURL* manifest_url);
......@@ -162,7 +161,7 @@ class CONTENT_EXPORT AppCacheRequestHandler
// Main-resource loading -------------------------------------
// Frame and SharedWorker main resources are handled here.
std::unique_ptr<AppCacheJob> MaybeLoadMainResource(
std::unique_ptr<AppCacheURLLoader> MaybeLoadMainResource(
net::NetworkDelegate* network_delegate);
// AppCacheStorage::Delegate methods
......@@ -187,7 +186,7 @@ class CONTENT_EXPORT AppCacheRequestHandler
// Sub-resource loading -------------------------------------
// Dedicated worker and all manner of sub-resources are handled here.
std::unique_ptr<AppCacheJob> MaybeLoadSubResource(
std::unique_ptr<AppCacheURLLoader> MaybeLoadSubResource(
net::NetworkDelegate* network_delegate);
void ContinueMaybeLoadSubResource();
......@@ -236,7 +235,7 @@ class CONTENT_EXPORT AppCacheRequestHandler
// 1) Before request has started a job.
// 2) Request is not being handled by appcache.
// 3) Request has been cancelled, and the job killed.
base::WeakPtr<AppCacheJob> job_;
base::WeakPtr<AppCacheURLLoader> loader_;
// Cached information about the response being currently served by the
// AppCache, if there is one.
......
content/browser/appcache/appcache_request_handler_unittest.cc
View file @ b9693954
......@@ -26,9 +26,8 @@
#include "base/threading/thread_task_runner_handle.h"
#include "content/browser/appcache/appcache.h"
#include "content/browser/appcache/appcache_backend_impl.h"
#include "content/browser/appcache/appcache_job.h"
#include "content/browser/appcache/appcache_request.h"
#include "content/browser/appcache/appcache_url_loader_job.h"
#include "content/browser/appcache/appcache_url_loader.h"
#include "content/browser/appcache/mock_appcache_policy.h"
#include "content/browser/appcache/mock_appcache_service.h"
#include "content/public/browser/browser_task_traits.h"
......@@ -98,9 +97,9 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
}
void TearDownTest() {
if (appcache_url_loader_job_)
appcache_url_loader_job_->DeleteIfNeeded();
appcache_url_loader_job_.reset();
if (appcache_url_loader_)
appcache_url_loader_->DeleteIfNeeded();
appcache_url_loader_.reset();
handler_.reset();
request_ = nullptr;
mock_service_.reset();
......@@ -137,16 +136,17 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
task_stack_.pop();
}
void SetAppCacheJob(AppCacheJob* job) {
if (appcache_url_loader_job_)
appcache_url_loader_job_->DeleteIfNeeded();
appcache_url_loader_job_ = nullptr;
if (!job)
void SetAppCacheURLLoader(AppCacheURLLoader* loader) {
if (appcache_url_loader_) {
appcache_url_loader_->DeleteIfNeeded();
appcache_url_loader_ = nullptr;
}
if (!loader)
return;
appcache_url_loader_job_ = job->AsURLLoaderJob()->GetDerivedWeakPtr();
appcache_url_loader_ = loader->GetWeakPtr();
}
AppCacheJob* job() { return appcache_url_loader_job_.get(); }
AppCacheURLLoader* loader() { return appcache_url_loader_.get(); }
// MainResource_Miss --------------------------------------------------
......@@ -159,17 +159,17 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
blink::mojom::ResourceType::kMainFrame);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
// We have to wait for completion of storage->FindResponseForMainRequest.
ScheduleNextTask();
}
void Verify_MainResource_Miss() {
EXPECT_FALSE(job()->IsWaiting());
EXPECT_TRUE(job()->IsDeliveringNetworkResponse());
EXPECT_FALSE(loader()->IsWaiting());
EXPECT_TRUE(loader()->IsDeliveringNetworkResponse());
int64_t cache_id = blink::mojom::kAppCacheNoCacheId;
GURL manifest_url;
......@@ -178,11 +178,11 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
EXPECT_EQ(GURL(), manifest_url);
EXPECT_EQ(0, handler_->found_group_id_);
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://blah/redirect")));
EXPECT_FALSE(job());
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
EXPECT_FALSE(loader());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
EXPECT_TRUE(host_->preferred_manifest_url().is_empty());
......@@ -204,17 +204,17 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
AppCacheEntry(AppCacheEntry::EXPLICIT, 1), GURL(), AppCacheEntry(), 1,
2, GURL("http://blah/manifest/"));
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
// We have to wait for completion of storage->FindResponseForMainRequest.
ScheduleNextTask();
}
void Verify_MainResource_Hit() {
EXPECT_FALSE(job()->IsWaiting());
EXPECT_TRUE(job()->IsDeliveringAppCacheResponse());
EXPECT_FALSE(loader()->IsWaiting());
EXPECT_TRUE(loader()->IsDeliveringAppCacheResponse());
int64_t cache_id = blink::mojom::kAppCacheNoCacheId;
GURL manifest_url;
......@@ -223,8 +223,8 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
EXPECT_EQ(GURL("http://blah/manifest/"), manifest_url);
EXPECT_EQ(2, handler_->found_group_id_);
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
EXPECT_EQ(GURL("http://blah/manifest/"), host_->preferred_manifest_url());
......@@ -247,9 +247,9 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
AppCacheEntry(AppCacheEntry::EXPLICIT, 1), 1, 2,
GURL("http://blah/manifest/"));
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
// We have to wait for completion of storage->FindResponseForMainRequest.
ScheduleNextTask();
......@@ -275,15 +275,15 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
}
void Verify_MainResource_Fallback() {
EXPECT_FALSE(job()->IsWaiting());
EXPECT_TRUE(job()->IsDeliveringNetworkResponse());
EXPECT_FALSE(loader()->IsWaiting());
EXPECT_TRUE(loader()->IsDeliveringNetworkResponse());
// Simulate an http error of the real network job.
SimulateResponseCode(500);
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsDeliveringAppCacheResponse());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsDeliveringAppCacheResponse());
int64_t cache_id = blink::mojom::kAppCacheNoCacheId;
GURL manifest_url;
......@@ -314,17 +314,17 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
AppCacheEntry(AppCacheEntry::EXPLICIT, 1), 1, 2,
GURL("http://blah/manifest/"));
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
// We have to wait for completion of storage->FindResponseForMainRequest.
ScheduleNextTask();
}
void Verify_MainResource_FallbackOverride() {
EXPECT_FALSE(job()->IsWaiting());
EXPECT_TRUE(job()->IsDeliveringNetworkResponse());
EXPECT_FALSE(loader()->IsWaiting());
EXPECT_TRUE(loader()->IsDeliveringNetworkResponse());
// Simulate an http error of the real network job, but with custom
// headers that override the fallback behavior.
......@@ -337,8 +337,8 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
std::string(kOverrideHeaders, base::size(kOverrideHeaders)));
SimulateResponseInfo(info);
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
// GetExtraResponseInfo should return no information.
int64_t cache_id = blink::mojom::kAppCacheNoCacheId;
......@@ -373,15 +373,15 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsDeliveringErrorResponse());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsDeliveringErrorResponse());
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://blah/redirect")));
EXPECT_FALSE(job());
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
EXPECT_FALSE(loader());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
TestFinished();
}
......@@ -397,19 +397,19 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
CreateRequestAndHandler(GURL("http://blah/"), host_,
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
host_->FinishCacheSelection(cache.get(), nullptr, base::DoNothing());
EXPECT_FALSE(job()->IsWaiting());
EXPECT_TRUE(job()->IsDeliveringErrorResponse());
EXPECT_FALSE(loader()->IsWaiting());
EXPECT_TRUE(loader()->IsDeliveringErrorResponse());
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://blah/redirect")));
EXPECT_FALSE(job());
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
EXPECT_FALSE(loader());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
TestFinished();
}
......@@ -425,15 +425,15 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
CreateRequestAndHandler(GURL("http://blah/"), host_,
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsDeliveringAppCacheResponse());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsDeliveringAppCacheResponse());
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://blah/redirect")));
EXPECT_FALSE(job());
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
EXPECT_FALSE(loader());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
TestFinished();
}
......@@ -451,16 +451,16 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
CreateRequestAndHandler(GURL("http://blah/"), host_,
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_FALSE(loader());
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://not_blah/redirect")));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsDeliveringAppCacheResponse());
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsDeliveringAppCacheResponse());
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
TestFinished();
}
......@@ -478,16 +478,16 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
CreateRequestAndHandler(GURL("http://blah/"), host_,
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_FALSE(loader());
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://blah/redirect")));
EXPECT_FALSE(job());
EXPECT_FALSE(loader());
SimulateResponseCode(200);
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
TestFinished();
}
......@@ -506,14 +506,14 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
CreateRequestAndHandler(GURL("http://blah/"), host_,
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_FALSE(job());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_FALSE(loader());
SetAppCacheJob(handler_->MaybeLoadFallbackForRedirect(
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForRedirect(
nullptr, GURL("http://blah/redirect")));
EXPECT_FALSE(job());
SetAppCacheJob(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(job());
EXPECT_FALSE(loader());
SetAppCacheURLLoader(handler_->MaybeLoadFallbackForResponse(nullptr));
EXPECT_FALSE(loader());
TestFinished();
}
......@@ -551,9 +551,9 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
mock_service_->EraseHost(host_->host_id());
host_ = nullptr;
......@@ -577,8 +577,8 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
CreateRequestAndHandler(GURL("http://blah/"), host_,
blink::mojom::ResourceType::kSubResource);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
mock_service_.reset();
mock_policy_.reset();
......@@ -617,12 +617,12 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
blink::mojom::ResourceType::kMainFrame);
EXPECT_TRUE(handler_.get());
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
EXPECT_FALSE(job()->IsStarted());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
EXPECT_FALSE(loader()->IsStarted());
base::WeakPtr<AppCacheJob> weak_job = job()->GetWeakPtr();
base::WeakPtr<AppCacheURLLoader> weak_job = loader()->GetWeakPtr();
EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(nullptr));
......@@ -645,17 +645,17 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
AppCacheEntry(AppCacheEntry::EXPLICIT, 1), GURL(), AppCacheEntry(), 1,
2, GURL("http://blah/manifest/"));
SetAppCacheJob(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(job());
EXPECT_TRUE(job()->IsWaiting());
SetAppCacheURLLoader(handler_->MaybeLoadResource(nullptr));
EXPECT_TRUE(loader());
EXPECT_TRUE(loader()->IsWaiting());
// We have to wait for completion of storage->FindResponseForMainRequest.
ScheduleNextTask();
}
void Verify_MainResource_Blocked() {
EXPECT_FALSE(job()->IsWaiting());
EXPECT_FALSE(job()->IsDeliveringAppCacheResponse());
EXPECT_FALSE(loader()->IsWaiting());
EXPECT_FALSE(loader()->IsDeliveringAppCacheResponse());
EXPECT_EQ(0, handler_->found_cache_id_);
EXPECT_EQ(0, handler_->found_group_id_);
......@@ -714,7 +714,7 @@ class AppCacheRequestHandlerTest : public ::testing::Test {
mojo::Remote<blink::mojom::AppCacheHost> host_remote_;
AppCacheRequest* request_;
std::unique_ptr<AppCacheRequestHandler> handler_;
base::WeakPtr<AppCacheURLLoaderJob> appcache_url_loader_job_;
base::WeakPtr<AppCacheURLLoader> appcache_url_loader_;
};
TEST_F(AppCacheRequestHandlerTest, MainResource_Miss) {
......
content/browser/appcache/appcache_subresource_url_factory.cc
View file @ b9693954
......@@ -13,7 +13,6 @@
#include "content/browser/appcache/appcache_host.h"
#include "content/browser/appcache/appcache_request.h"
#include "content/browser/appcache/appcache_request_handler.h"
#include "content/browser/appcache/appcache_url_loader_job.h"
#include "content/browser/loader/navigation_url_loader_impl.h"
#include "content/browser/storage_partition_impl.h"
#include "content/public/browser/browser_thread.h"
......@@ -74,7 +73,7 @@ class SubresourceLoader : public network::mojom::URLLoader,
}
private:
~SubresourceLoader() override {}
~SubresourceLoader() override = default;
void OnMojoDisconnect() { delete this; }
......
content/browser/appcache/appcache_subresource_url_factory.h
View file @ b9693954
......@@ -22,7 +22,6 @@ class SharedURLLoaderFactory;
namespace content {
class AppCacheHost;
class AppCacheJob;
class AppCacheRequestHandler;
class AppCacheServiceImpl;
......
content/browser/appcache/appcache_url_loader_job.cc → content/browser/appcache/appcache_url_loader.cc
View file @ b9693954
// Copyright (c) 2017 The Chromium Authors. All rights reserved.
// Copyright 2020 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/appcache/appcache_url_loader_job.h"
#include "content/browser/appcache/appcache_url_loader.h"
#include "base/bind.h"
#include "base/strings/string_number_conversions.h"
......@@ -12,7 +12,10 @@
#include "content/browser/appcache/appcache_subresource_url_factory.h"
#include "content/browser/url_loader_factory_getter.h"
#include "net/base/ip_endpoint.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/http/http_util.h"
#include "services/network/public/cpp/net_adapters.h"
#include "third_party/blink/public/common/loader/resource_type_util.h"
#include "third_party/blink/public/mojom/appcache/appcache_info.mojom.h"
......@@ -20,20 +23,62 @@
namespace content {
AppCacheURLLoaderJob::~AppCacheURLLoaderJob() {
AppCacheURLLoader::~AppCacheURLLoader() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (storage_.get())
storage_->CancelDelegateCallbacks(this);
}
bool AppCacheURLLoaderJob::IsStarted() const {
void AppCacheURLLoader::InitializeRangeRequestInfo(
const net::HttpRequestHeaders& headers) {
std::string value;
std::vector<net::HttpByteRange> ranges;
if (!headers.GetHeader(net::HttpRequestHeaders::kRange, &value) ||
!net::HttpUtil::ParseRangeHeader(value, &ranges)) {
return;
}
// If multiple ranges are requested, we play dumb and
// return the entire response with 200 OK.
if (ranges.size() == 1U)
range_requested_ = ranges[0];
}
void AppCacheURLLoader::SetupRangeResponse() {
DCHECK(is_range_request() && reader_.get() && IsDeliveringAppCacheResponse());
int resource_size = static_cast<int>(info_->response_data_size());
if (resource_size < 0 || !range_requested_.ComputeBounds(resource_size)) {
range_requested_ = net::HttpByteRange();
return;
}
DCHECK(range_requested_.IsValid());
int offset = static_cast<int>(range_requested_.first_byte_position());
int length = static_cast<int>(range_requested_.last_byte_position() -
range_requested_.first_byte_position() + 1);
// Tell the reader about the range to read.
reader_->SetReadRange(offset, length);
// Make a copy of the full response headers and fix them up
// for the range we'll be returning.
range_response_info_ =
std::make_unique<net::HttpResponseInfo>(info_->http_response_info());
net::HttpResponseHeaders* headers = range_response_info_->headers.get();
headers->UpdateWithNewRange(range_requested_, resource_size,
/*replace_status_line=*/true);
}
bool AppCacheURLLoader::IsStarted() const {
return delivery_type_ != DeliveryType::kAwaitingDeliverCall &&
delivery_type_ != DeliveryType::kNetwork;
}
void AppCacheURLLoaderJob::DeliverAppCachedResponse(const GURL& manifest_url,
int64_t cache_id,
const AppCacheEntry& entry,
bool is_fallback) {
void AppCacheURLLoader::DeliverAppCachedResponse(const GURL& manifest_url,
int64_t cache_id,
const AppCacheEntry& entry,
bool is_fallback) {
if (!storage_.get() || !appcache_request_) {
DeliverErrorResponse();
return;
......@@ -60,7 +105,7 @@ void AppCacheURLLoaderJob::DeliverAppCachedResponse(const GURL& manifest_url,
storage_->LoadResponseInfo(manifest_url_, entry_.response_id(), this);
}
void AppCacheURLLoaderJob::DeliverNetworkResponse() {
void AppCacheURLLoader::DeliverNetworkResponse() {
delivery_type_ = DeliveryType::kNetwork;
// In tests we only care about the delivery_type_ state.
......@@ -75,7 +120,7 @@ void AppCacheURLLoaderJob::DeliverNetworkResponse() {
DeleteSoon();
}
void AppCacheURLLoaderJob::DeliverErrorResponse() {
void AppCacheURLLoader::DeliverErrorResponse() {
delivery_type_ = DeliveryType::kError;
// In tests we only care about the delivery_type_ state.
......@@ -83,44 +128,36 @@ void AppCacheURLLoaderJob::DeliverErrorResponse() {
return;
if (loader_callback_) {
CallLoaderCallback(base::BindOnce(&AppCacheURLLoaderJob::NotifyCompleted,
GetDerivedWeakPtr(), net::ERR_FAILED));
CallLoaderCallback(base::BindOnce(&AppCacheURLLoader::NotifyCompleted,
GetWeakPtr(), net::ERR_FAILED));
} else {
NotifyCompleted(net::ERR_FAILED);
}
}
AppCacheURLLoaderJob* AppCacheURLLoaderJob::AsURLLoaderJob() {
return this;
}
base::WeakPtr<AppCacheJob> AppCacheURLLoaderJob::GetWeakPtr() {
base::WeakPtr<AppCacheURLLoader> AppCacheURLLoader::GetWeakPtr() {
return weak_factory_.GetWeakPtr();
}
base::WeakPtr<AppCacheURLLoaderJob> AppCacheURLLoaderJob::GetDerivedWeakPtr() {
return weak_factory_.GetWeakPtr();
}
void AppCacheURLLoaderJob::FollowRedirect(
void AppCacheURLLoader::FollowRedirect(
const std::vector<std::string>& modified_headers,
const net::HttpRequestHeaders& removed_headers,
const base::Optional<GURL>& new_url) {
NOTREACHED() << "appcache never produces redirects";
}
void AppCacheURLLoaderJob::SetPriority(net::RequestPriority priority,
int32_t intra_priority_value) {}
void AppCacheURLLoaderJob::PauseReadingBodyFromNet() {}
void AppCacheURLLoaderJob::ResumeReadingBodyFromNet() {}
void AppCacheURLLoader::SetPriority(net::RequestPriority priority,
int32_t intra_priority_value) {}
void AppCacheURLLoader::PauseReadingBodyFromNet() {}
void AppCacheURLLoader::ResumeReadingBodyFromNet() {}
void AppCacheURLLoaderJob::DeleteIfNeeded() {
void AppCacheURLLoader::DeleteIfNeeded() {
if (receiver_.is_bound() || is_deleting_soon_)
return;
delete this;
}
void AppCacheURLLoaderJob::Start(
void AppCacheURLLoader::Start(
base::OnceClosure continuation,
const network::ResourceRequest& /* resource_request */,
mojo::PendingReceiver<network::mojom::URLLoader> receiver,
......@@ -132,7 +169,7 @@ void AppCacheURLLoaderJob::Start(
receiver_.Bind(std::move(receiver));
client_.Bind(std::move(client));
receiver_.set_disconnect_handler(
base::BindOnce(&AppCacheURLLoaderJob::DeleteSoon, GetDerivedWeakPtr()));
base::BindOnce(&AppCacheURLLoader::DeleteSoon, GetWeakPtr()));
MojoResult result =
mojo::CreateDataPipe(nullptr, &response_body_stream_, &consumer_handle_);
......@@ -147,14 +184,12 @@ void AppCacheURLLoaderJob::Start(
std::move(continuation).Run();
}
AppCacheURLLoaderJob::AppCacheURLLoaderJob(
AppCacheURLLoader::AppCacheURLLoader(
AppCacheRequest* appcache_request,
AppCacheStorage* storage,
AppCacheRequestHandler::AppCacheLoaderCallback loader_callback)
: storage_(storage->GetWeakPtr()),
start_time_tick_(base::TimeTicks::Now()),
cache_id_(blink::mojom::kAppCacheNoCacheId),
is_fallback_(false),
writable_handle_watcher_(FROM_HERE,
mojo::SimpleWatcher::ArmingPolicy::MANUAL,
base::SequencedTaskRunnerHandle::Get()),
......@@ -164,15 +199,15 @@ AppCacheURLLoaderJob::AppCacheURLLoaderJob(
blink::IsResourceTypeFrame(static_cast<blink::mojom::ResourceType>(
appcache_request->GetResourceType()))) {}
void AppCacheURLLoaderJob::CallLoaderCallback(base::OnceClosure continuation) {
void AppCacheURLLoader::CallLoaderCallback(base::OnceClosure continuation) {
DCHECK(loader_callback_);
DCHECK(!receiver_.is_bound());
std::move(loader_callback_)
.Run(base::BindOnce(&AppCacheURLLoaderJob::Start, GetDerivedWeakPtr(),
.Run(base::BindOnce(&AppCacheURLLoader::Start, GetWeakPtr(),
std::move(continuation)));
}
void AppCacheURLLoaderJob::OnResponseInfoLoaded(
void AppCacheURLLoader::OnResponseInfoLoaded(
AppCacheResponseInfo* response_info,
int64_t response_id) {
DCHECK(IsDeliveringAppCacheResponse());
......@@ -184,9 +219,9 @@ void AppCacheURLLoaderJob::OnResponseInfoLoaded(
if (response_info) {
if (loader_callback_) {
CallLoaderCallback(base::BindOnce(
&AppCacheURLLoaderJob::ContinueOnResponseInfoLoaded,
GetDerivedWeakPtr(), base::WrapRefCounted(response_info)));
CallLoaderCallback(
base::BindOnce(&AppCacheURLLoader::ContinueOnResponseInfoLoaded,
GetWeakPtr(), base::WrapRefCounted(response_info)));
} else {
ContinueOnResponseInfoLoaded(response_info);
}
......@@ -203,7 +238,7 @@ void AppCacheURLLoaderJob::OnResponseInfoLoaded(
}
cache_entry_not_found_ = true;
// We fallback to the network unless this job was falling back to the
// We fallback to the network unless this loader was falling back to the
// appcache from the network which had already failed in some way.
if (!is_fallback_)
DeliverNetworkResponse();
......@@ -211,7 +246,7 @@ void AppCacheURLLoaderJob::OnResponseInfoLoaded(
DeliverErrorResponse();
}
void AppCacheURLLoaderJob::ContinueOnResponseInfoLoaded(
void AppCacheURLLoader::ContinueOnResponseInfoLoaded(
scoped_refptr<AppCacheResponseInfo> response_info) {
info_ = response_info;
reader_ = storage_->CreateResponseReader(manifest_url_, entry_.response_id());
......@@ -226,14 +261,14 @@ void AppCacheURLLoaderJob::ContinueOnResponseInfoLoaded(
// Wait for the data pipe to be ready to accept data.
writable_handle_watcher_.Watch(
response_body_stream_.get(), MOJO_HANDLE_SIGNAL_WRITABLE,
base::BindRepeating(&AppCacheURLLoaderJob::OnResponseBodyStreamReady,
GetDerivedWeakPtr()));
base::BindRepeating(&AppCacheURLLoader::OnResponseBodyStreamReady,
GetWeakPtr()));
SendResponseInfo();
ReadMore();
}
void AppCacheURLLoaderJob::OnReadComplete(int result) {
void AppCacheURLLoader::OnReadComplete(int result) {
if (result > 0) {
uint32_t bytes_written = static_cast<uint32_t>(result);
response_body_stream_ = pending_write_->Complete(bytes_written);
......@@ -248,7 +283,7 @@ void AppCacheURLLoaderJob::OnReadComplete(int result) {
NotifyCompleted(result);
}
void AppCacheURLLoaderJob::OnResponseBodyStreamReady(MojoResult result) {
void AppCacheURLLoader::OnResponseBodyStreamReady(MojoResult result) {
// TODO(ananta)
// Add proper error handling here.
if (result != MOJO_RESULT_OK) {
......@@ -259,7 +294,7 @@ void AppCacheURLLoaderJob::OnResponseBodyStreamReady(MojoResult result) {
ReadMore();
}
void AppCacheURLLoaderJob::DeleteSoon() {
void AppCacheURLLoader::DeleteSoon() {
if (storage_.get())
storage_->CancelDelegateCallbacks(this);
weak_factory_.InvalidateWeakPtrs();
......@@ -267,7 +302,7 @@ void AppCacheURLLoaderJob::DeleteSoon() {
base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
}
void AppCacheURLLoaderJob::SendResponseInfo() {
void AppCacheURLLoader::SendResponseInfo() {
// If this is null it means the response information was sent to the client.
if (!consumer_handle_.is_valid())
return;
......@@ -302,7 +337,7 @@ void AppCacheURLLoaderJob::SendResponseInfo() {
client_->OnStartLoadingResponseBody(std::move(consumer_handle_));
}
void AppCacheURLLoaderJob::ReadMore() {
void AppCacheURLLoader::ReadMore() {
DCHECK(!pending_write_.get());
uint32_t num_bytes;
......@@ -313,7 +348,8 @@ void AppCacheURLLoaderJob::ReadMore() {
// The pipe is full. We need to wait for it to have more space.
writable_handle_watcher_.ArmOrNotify();
return;
} else if (result != MOJO_RESULT_OK) {
}
if (result != MOJO_RESULT_OK) {
NotifyCompleted(net::ERR_FAILED);
writable_handle_watcher_.Cancel();
response_body_stream_.reset();
......@@ -327,12 +363,12 @@ void AppCacheURLLoaderJob::ReadMore() {
uint32_t bytes_to_read =
std::min<uint32_t>(num_bytes, info_->response_data_size());
reader_->ReadData(buffer.get(), bytes_to_read,
base::BindOnce(&AppCacheURLLoaderJob::OnReadComplete,
GetDerivedWeakPtr()));
reader_->ReadData(
buffer.get(), bytes_to_read,
base::BindOnce(&AppCacheURLLoader::OnReadComplete, GetWeakPtr()));
}
void AppCacheURLLoaderJob::NotifyCompleted(int error_code) {
void AppCacheURLLoader::NotifyCompleted(int error_code) {
if (storage_.get())
storage_->CancelDelegateCallbacks(this);
......
content/browser/appcache/appcache_url_loader_job.h → content/browser/appcache/appcache_url_loader.h
View file @ b9693954
// Copyright (c) 2017 The Chromium Authors. All rights reserved.
// Copyright 2020 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.
#ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_JOB_H_
#define CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_JOB_H_
#ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_H_
#define CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_H_
#include <memory>
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string16.h"
#include "base/sequence_checker.h"
#include "base/time/time.h"
#include "content/browser/appcache/appcache_entry.h"
#include "content/browser/appcache/appcache_job.h"
#include "content/browser/appcache/appcache_request_handler.h"
#include "content/browser/appcache/appcache_response.h"
#include "content/browser/appcache/appcache_storage.h"
#include "content/browser/loader/navigation_loader_interceptor.h"
#include "content/common/content_export.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/system/data_pipe.h"
#include "net/http/http_byte_range.h"
#include "services/network/public/mojom/url_loader.mojom-forward.h"
#include "third_party/blink/public/mojom/appcache/appcache_info.mojom-forward.h"
#include "url/gurl.h"
namespace net {
class HttpRequestHeaders;
class HttpResponseInfo;
} // namespace net
namespace network {
class NetToMojoPendingBuffer;
......@@ -31,23 +39,30 @@ class NetToMojoPendingBuffer;
namespace content {
class AppCacheRequest;
class AppCacheResponseInfo;
class AppCacheResponseReader;
// AppCacheJob wrapper for a network::mojom::URLLoader implementation which
// returns responses stored in the AppCache.
class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,
public AppCacheStorage::Delegate,
public network::mojom::URLLoader {
// network::mojom::URLLoader that retrieves responses stored in an AppCache.
class CONTENT_EXPORT AppCacheURLLoader : public AppCacheStorage::Delegate,
public network::mojom::URLLoader {
public:
enum class DeliveryType {
kAwaitingDeliverCall,
kAppCached,
kNetwork,
kError,
};
// Use AppCacheRequestHandler::CreateJob() instead of calling the constructor
// directly.
//
// The constructor is exposed for std::make_unique.
AppCacheURLLoaderJob(
AppCacheURLLoader(
AppCacheRequest* appcache_request,
AppCacheStorage* storage,
AppCacheRequestHandler::AppCacheLoaderCallback loader_callback);
~AppCacheURLLoaderJob() override;
~AppCacheURLLoader() override;
// Sets up the bindings.
void Start(base::OnceClosure continuation,
......@@ -55,19 +70,64 @@ class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,
mojo::PendingReceiver<network::mojom::URLLoader> receiver,
mojo::PendingRemote<network::mojom::URLLoaderClient> client);
// AppCacheJob overrides.
bool IsStarted() const override;
// True if the loader was started.
bool IsStarted() const;
// True if the loader is waiting for instructions.
bool IsWaiting() const {
return delivery_type_ == DeliveryType::kAwaitingDeliverCall;
}
// True if the loader is delivering a response from the cache.
bool IsDeliveringAppCacheResponse() const {
return delivery_type_ == DeliveryType::kAppCached;
}
// True if the loader is delivering a response from the network.
bool IsDeliveringNetworkResponse() const {
return delivery_type_ == DeliveryType::kNetwork;
}
// True if the loader is delivering an error response.
bool IsDeliveringErrorResponse() const {
return delivery_type_ == DeliveryType::kError;
}
void set_delivery_type(DeliveryType delivery_type) {
delivery_type_ = delivery_type;
}
// True if the cache entry was not found in the cache.
bool IsCacheEntryNotFound() const { return cache_entry_not_found_; }
// Informs the loader of what response it should deliver.
//
// Each loader should receive exactly one call to a Deliver*() method. Loaders
// will sit idle and wait indefinitely until one of the Deliver*() methods is
// called.
void DeliverAppCachedResponse(const GURL& manifest_url,
int64_t cache_id,
const AppCacheEntry& entry,
bool is_fallback) override;
void DeliverNetworkResponse() override;
void DeliverErrorResponse() override;
AppCacheURLLoaderJob* AsURLLoaderJob() override;
base::WeakPtr<AppCacheJob> GetWeakPtr() override;
base::WeakPtr<AppCacheURLLoaderJob> GetDerivedWeakPtr();
// network::mojom::URLLoader implementation:
bool is_fallback);
// Informs the loader that it should deliver the response from the network.
// This is generally controlled by the entries in the manifest file.
//
// Each loader should receive exactly one call to a Deliver*() method. Loaders
// will sit idle and wait indefinitely until one of the Deliver*() methods is
// called.
void DeliverNetworkResponse();
// Informs the loader that it should deliver an error response.
//
// Each loader should receive exactly one call to a Deliver*() method. Loaders
// will sit idle and wait indefinitely until one of the Deliver*() methods is
// called.
void DeliverErrorResponse();
base::WeakPtr<AppCacheURLLoader> GetWeakPtr();
// network::mojom::URLLoader:
void FollowRedirect(const std::vector<std::string>& removed_headers,
const net::HttpRequestHeaders& modified_headers,
const base::Optional<GURL>& new_url) override;
......@@ -78,13 +138,19 @@ class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,
void DeleteIfNeeded();
protected:
private:
bool is_range_request() const { return range_requested_.IsValid(); }
void InitializeRangeRequestInfo(const net::HttpRequestHeaders& headers);
void SetupRangeResponse();
// Invokes the loader callback which is expected to setup the mojo binding.
void CallLoaderCallback(base::OnceClosure continuation);
// AppCacheStorage::Delegate methods
// AppCacheStorage::Delegate:
void OnResponseInfoLoaded(AppCacheResponseInfo* response_info,
int64_t response_id) override;
void ContinueOnResponseInfoLoaded(
scoped_refptr<AppCacheResponseInfo> response_info);
......@@ -102,6 +168,23 @@ class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,
void ReadMore();
void NotifyCompleted(int error_code);
// True if the AppCache entry is not found.
bool cache_entry_not_found_ = false;
// The loader's delivery status.
DeliveryType delivery_type_ = DeliveryType::kAwaitingDeliverCall;
// Byte range request if any.
net::HttpByteRange range_requested_;
std::unique_ptr<net::HttpResponseInfo> range_response_info_;
// The response details.
scoped_refptr<AppCacheResponseInfo> info_;
// Used to read the cache.
std::unique_ptr<AppCacheResponseReader> reader_;
base::WeakPtr<AppCacheStorage> storage_;
// Time when the request started.
......@@ -112,9 +195,9 @@ class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,
net::LoadTimingInfo load_timing_info_;
GURL manifest_url_;
int64_t cache_id_;
int64_t cache_id_ = blink::mojom::kAppCacheNoCacheId;
AppCacheEntry entry_;
bool is_fallback_;
bool is_fallback_ = false;
// Receiver of the URLLoaderClient with us.
mojo::Receiver<network::mojom::URLLoader> receiver_{this};
......@@ -135,15 +218,17 @@ class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,
// The AppCacheRequest instance, used to inform the loader job about range
// request headers. Not owned by this class.
base::WeakPtr<AppCacheRequest> appcache_request_;
const base::WeakPtr<AppCacheRequest> appcache_request_;
bool is_deleting_soon_ = false;
bool is_main_resource_load_;
const bool is_main_resource_load_;
SEQUENCE_CHECKER(sequence_checker_);
base::WeakPtrFactory<AppCacheURLLoaderJob> weak_factory_{this};
DISALLOW_COPY_AND_ASSIGN(AppCacheURLLoaderJob);
base::WeakPtrFactory<AppCacheURLLoader> weak_factory_{this};
DISALLOW_COPY_AND_ASSIGN(AppCacheURLLoader);
};
} // namespace content
#endif // CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_JOB_H_
#endif // CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_H_
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