mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2025-06-05 21:39:12 +02:00
Update to Chromium version 91.0.4472.0 (#870763)
This commit is contained in:
@@ -206,13 +206,12 @@ class CefBrowserURLRequest::Context
|
||||
auto browser_context = cef_browser_context->AsBrowserContext();
|
||||
CHECK(browser_context);
|
||||
|
||||
int render_frame_id = MSG_ROUTING_NONE;
|
||||
scoped_refptr<net_service::URLLoaderFactoryGetter> loader_factory_getter;
|
||||
|
||||
// Used to route authentication and certificate callbacks through the
|
||||
// associated StoragePartition instance.
|
||||
mojo::PendingRemote<network::mojom::AuthenticationAndCertificateObserver>
|
||||
auth_cert_observer;
|
||||
mojo::PendingRemote<network::mojom::URLLoaderNetworkServiceObserver>
|
||||
url_loader_network_observer;
|
||||
|
||||
if (frame) {
|
||||
// The request will be associated with this frame/browser if it's valid,
|
||||
@@ -220,23 +219,16 @@ class CefBrowserURLRequest::Context
|
||||
content::RenderFrameHost* rfh =
|
||||
static_cast<CefFrameHostImpl*>(frame.get())->GetRenderFrameHost();
|
||||
if (rfh) {
|
||||
// In cases where authentication is required this value will be passed
|
||||
// as the |routing_id| parameter to
|
||||
// NetworkServiceClient::OnAuthRequired. Despite the naming the
|
||||
// GetWebContents method in network_service_client.cc expects it to be a
|
||||
// FrameTreeNodeId. The |process_id| parameter will always be
|
||||
// network::mojom::kBrowserProcessId (value 0) for these requests.
|
||||
render_frame_id = rfh->GetFrameTreeNodeId();
|
||||
|
||||
loader_factory_getter =
|
||||
net_service::URLLoaderFactoryGetter::Create(rfh, browser_context);
|
||||
auth_cert_observer = static_cast<content::RenderFrameHostImpl*>(rfh)
|
||||
->CreateAuthAndCertObserver();
|
||||
url_loader_network_observer =
|
||||
static_cast<content::RenderFrameHostImpl*>(rfh)
|
||||
->CreateURLLoaderNetworkObserver();
|
||||
}
|
||||
} else {
|
||||
loader_factory_getter =
|
||||
net_service::URLLoaderFactoryGetter::Create(nullptr, browser_context);
|
||||
auth_cert_observer =
|
||||
url_loader_network_observer =
|
||||
static_cast<content::StoragePartitionImpl*>(
|
||||
content::BrowserContext::GetDefaultStoragePartition(
|
||||
browser_context))
|
||||
@@ -247,16 +239,15 @@ class CefBrowserURLRequest::Context
|
||||
FROM_HERE,
|
||||
base::BindOnce(
|
||||
&CefBrowserURLRequest::Context::ContinueOnOriginatingThread, self,
|
||||
render_frame_id, MakeRequestID(), loader_factory_getter,
|
||||
std::move(auth_cert_observer)));
|
||||
MakeRequestID(), loader_factory_getter,
|
||||
std::move(url_loader_network_observer)));
|
||||
}
|
||||
|
||||
void ContinueOnOriginatingThread(
|
||||
int render_frame_id,
|
||||
int32_t request_id,
|
||||
scoped_refptr<net_service::URLLoaderFactoryGetter> loader_factory_getter,
|
||||
mojo::PendingRemote<network::mojom::AuthenticationAndCertificateObserver>
|
||||
auth_cert_observer) {
|
||||
mojo::PendingRemote<network::mojom::URLLoaderNetworkServiceObserver>
|
||||
url_loader_network_observer) {
|
||||
DCHECK(CalledOnValidThread());
|
||||
|
||||
// The request may have been canceled.
|
||||
@@ -282,8 +273,6 @@ class CefBrowserURLRequest::Context
|
||||
static_cast<CefRequestImpl*>(request_.get())
|
||||
->Get(resource_request.get(), false);
|
||||
|
||||
resource_request->render_frame_id = render_frame_id;
|
||||
|
||||
// Behave the same as a subresource load.
|
||||
resource_request->resource_type =
|
||||
static_cast<int>(blink::mojom::ResourceType::kSubResource);
|
||||
@@ -298,11 +287,11 @@ class CefBrowserURLRequest::Context
|
||||
net::SiteForCookies::FromOrigin(*resource_request->request_initiator);
|
||||
}
|
||||
|
||||
if (auth_cert_observer) {
|
||||
if (url_loader_network_observer) {
|
||||
resource_request->trusted_params =
|
||||
network::ResourceRequest::TrustedParams();
|
||||
resource_request->trusted_params->auth_cert_observer =
|
||||
std::move(auth_cert_observer);
|
||||
resource_request->trusted_params->url_loader_network_observer =
|
||||
std::move(url_loader_network_observer);
|
||||
}
|
||||
|
||||
// SimpleURLLoader is picky about the body contents. Try to populate them
|
||||
|
@@ -46,7 +46,7 @@ net::CookieOptions GetCookieOptions(const network::ResourceRequest& request) {
|
||||
options.set_include_httponly();
|
||||
options.set_same_site_cookie_context(
|
||||
net::cookie_util::ComputeSameSiteContextForRequest(
|
||||
request.method, request.url, request.site_for_cookies,
|
||||
request.method, {request.url}, request.site_for_cookies,
|
||||
request.request_initiator, is_main_frame_navigation,
|
||||
should_treat_as_first_party));
|
||||
|
||||
|
@@ -180,7 +180,7 @@ class InterceptedRequest : public network::mojom::URLLoader,
|
||||
public:
|
||||
InterceptedRequest(
|
||||
ProxyURLLoaderFactory* factory,
|
||||
RequestId id,
|
||||
int32_t id,
|
||||
uint32_t options,
|
||||
const network::ResourceRequest& request,
|
||||
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
|
||||
@@ -207,6 +207,7 @@ class InterceptedRequest : public network::mojom::URLLoader,
|
||||
OnHeadersReceivedCallback callback) override;
|
||||
|
||||
// mojom::URLLoaderClient methods:
|
||||
void OnReceiveEarlyHints(network::mojom::EarlyHintsPtr early_hints) override;
|
||||
void OnReceiveResponse(network::mojom::URLResponseHeadPtr head) override;
|
||||
void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
|
||||
network::mojom::URLResponseHeadPtr head) override;
|
||||
@@ -230,7 +231,7 @@ class InterceptedRequest : public network::mojom::URLLoader,
|
||||
void PauseReadingBodyFromNet() override;
|
||||
void ResumeReadingBodyFromNet() override;
|
||||
|
||||
const RequestId id() const { return id_; }
|
||||
int32_t id() const { return id_; }
|
||||
|
||||
private:
|
||||
// Helpers for determining the request handler.
|
||||
@@ -289,7 +290,7 @@ class InterceptedRequest : public network::mojom::URLLoader,
|
||||
void OnUploadProgressACK();
|
||||
|
||||
ProxyURLLoaderFactory* const factory_;
|
||||
const RequestId id_;
|
||||
const int32_t id_;
|
||||
const uint32_t options_;
|
||||
bool input_stream_previously_failed_ = false;
|
||||
bool request_was_redirected_ = false;
|
||||
@@ -346,19 +347,18 @@ class InterceptDelegate : public StreamReaderURLLoader::Delegate {
|
||||
base::WeakPtr<InterceptedRequest> request)
|
||||
: response_(std::move(response)), request_(request) {}
|
||||
|
||||
bool OpenInputStream(const RequestId& request_id,
|
||||
bool OpenInputStream(int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
OpenCallback callback) override {
|
||||
return response_->OpenInputStream(request_id, request, std::move(callback));
|
||||
}
|
||||
|
||||
void OnInputStreamOpenFailed(const RequestId& request_id,
|
||||
bool* restarted) override {
|
||||
void OnInputStreamOpenFailed(int32_t request_id, bool* restarted) override {
|
||||
request_->InputStreamFailed(false /* restart_needed */);
|
||||
*restarted = false;
|
||||
}
|
||||
|
||||
void GetResponseHeaders(const RequestId& request_id,
|
||||
void GetResponseHeaders(int32_t request_id,
|
||||
int* status_code,
|
||||
std::string* reason_phrase,
|
||||
std::string* mime_type,
|
||||
@@ -377,7 +377,7 @@ class InterceptDelegate : public StreamReaderURLLoader::Delegate {
|
||||
|
||||
InterceptedRequest::InterceptedRequest(
|
||||
ProxyURLLoaderFactory* factory,
|
||||
RequestId id,
|
||||
int32_t id,
|
||||
uint32_t options,
|
||||
const network::ResourceRequest& request,
|
||||
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
|
||||
@@ -533,6 +533,11 @@ void InterceptedRequest::OnHeadersReceived(
|
||||
|
||||
// URLLoaderClient methods.
|
||||
|
||||
void InterceptedRequest::OnReceiveEarlyHints(
|
||||
network::mojom::EarlyHintsPtr early_hints) {
|
||||
target_client_->OnReceiveEarlyHints(std::move(early_hints));
|
||||
}
|
||||
|
||||
void InterceptedRequest::OnReceiveResponse(
|
||||
network::mojom::URLResponseHeadPtr head) {
|
||||
current_response_ = std::move(head);
|
||||
@@ -776,8 +781,7 @@ void InterceptedRequest::ContinueAfterIntercept() {
|
||||
// might, so we need to set the option on the loader.
|
||||
uint32_t options = options_ | network::mojom::kURLLoadOptionUseHeaderClient;
|
||||
target_factory_->CreateLoaderAndStart(
|
||||
target_loader_.BindNewPipeAndPassReceiver(), id_.routing_id(),
|
||||
id_.request_id(), options, request_,
|
||||
target_loader_.BindNewPipeAndPassReceiver(), id_, options, request_,
|
||||
proxied_client_receiver_.BindNewPipeAndPassRemote(),
|
||||
traffic_annotation_);
|
||||
}
|
||||
@@ -1141,7 +1145,7 @@ InterceptedRequestHandler::InterceptedRequestHandler() {}
|
||||
InterceptedRequestHandler::~InterceptedRequestHandler() {}
|
||||
|
||||
void InterceptedRequestHandler::OnBeforeRequest(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
bool request_was_redirected,
|
||||
OnBeforeRequestResultCallback callback,
|
||||
@@ -1150,14 +1154,14 @@ void InterceptedRequestHandler::OnBeforeRequest(
|
||||
}
|
||||
|
||||
void InterceptedRequestHandler::ShouldInterceptRequest(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
ShouldInterceptRequestResultCallback callback) {
|
||||
std::move(callback).Run(nullptr);
|
||||
}
|
||||
|
||||
void InterceptedRequestHandler::OnRequestResponse(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
net::HttpResponseHeaders* headers,
|
||||
base::Optional<net::RedirectInfo> redirect_info,
|
||||
@@ -1169,7 +1173,7 @@ void InterceptedRequestHandler::OnRequestResponse(
|
||||
|
||||
mojo::ScopedDataPipeConsumerHandle
|
||||
InterceptedRequestHandler::OnFilterResponseBody(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
mojo::ScopedDataPipeConsumerHandle body) {
|
||||
return body;
|
||||
@@ -1287,7 +1291,6 @@ void ProxyURLLoaderFactory::CreateProxy(
|
||||
|
||||
void ProxyURLLoaderFactory::CreateLoaderAndStart(
|
||||
mojo::PendingReceiver<network::mojom::URLLoader> receiver,
|
||||
int32_t routing_id,
|
||||
int32_t request_id,
|
||||
uint32_t options,
|
||||
const network::ResourceRequest& request,
|
||||
@@ -1303,9 +1306,9 @@ void ProxyURLLoaderFactory::CreateLoaderAndStart(
|
||||
if (pass_through) {
|
||||
// This is the so-called pass-through, no-op option.
|
||||
if (target_factory_) {
|
||||
target_factory_->CreateLoaderAndStart(
|
||||
std::move(receiver), routing_id, request_id, options, request,
|
||||
std::move(client), traffic_annotation);
|
||||
target_factory_->CreateLoaderAndStart(std::move(receiver), request_id,
|
||||
options, request, std::move(client),
|
||||
traffic_annotation);
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -1317,9 +1320,8 @@ void ProxyURLLoaderFactory::CreateLoaderAndStart(
|
||||
}
|
||||
|
||||
InterceptedRequest* req = new InterceptedRequest(
|
||||
this, RequestId(request_id, routing_id), options, request,
|
||||
traffic_annotation, std::move(receiver), std::move(client),
|
||||
std::move(target_factory_clone));
|
||||
this, request_id, options, request, traffic_annotation,
|
||||
std::move(receiver), std::move(client), std::move(target_factory_clone));
|
||||
requests_.insert(std::make_pair(request_id, base::WrapUnique(req)));
|
||||
req->Restart();
|
||||
}
|
||||
@@ -1362,7 +1364,7 @@ void ProxyURLLoaderFactory::OnProxyBindingError() {
|
||||
}
|
||||
|
||||
void ProxyURLLoaderFactory::RemoveRequest(InterceptedRequest* request) {
|
||||
auto it = requests_.find(request->id().request_id());
|
||||
auto it = requests_.find(request->id());
|
||||
DCHECK(it != requests_.end());
|
||||
requests_.erase(it);
|
||||
|
||||
|
@@ -46,7 +46,7 @@ class InterceptedRequestHandler {
|
||||
base::OnceCallback<void(bool /* intercept_request */,
|
||||
bool /* intercept_only */)>;
|
||||
using CancelRequestCallback = base::OnceCallback<void(int /* error_code */)>;
|
||||
virtual void OnBeforeRequest(const RequestId& id,
|
||||
virtual void OnBeforeRequest(int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
bool request_was_redirected,
|
||||
OnBeforeRequestResultCallback callback,
|
||||
@@ -57,7 +57,7 @@ class InterceptedRequestHandler {
|
||||
using ShouldInterceptRequestResultCallback =
|
||||
base::OnceCallback<void(std::unique_ptr<ResourceResponse>)>;
|
||||
virtual void ShouldInterceptRequest(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
ShouldInterceptRequestResultCallback callback);
|
||||
|
||||
@@ -68,7 +68,7 @@ class InterceptedRequestHandler {
|
||||
// values will be merged first, and then any |removed_headers| values will be
|
||||
// removed. This comparison is case sensitive.
|
||||
virtual void ProcessRequestHeaders(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
const GURL& redirect_url,
|
||||
net::HttpRequestHeaders* modified_headers,
|
||||
@@ -79,7 +79,7 @@ class InterceptedRequestHandler {
|
||||
// method is called in response to a redirect. Even though |head| is const the
|
||||
// |head.headers| value is non-const and any changes will be passed to the
|
||||
// client.
|
||||
virtual void ProcessResponseHeaders(const RequestId& id,
|
||||
virtual void ProcessResponseHeaders(int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
const GURL& redirect_url,
|
||||
net::HttpResponseHeaders* headers) {}
|
||||
@@ -101,7 +101,7 @@ class InterceptedRequestHandler {
|
||||
scoped_refptr<net::HttpResponseHeaders> /* override_headers */,
|
||||
const GURL& /* redirect_url */)>;
|
||||
virtual void OnRequestResponse(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
net::HttpResponseHeaders* headers,
|
||||
base::Optional<net::RedirectInfo> redirect_info,
|
||||
@@ -109,18 +109,18 @@ class InterceptedRequestHandler {
|
||||
|
||||
// Called to optionally filter the response body.
|
||||
virtual mojo::ScopedDataPipeConsumerHandle OnFilterResponseBody(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
mojo::ScopedDataPipeConsumerHandle body);
|
||||
|
||||
// Called on completion notification from the loader (successful or not).
|
||||
virtual void OnRequestComplete(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
const network::URLLoaderCompletionStatus& status) {}
|
||||
|
||||
// Called on error.
|
||||
virtual void OnRequestError(const RequestId& id,
|
||||
virtual void OnRequestError(int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
int error_code,
|
||||
bool safebrowsing_hit) {}
|
||||
@@ -156,7 +156,6 @@ class ProxyURLLoaderFactory
|
||||
// mojom::URLLoaderFactory methods:
|
||||
void CreateLoaderAndStart(
|
||||
mojo::PendingReceiver<network::mojom::URLLoader> receiver,
|
||||
int32_t routing_id,
|
||||
int32_t request_id,
|
||||
uint32_t options,
|
||||
const network::ResourceRequest& request,
|
||||
|
@@ -372,7 +372,7 @@ void CallProcessRequestOnIOThread(
|
||||
|
||||
class ResourceResponseWrapper : public ResourceResponse {
|
||||
public:
|
||||
ResourceResponseWrapper(const RequestId request_id,
|
||||
ResourceResponseWrapper(const int32_t request_id,
|
||||
CefRefPtr<CefResourceHandler> handler)
|
||||
: request_id_(request_id),
|
||||
handler_provider_(new HandlerProvider(handler)) {}
|
||||
@@ -383,7 +383,7 @@ class ResourceResponseWrapper : public ResourceResponse {
|
||||
}
|
||||
|
||||
// ResourceResponse methods:
|
||||
bool OpenInputStream(const RequestId& request_id,
|
||||
bool OpenInputStream(int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
OpenCallback callback) override {
|
||||
DCHECK_EQ(request_id, request_id_);
|
||||
@@ -396,7 +396,7 @@ class ResourceResponseWrapper : public ResourceResponse {
|
||||
|
||||
// May be recreated on redirect.
|
||||
request_ = new CefRequestImpl();
|
||||
request_->Set(&request, request_id.hash());
|
||||
request_->Set(&request, request_id);
|
||||
request_->SetReadOnly(true);
|
||||
|
||||
CefRefPtr<OpenCallbackWrapper> callbackWrapper = new OpenCallbackWrapper(
|
||||
@@ -426,7 +426,7 @@ class ResourceResponseWrapper : public ResourceResponse {
|
||||
return true;
|
||||
}
|
||||
|
||||
void GetResponseHeaders(const RequestId& request_id,
|
||||
void GetResponseHeaders(int32_t request_id,
|
||||
int* status_code,
|
||||
std::string* reason_phrase,
|
||||
std::string* mime_type,
|
||||
@@ -487,7 +487,7 @@ class ResourceResponseWrapper : public ResourceResponse {
|
||||
}
|
||||
|
||||
private:
|
||||
const RequestId request_id_;
|
||||
const int32_t request_id_;
|
||||
|
||||
CefRefPtr<CefRequestImpl> request_;
|
||||
scoped_refptr<HandlerProvider> handler_provider_;
|
||||
@@ -498,7 +498,7 @@ class ResourceResponseWrapper : public ResourceResponse {
|
||||
} // namespace
|
||||
|
||||
std::unique_ptr<ResourceResponse> CreateResourceResponse(
|
||||
const RequestId& request_id,
|
||||
int32_t request_id,
|
||||
CefRefPtr<CefResourceHandler> handler) {
|
||||
return std::make_unique<ResourceResponseWrapper>(request_id, handler);
|
||||
}
|
||||
|
@@ -10,14 +10,13 @@
|
||||
|
||||
namespace net_service {
|
||||
|
||||
class RequestId;
|
||||
class ResourceResponse;
|
||||
|
||||
// Create a ResourceResponse that delegates to |handler|.
|
||||
// The resulting object should be passed to
|
||||
// InterceptedRequestHandler::ShouldInterceptRequestResultCallback.
|
||||
std::unique_ptr<ResourceResponse> CreateResourceResponse(
|
||||
const RequestId& request_id,
|
||||
int32_t request_id,
|
||||
CefRefPtr<CefResourceHandler> handler);
|
||||
|
||||
} // namespace net_service
|
||||
|
@@ -131,12 +131,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
};
|
||||
|
||||
struct PendingRequest {
|
||||
PendingRequest(const RequestId& id,
|
||||
PendingRequest(int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
bool request_was_redirected,
|
||||
OnBeforeRequestResultCallback callback,
|
||||
CancelRequestCallback cancel_callback)
|
||||
: id_(id),
|
||||
: id_(request_id),
|
||||
request_(request),
|
||||
request_was_redirected_(request_was_redirected),
|
||||
callback_(std::move(callback)),
|
||||
@@ -153,7 +153,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
std::move(callback_), std::move(cancel_callback_));
|
||||
}
|
||||
|
||||
const RequestId id_;
|
||||
const int32_t id_;
|
||||
network::ResourceRequest* const request_;
|
||||
const bool request_was_redirected_;
|
||||
OnBeforeRequestResultCallback callback_;
|
||||
@@ -251,7 +251,6 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
CefRefPtr<CefBrowserHostBase> browser,
|
||||
CefRefPtr<CefFrame> frame,
|
||||
int render_process_id,
|
||||
int render_frame_id,
|
||||
int frame_tree_node_id,
|
||||
bool is_navigation,
|
||||
bool is_download,
|
||||
@@ -280,7 +279,6 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
|
||||
render_process_id_ = render_process_id;
|
||||
render_frame_id_ = render_frame_id;
|
||||
frame_tree_node_id_ = frame_tree_node_id;
|
||||
is_navigation_ = is_navigation;
|
||||
is_download_ = is_download;
|
||||
@@ -317,7 +315,6 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
scoped_refptr<CefIOThreadState> iothread_state_;
|
||||
CefBrowserContext::CookieableSchemes cookieable_schemes_;
|
||||
int render_process_id_ = 0;
|
||||
int render_frame_id_ = -1;
|
||||
int frame_tree_node_id_ = -1;
|
||||
bool is_navigation_ = true;
|
||||
bool is_download_ = false;
|
||||
@@ -413,7 +410,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
|
||||
// InterceptedRequestHandler methods:
|
||||
void OnBeforeRequest(const RequestId& id,
|
||||
void OnBeforeRequest(int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
bool request_was_redirected,
|
||||
OnBeforeRequestResultCallback callback,
|
||||
@@ -429,13 +426,13 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
if (!init_state_) {
|
||||
// Queue requests until we're initialized.
|
||||
pending_requests_.push_back(std::make_unique<PendingRequest>(
|
||||
id, request, request_was_redirected, std::move(callback),
|
||||
request_id, request, request_was_redirected, std::move(callback),
|
||||
std::move(cancel_callback)));
|
||||
return;
|
||||
}
|
||||
|
||||
// State may already exist for restarted requests.
|
||||
RequestState* state = GetOrCreateState(id);
|
||||
RequestState* state = GetOrCreateState(request_id);
|
||||
|
||||
// Add standard headers, if currently unspecified.
|
||||
request->headers.SetHeaderIfMissing(
|
||||
@@ -451,12 +448,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
|
||||
CefRefPtr<CefRequestImpl> requestPtr;
|
||||
CefRefPtr<CefResourceRequestHandler> handler =
|
||||
GetHandler(id, request, &intercept_only, requestPtr);
|
||||
GetHandler(request_id, request, &intercept_only, requestPtr);
|
||||
|
||||
CefRefPtr<CefSchemeHandlerFactory> scheme_factory =
|
||||
init_state_->iothread_state_->GetSchemeHandlerFactory(request->url);
|
||||
if (scheme_factory && !requestPtr) {
|
||||
requestPtr = MakeRequest(request, id.hash(), true);
|
||||
requestPtr = MakeRequest(request, request_id, true);
|
||||
}
|
||||
|
||||
// True if there's a possibility that the client might handle the request.
|
||||
@@ -483,10 +480,10 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
return;
|
||||
}
|
||||
|
||||
MaybeLoadCookies(id, state, request, std::move(exec_callback));
|
||||
MaybeLoadCookies(request_id, state, request, std::move(exec_callback));
|
||||
}
|
||||
|
||||
void MaybeLoadCookies(const RequestId& id,
|
||||
void MaybeLoadCookies(int32_t request_id,
|
||||
RequestState* state,
|
||||
network::ResourceRequest* request,
|
||||
base::OnceClosure callback) {
|
||||
@@ -505,12 +502,13 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
state->cookie_filter_
|
||||
? base::BindRepeating(
|
||||
&InterceptedRequestHandlerWrapper::AllowCookieLoad,
|
||||
weak_ptr_factory_.GetWeakPtr(), id)
|
||||
weak_ptr_factory_.GetWeakPtr(), request_id)
|
||||
: base::BindRepeating(
|
||||
&InterceptedRequestHandlerWrapper::AllowCookieAlways);
|
||||
auto done_cookie_callback = base::BindOnce(
|
||||
&InterceptedRequestHandlerWrapper::ContinueWithLoadedCookies,
|
||||
weak_ptr_factory_.GetWeakPtr(), id, request, std::move(callback));
|
||||
weak_ptr_factory_.GetWeakPtr(), request_id, request,
|
||||
std::move(callback));
|
||||
cookie_helper::LoadCookies(init_state_->browser_context_, *request,
|
||||
allow_cookie_callback,
|
||||
std::move(done_cookie_callback));
|
||||
@@ -521,12 +519,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
*allow = true;
|
||||
}
|
||||
|
||||
void AllowCookieLoad(const RequestId& id,
|
||||
void AllowCookieLoad(int32_t request_id,
|
||||
const net::CanonicalCookie& cookie,
|
||||
bool* allow) {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled while the async callback was
|
||||
// pending.
|
||||
@@ -543,14 +541,14 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
}
|
||||
|
||||
void ContinueWithLoadedCookies(const RequestId& id,
|
||||
void ContinueWithLoadedCookies(int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
base::OnceClosure callback,
|
||||
int total_count,
|
||||
net::CookieList allowed_cookies) {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled while the async callback was
|
||||
// pending.
|
||||
@@ -579,12 +577,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
|
||||
void ShouldInterceptRequest(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
ShouldInterceptRequestResultCallback callback) override {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled during destruction.
|
||||
return;
|
||||
@@ -603,8 +601,8 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
CefRefPtr<RequestCallbackWrapper> callbackPtr =
|
||||
new RequestCallbackWrapper(base::BindOnce(
|
||||
&InterceptedRequestHandlerWrapper::ContinueShouldInterceptRequest,
|
||||
weak_ptr_factory_.GetWeakPtr(), id, base::Unretained(request),
|
||||
std::move(callback)));
|
||||
weak_ptr_factory_.GetWeakPtr(), request_id,
|
||||
base::Unretained(request), std::move(callback)));
|
||||
|
||||
cef_return_value_t retval = state->handler_->OnBeforeResourceLoad(
|
||||
init_state_->browser_, init_state_->frame_,
|
||||
@@ -615,18 +613,19 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
} else {
|
||||
// The scheme factory may choose to handle it.
|
||||
ContinueShouldInterceptRequest(id, request, std::move(callback), true);
|
||||
ContinueShouldInterceptRequest(request_id, request, std::move(callback),
|
||||
true);
|
||||
}
|
||||
}
|
||||
|
||||
void ContinueShouldInterceptRequest(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
ShouldInterceptRequestResultCallback callback,
|
||||
bool allow) {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled while the async callback was
|
||||
// pending.
|
||||
@@ -685,7 +684,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
|
||||
std::unique_ptr<ResourceResponse> resource_response;
|
||||
if (resource_handler) {
|
||||
resource_response = CreateResourceResponse(id, resource_handler);
|
||||
resource_response = CreateResourceResponse(request_id, resource_handler);
|
||||
DCHECK(resource_response);
|
||||
state->was_custom_handled_ = true;
|
||||
} else {
|
||||
@@ -699,13 +698,13 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
std::move(callback).Run(std::move(resource_response));
|
||||
}
|
||||
|
||||
void ProcessResponseHeaders(const RequestId& id,
|
||||
void ProcessResponseHeaders(int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
const GURL& redirect_url,
|
||||
net::HttpResponseHeaders* headers) override {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled during destruction.
|
||||
return;
|
||||
@@ -725,14 +724,14 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
state->pending_response_->SetReadOnly(true);
|
||||
}
|
||||
|
||||
void OnRequestResponse(const RequestId& id,
|
||||
void OnRequestResponse(int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
net::HttpResponseHeaders* headers,
|
||||
base::Optional<net::RedirectInfo> redirect_info,
|
||||
OnRequestResponseResultCallback callback) override {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled during destruction.
|
||||
return;
|
||||
@@ -746,7 +745,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
if (!state->handler_) {
|
||||
// Cookies may come from a scheme handler.
|
||||
MaybeSaveCookies(
|
||||
id, state, request, headers,
|
||||
request_id, state, request, headers,
|
||||
base::BindOnce(
|
||||
std::move(callback), ResponseMode::CONTINUE, nullptr,
|
||||
redirect_info.has_value() ? redirect_info->new_url : GURL()));
|
||||
@@ -757,14 +756,14 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
DCHECK(state->pending_response_);
|
||||
|
||||
if (redirect_info.has_value()) {
|
||||
HandleRedirect(id, state, request, headers, *redirect_info,
|
||||
HandleRedirect(request_id, state, request, headers, *redirect_info,
|
||||
std::move(callback));
|
||||
} else {
|
||||
HandleResponse(id, state, request, headers, std::move(callback));
|
||||
HandleResponse(request_id, state, request, headers, std::move(callback));
|
||||
}
|
||||
}
|
||||
|
||||
void HandleRedirect(const RequestId& id,
|
||||
void HandleRedirect(int32_t request_id,
|
||||
RequestState* state,
|
||||
network::ResourceRequest* request,
|
||||
net::HttpResponseHeaders* headers,
|
||||
@@ -797,10 +796,11 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
auto exec_callback = base::BindOnce(
|
||||
std::move(callback), ResponseMode::CONTINUE, nullptr, new_url);
|
||||
|
||||
MaybeSaveCookies(id, state, request, headers, std::move(exec_callback));
|
||||
MaybeSaveCookies(request_id, state, request, headers,
|
||||
std::move(exec_callback));
|
||||
}
|
||||
|
||||
void HandleResponse(const RequestId& id,
|
||||
void HandleResponse(int32_t request_id,
|
||||
RequestState* state,
|
||||
network::ResourceRequest* request,
|
||||
net::HttpResponseHeaders* headers,
|
||||
@@ -846,10 +846,11 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
return;
|
||||
}
|
||||
|
||||
MaybeSaveCookies(id, state, request, headers, std::move(exec_callback));
|
||||
MaybeSaveCookies(request_id, state, request, headers,
|
||||
std::move(exec_callback));
|
||||
}
|
||||
|
||||
void MaybeSaveCookies(const RequestId& id,
|
||||
void MaybeSaveCookies(int32_t request_id,
|
||||
RequestState* state,
|
||||
network::ResourceRequest* request,
|
||||
net::HttpResponseHeaders* headers,
|
||||
@@ -875,23 +876,23 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
state->cookie_filter_
|
||||
? base::BindRepeating(
|
||||
&InterceptedRequestHandlerWrapper::AllowCookieSave,
|
||||
weak_ptr_factory_.GetWeakPtr(), id)
|
||||
weak_ptr_factory_.GetWeakPtr(), request_id)
|
||||
: base::BindRepeating(
|
||||
&InterceptedRequestHandlerWrapper::AllowCookieAlways);
|
||||
auto done_cookie_callback = base::BindOnce(
|
||||
&InterceptedRequestHandlerWrapper::ContinueWithSavedCookies,
|
||||
weak_ptr_factory_.GetWeakPtr(), id, std::move(callback));
|
||||
weak_ptr_factory_.GetWeakPtr(), request_id, std::move(callback));
|
||||
cookie_helper::SaveCookies(init_state_->browser_context_, *request, headers,
|
||||
allow_cookie_callback,
|
||||
std::move(done_cookie_callback));
|
||||
}
|
||||
|
||||
void AllowCookieSave(const RequestId& id,
|
||||
void AllowCookieSave(int32_t request_id,
|
||||
const net::CanonicalCookie& cookie,
|
||||
bool* allow) {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled while the async callback was
|
||||
// pending.
|
||||
@@ -909,7 +910,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
}
|
||||
|
||||
void ContinueWithSavedCookies(const RequestId& id,
|
||||
void ContinueWithSavedCookies(int32_t request_id,
|
||||
base::OnceClosure callback,
|
||||
int total_count,
|
||||
net::CookieList allowed_cookies) {
|
||||
@@ -918,12 +919,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
|
||||
mojo::ScopedDataPipeConsumerHandle OnFilterResponseBody(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
mojo::ScopedDataPipeConsumerHandle body) override {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled during destruction.
|
||||
return body;
|
||||
@@ -937,17 +938,17 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
return CreateResponseFilterHandler(
|
||||
filter, std::move(body),
|
||||
base::BindOnce(&InterceptedRequestHandlerWrapper::OnFilterError,
|
||||
weak_ptr_factory_.GetWeakPtr(), id));
|
||||
weak_ptr_factory_.GetWeakPtr(), request_id));
|
||||
}
|
||||
}
|
||||
|
||||
return body;
|
||||
}
|
||||
|
||||
void OnFilterError(const RequestId& id) {
|
||||
void OnFilterError(int32_t request_id) {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been canceled while the async callback was
|
||||
// pending.
|
||||
@@ -960,12 +961,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
|
||||
void OnRequestComplete(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
const network::URLLoaderCompletionStatus& status) override {
|
||||
CEF_REQUIRE_IOT();
|
||||
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
// The request may have been aborted during initialization or canceled
|
||||
// during destruction. This method will always be called before a request
|
||||
@@ -974,7 +975,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
if (!pending_requests_.empty()) {
|
||||
PendingRequests::iterator it = pending_requests_.begin();
|
||||
for (; it != pending_requests_.end(); ++it) {
|
||||
if ((*it)->id_ == id) {
|
||||
if ((*it)->id_ == request_id) {
|
||||
pending_requests_.erase(it);
|
||||
break;
|
||||
}
|
||||
@@ -1011,7 +1012,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
}
|
||||
}
|
||||
|
||||
RemoveState(id);
|
||||
RemoveState(request_id);
|
||||
}
|
||||
|
||||
private:
|
||||
@@ -1045,14 +1046,12 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
|
||||
// Returns the handler, if any, that should be used for this request.
|
||||
CefRefPtr<CefResourceRequestHandler> GetHandler(
|
||||
const RequestId& id,
|
||||
int32_t request_id,
|
||||
network::ResourceRequest* request,
|
||||
bool* intercept_only,
|
||||
CefRefPtr<CefRequestImpl>& requestPtr) const {
|
||||
CefRefPtr<CefResourceRequestHandler> handler;
|
||||
|
||||
const int64 request_id = id.hash();
|
||||
|
||||
if (init_state_->browser_) {
|
||||
// Maybe the browser's client wants to handle it?
|
||||
CefRefPtr<CefClient> client =
|
||||
@@ -1075,8 +1074,8 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
// Maybe the request context wants to handle it?
|
||||
CefRefPtr<CefRequestContextHandler> context_handler =
|
||||
init_state_->iothread_state_->GetHandler(
|
||||
init_state_->render_process_id_, request->render_frame_id,
|
||||
init_state_->frame_tree_node_id_, false);
|
||||
init_state_->render_process_id_, MSG_ROUTING_NONE,
|
||||
init_state_->frame_tree_node_id_, /*require_frame_match=*/false);
|
||||
if (context_handler) {
|
||||
if (!requestPtr)
|
||||
requestPtr = MakeRequest(request, request_id, true);
|
||||
@@ -1091,24 +1090,24 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
return handler;
|
||||
}
|
||||
|
||||
RequestState* GetOrCreateState(const RequestId& id) {
|
||||
RequestState* state = GetState(id);
|
||||
RequestState* GetOrCreateState(int32_t request_id) {
|
||||
RequestState* state = GetState(request_id);
|
||||
if (!state) {
|
||||
state = new RequestState();
|
||||
request_map_.insert(std::make_pair(id, base::WrapUnique(state)));
|
||||
request_map_.insert(std::make_pair(request_id, base::WrapUnique(state)));
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
RequestState* GetState(const RequestId& id) const {
|
||||
RequestMap::const_iterator it = request_map_.find(id);
|
||||
RequestState* GetState(int32_t request_id) const {
|
||||
RequestMap::const_iterator it = request_map_.find(request_id);
|
||||
if (it != request_map_.end())
|
||||
return it->second.get();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void RemoveState(const RequestId& id) {
|
||||
RequestMap::iterator it = request_map_.find(id);
|
||||
void RemoveState(int32_t request_id) {
|
||||
RequestMap::iterator it = request_map_.find(request_id);
|
||||
DCHECK(it != request_map_.end());
|
||||
if (it != request_map_.end())
|
||||
request_map_.erase(it);
|
||||
@@ -1186,7 +1185,7 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
|
||||
|
||||
bool shutting_down_ = false;
|
||||
|
||||
using RequestMap = std::map<RequestId, std::unique_ptr<RequestState>>;
|
||||
using RequestMap = std::map<int32_t, std::unique_ptr<RequestState>>;
|
||||
RequestMap request_map_;
|
||||
|
||||
using PendingRequests = std::vector<std::unique_ptr<PendingRequest>>;
|
||||
@@ -1220,27 +1219,21 @@ void InitOnUIThread(
|
||||
|
||||
content::RenderFrameHost* frame = nullptr;
|
||||
|
||||
if (request.render_frame_id >= 0) {
|
||||
// TODO(network): Are these main frame checks equivalent?
|
||||
if (request.is_main_frame ||
|
||||
static_cast<blink::mojom::ResourceType>(request.resource_type) ==
|
||||
blink::mojom::ResourceType::kMainFrame) {
|
||||
if (request.is_main_frame ||
|
||||
static_cast<blink::mojom::ResourceType>(request.resource_type) ==
|
||||
blink::mojom::ResourceType::kMainFrame) {
|
||||
frame = web_contents->GetMainFrame();
|
||||
DCHECK(frame);
|
||||
} else {
|
||||
if (frame_tree_node_id >= 0) {
|
||||
// May return null for frames in inner WebContents.
|
||||
frame = web_contents->FindFrameByFrameTreeNodeId(frame_tree_node_id,
|
||||
render_process_id);
|
||||
}
|
||||
if (!frame) {
|
||||
// Use the main frame for the CefBrowserHost.
|
||||
frame = web_contents->GetMainFrame();
|
||||
DCHECK(frame);
|
||||
} else {
|
||||
// May return null for newly created iframes.
|
||||
frame = content::RenderFrameHost::FromID(render_process_id,
|
||||
request.render_frame_id);
|
||||
if (!frame && frame_tree_node_id >= 0) {
|
||||
// May return null for frames in inner WebContents.
|
||||
frame = web_contents->FindFrameByFrameTreeNodeId(frame_tree_node_id,
|
||||
render_process_id);
|
||||
}
|
||||
if (!frame) {
|
||||
// Use the main frame for the CefBrowserHost.
|
||||
frame = web_contents->GetMainFrame();
|
||||
DCHECK(frame);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1270,9 +1263,9 @@ void InitOnUIThread(
|
||||
auto init_state =
|
||||
std::make_unique<InterceptedRequestHandlerWrapper::InitState>();
|
||||
init_state->Initialize(browser_context, browserPtr, framePtr,
|
||||
render_process_id, request.render_frame_id,
|
||||
frame_tree_node_id, is_navigation, is_download,
|
||||
request_initiator, unhandled_request_callback);
|
||||
render_process_id, frame_tree_node_id, is_navigation,
|
||||
is_download, request_initiator,
|
||||
unhandled_request_callback);
|
||||
|
||||
init_helper->MaybeSetInitialized(std::move(init_state));
|
||||
}
|
||||
@@ -1289,12 +1282,10 @@ std::unique_ptr<InterceptedRequestHandler> CreateInterceptedRequestHandler(
|
||||
CEF_REQUIRE_UIT();
|
||||
CefRefPtr<CefBrowserHostBase> browserPtr;
|
||||
CefRefPtr<CefFrame> framePtr;
|
||||
int render_frame_id = -1;
|
||||
int frame_tree_node_id = -1;
|
||||
|
||||
// |frame| may be null for service worker requests.
|
||||
if (frame) {
|
||||
render_frame_id = frame->GetRoutingID();
|
||||
frame_tree_node_id = frame->GetFrameTreeNodeId();
|
||||
|
||||
// May return nullptr for requests originating from guest views.
|
||||
@@ -1308,9 +1299,8 @@ std::unique_ptr<InterceptedRequestHandler> CreateInterceptedRequestHandler(
|
||||
auto init_state =
|
||||
std::make_unique<InterceptedRequestHandlerWrapper::InitState>();
|
||||
init_state->Initialize(browser_context, browserPtr, framePtr,
|
||||
render_process_id, render_frame_id, frame_tree_node_id,
|
||||
is_navigation, is_download, request_initiator,
|
||||
base::Closure());
|
||||
render_process_id, frame_tree_node_id, is_navigation,
|
||||
is_download, request_initiator, base::Closure());
|
||||
|
||||
auto wrapper = std::make_unique<InterceptedRequestHandlerWrapper>();
|
||||
wrapper->init_helper()->MaybeSetInitialized(std::move(init_state));
|
||||
|
@@ -14,6 +14,7 @@
|
||||
#include "base/strings/string_util.h"
|
||||
#include "base/strings/stringprintf.h"
|
||||
#include "base/task/post_task.h"
|
||||
#include "base/task/thread_pool.h"
|
||||
#include "base/threading/thread.h"
|
||||
#include "base/threading/thread_task_runner_handle.h"
|
||||
#include "content/public/browser/browser_thread.h"
|
||||
@@ -37,7 +38,7 @@ class OpenInputStreamWrapper
|
||||
static base::OnceClosure Open(
|
||||
std::unique_ptr<StreamReaderURLLoader::Delegate> delegate,
|
||||
scoped_refptr<base::SequencedTaskRunner> work_thread_task_runner,
|
||||
const RequestId& request_id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
OnInputStreamOpenedCallback callback) WARN_UNUSED_RESULT {
|
||||
scoped_refptr<OpenInputStreamWrapper> wrapper = new OpenInputStreamWrapper(
|
||||
@@ -62,8 +63,7 @@ class OpenInputStreamWrapper
|
||||
callback_(std::move(callback)) {}
|
||||
virtual ~OpenInputStreamWrapper() {}
|
||||
|
||||
void Start(const RequestId& request_id,
|
||||
const network::ResourceRequest& request) {
|
||||
void Start(int32_t request_id, const network::ResourceRequest& request) {
|
||||
work_thread_task_runner_->PostTask(
|
||||
FROM_HERE,
|
||||
base::BindOnce(&OpenInputStreamWrapper::OpenOnWorkThread,
|
||||
@@ -95,7 +95,7 @@ class OpenInputStreamWrapper
|
||||
OnCallback(nullptr);
|
||||
}
|
||||
|
||||
void OpenOnWorkThread(const RequestId& request_id,
|
||||
void OpenOnWorkThread(int32_t request_id,
|
||||
const network::ResourceRequest& request) {
|
||||
DCHECK(work_thread_task_runner_->RunsTasksInCurrentSequence());
|
||||
if (is_canceled_)
|
||||
@@ -455,30 +455,12 @@ void InputStreamReader::RunReadCallbackOnJobThread(
|
||||
std::move(read_callback).Run(bytes_read);
|
||||
}
|
||||
|
||||
//==============================
|
||||
// RequestId
|
||||
//==============================
|
||||
|
||||
std::string RequestId::ToString() const {
|
||||
return base::StringPrintf("RequestId(%u, %u)", request_id_, routing_id_);
|
||||
}
|
||||
|
||||
std::string RequestId::ToString(base::StringPiece debug_label) const {
|
||||
return base::StringPrintf("RequestId[%s](%u, %u)",
|
||||
debug_label.as_string().c_str(), request_id_,
|
||||
routing_id_);
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const RequestId& request_id) {
|
||||
return out << request_id.ToString();
|
||||
}
|
||||
|
||||
//==============================
|
||||
// StreamReaderURLLoader
|
||||
//=============================
|
||||
|
||||
StreamReaderURLLoader::StreamReaderURLLoader(
|
||||
const RequestId& request_id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
|
||||
mojo::PendingRemote<network::mojom::TrustedHeaderClient> header_client,
|
||||
@@ -502,7 +484,7 @@ StreamReaderURLLoader::StreamReaderURLLoader(
|
||||
|
||||
// All InputStream work will be performed on this task runner.
|
||||
stream_work_task_runner_ =
|
||||
base::CreateSequencedTaskRunner({base::ThreadPool(), base::MayBlock()});
|
||||
base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
|
||||
}
|
||||
|
||||
StreamReaderURLLoader::~StreamReaderURLLoader() {
|
||||
|
@@ -63,54 +63,6 @@ class InputStream {
|
||||
ReadCallback callback) = 0;
|
||||
};
|
||||
|
||||
// Unique identifier for RequestHandler callbacks.
|
||||
// Based on components/viz/common/surfaces/frame_sink_id.h
|
||||
class RequestId {
|
||||
public:
|
||||
constexpr RequestId() : request_id_(0), routing_id_(0) {}
|
||||
|
||||
constexpr RequestId(const RequestId& other)
|
||||
: request_id_(other.request_id_), routing_id_(other.routing_id_) {}
|
||||
|
||||
constexpr RequestId(uint32_t request_id, uint32_t routing_id)
|
||||
: request_id_(request_id), routing_id_(routing_id) {}
|
||||
|
||||
constexpr bool is_valid() const {
|
||||
return request_id_ != 0 || routing_id_ != 0;
|
||||
}
|
||||
|
||||
constexpr uint32_t request_id() const { return request_id_; }
|
||||
|
||||
constexpr uint32_t routing_id() const { return routing_id_; }
|
||||
|
||||
bool operator==(const RequestId& other) const {
|
||||
return request_id_ == other.request_id_ && routing_id_ == other.routing_id_;
|
||||
}
|
||||
|
||||
bool operator!=(const RequestId& other) const { return !(*this == other); }
|
||||
|
||||
bool operator<(const RequestId& other) const {
|
||||
return std::tie(request_id_, routing_id_) <
|
||||
std::tie(other.request_id_, other.routing_id_);
|
||||
}
|
||||
|
||||
size_t hash() const { return base::HashInts(request_id_, routing_id_); }
|
||||
|
||||
std::string ToString() const;
|
||||
|
||||
std::string ToString(base::StringPiece debug_label) const;
|
||||
|
||||
private:
|
||||
uint32_t request_id_;
|
||||
uint32_t routing_id_;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const RequestId& request_id);
|
||||
|
||||
struct RequestIdHash {
|
||||
size_t operator()(const RequestId& key) const { return key.hash(); }
|
||||
};
|
||||
|
||||
// Abstract class for handling intercepted resource responses. All methods are
|
||||
// called on the IO thread unless otherwise indicated.
|
||||
class ResourceResponse {
|
||||
@@ -125,13 +77,13 @@ class ResourceResponse {
|
||||
// |callback| to continue the request. Return false to cancel the request.
|
||||
// |request| may be different from the request used to create the
|
||||
// StreamReaderURLLoader if a redirect was followed.
|
||||
virtual bool OpenInputStream(const RequestId& id,
|
||||
virtual bool OpenInputStream(int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
OpenCallback callback) = 0;
|
||||
|
||||
// This method is called to populate the response headers.
|
||||
using HeaderMap = std::multimap<std::string, std::string>;
|
||||
virtual void GetResponseHeaders(const RequestId& id,
|
||||
virtual void GetResponseHeaders(int32_t request_id,
|
||||
int* status_code,
|
||||
std::string* reason_phrase,
|
||||
std::string* mime_type,
|
||||
@@ -153,12 +105,12 @@ class StreamReaderURLLoader : public network::mojom::URLLoader {
|
||||
// This method is called if the result of calling OpenInputStream was null.
|
||||
// The |restarted| parameter is set to true if the request was restarted
|
||||
// with a new loader.
|
||||
virtual void OnInputStreamOpenFailed(const RequestId& id,
|
||||
virtual void OnInputStreamOpenFailed(int32_t request_id,
|
||||
bool* restarted) = 0;
|
||||
};
|
||||
|
||||
StreamReaderURLLoader(
|
||||
const RequestId& request_id,
|
||||
int32_t request_id,
|
||||
const network::ResourceRequest& request,
|
||||
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
|
||||
mojo::PendingRemote<network::mojom::TrustedHeaderClient> header_client,
|
||||
@@ -207,7 +159,7 @@ class StreamReaderURLLoader : public network::mojom::URLLoader {
|
||||
bool ParseRange(const net::HttpRequestHeaders& headers);
|
||||
bool byte_range_valid() const;
|
||||
|
||||
const RequestId request_id_;
|
||||
const int32_t request_id_;
|
||||
|
||||
size_t header_length_ = 0;
|
||||
int64_t total_bytes_read_ = 0;
|
||||
|
Reference in New Issue
Block a user