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