feat: migrate webRequest module to NetworkService (Part 6) (#19752)

* Implement OnBeforeSendHeaders

* Pass the request

* Handle simple listeners

* Handle response listeners

* Read responses from listener
This commit is contained in:
Cheng Zhao 2019-08-16 10:19:05 +09:00 committed by GitHub
parent e59095423e
commit c3bb73a711
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 297 additions and 64 deletions

View file

@ -8,12 +8,16 @@
#include <string>
#include <utility>
#include "base/stl_util.h"
#include "gin/converter.h"
#include "gin/dictionary.h"
#include "gin/object_template_builder.h"
#include "shell/browser/api/atom_api_session.h"
#include "shell/browser/api/atom_api_web_contents.h"
#include "shell/browser/atom_browser_context.h"
#include "shell/common/gin_converters/callback_converter_gin_adapter.h"
#include "shell/common/gin_converters/gurl_converter.h"
#include "shell/common/gin_converters/net_converter.h"
#include "shell/common/gin_converters/std_converter.h"
#include "shell/common/gin_converters/value_converter_gin_adapter.h"
@ -32,6 +36,40 @@ struct Converter<URLPattern> {
}
};
template <>
struct Converter<content::ResourceType> {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
content::ResourceType type) {
const char* result;
switch (type) {
case content::ResourceType::kMainFrame:
result = "mainFrame";
break;
case content::ResourceType::kSubFrame:
result = "subFrame";
break;
case content::ResourceType::kStylesheet:
result = "stylesheet";
break;
case content::ResourceType::kScript:
result = "script";
break;
case content::ResourceType::kImage:
result = "image";
break;
case content::ResourceType::kObject:
result = "object";
break;
case content::ResourceType::kXhr:
result = "xhr";
break;
default:
result = "other";
}
return StringToV8(isolate, result);
}
};
} // namespace gin
namespace electron {
@ -49,18 +87,106 @@ struct UserData : public base::SupportsUserData::Data {
};
// Test whether the URL of |request| matches |patterns|.
bool MatchesFilterCondition(extensions::WebRequestInfo* request,
bool MatchesFilterCondition(extensions::WebRequestInfo* info,
const std::set<URLPattern>& patterns) {
if (patterns.empty())
return true;
for (const auto& pattern : patterns) {
if (pattern.MatchesURL(request->url))
if (pattern.MatchesURL(info->url))
return true;
}
return false;
}
// Overloaded by multiple types to fill the |details| object.
void ToDictionary(gin::Dictionary* details, extensions::WebRequestInfo* info) {
details->Set("id", info->id);
details->Set("url", info->url);
details->Set("method", info->method);
details->Set("timestamp", base::Time::Now().ToDoubleT() * 1000);
if (!info->response_ip.empty())
details->Set("ip", info->response_ip);
if (info->type.has_value())
details->Set("resourceType", info->type.value());
else
details->Set("resourceType", base::StringPiece("other"));
if (info->response_headers) {
details->Set("fromCache", info->response_from_cache);
details->Set("responseHeaders", info->response_headers.get());
details->Set("statusLine", info->response_headers->GetStatusLine());
details->Set("statusCode", info->response_headers->response_code());
}
auto* web_contents = content::WebContents::FromRenderFrameHost(
content::RenderFrameHost::FromID(info->render_process_id,
info->frame_id));
int32_t id = api::WebContents::GetIDFromWrappedClass(web_contents);
// id must be greater than zero.
if (id > 0)
details->Set("webContentsId", id);
}
void ToDictionary(gin::Dictionary* details,
const network::ResourceRequest& request) {
details->Set("referrer", request.referrer);
}
void ToDictionary(gin::Dictionary* details,
const net::HttpRequestHeaders& headers) {
details->Set("requestHeaders", headers);
}
void ToDictionary(gin::Dictionary* details, const GURL& location) {
details->Set("redirectURL", location);
}
void ToDictionary(gin::Dictionary* details, int net_error) {
details->Set("error", net::ErrorToString(net_error));
}
// Helper function to fill |details| with arbitrary |args|.
template <typename Arg>
void FillDetails(gin::Dictionary* details, Arg arg) {
ToDictionary(details, arg);
}
template <typename Arg, typename... Args>
void FillDetails(gin::Dictionary* details, Arg arg, Args... args) {
ToDictionary(details, arg);
FillDetails(details, args...);
}
// Fill the native types with the result from the response object.
void ReadFromResponse(v8::Isolate* isolate,
gin::Dictionary* response,
GURL* new_location) {
response->Get("redirectURL", new_location);
}
void ReadFromResponse(v8::Isolate* isolate,
gin::Dictionary* response,
net::HttpRequestHeaders* headers) {
headers->Clear();
gin::ConvertFromV8(isolate, gin::ConvertToV8(isolate, *response), headers);
}
void ReadFromResponse(v8::Isolate* isolate,
gin::Dictionary* response,
const std::pair<scoped_refptr<net::HttpResponseHeaders>*,
const std::string>& headers) {
std::string status_line;
if (!response->Get("statusLine", &status_line))
status_line = headers.second;
v8::Local<v8::Value> value;
if (response->Get("responseHeaders", &value)) {
*headers.first = new net::HttpResponseHeaders("");
(*headers.first)->ReplaceStatusLine(status_line);
gin::Converter<net::HttpResponseHeaders*>::FromV8(isolate, value,
(*headers.first).get());
}
}
} // namespace
gin::WrapperInfo WebRequestNS::kWrapperInfo = {gin::kEmbedderNativeGin};
@ -113,54 +239,70 @@ const char* WebRequestNS::GetTypeName() {
return "WebRequest";
}
int WebRequestNS::OnBeforeRequest(extensions::WebRequestInfo* request,
int WebRequestNS::OnBeforeRequest(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
net::CompletionOnceCallback callback,
GURL* new_url) {
return HandleResponseEvent(kOnBeforeRequest, request, std::move(callback),
new_url);
return HandleResponseEvent(kOnBeforeRequest, info, std::move(callback),
new_url, request);
}
int WebRequestNS::OnBeforeSendHeaders(extensions::WebRequestInfo* request,
int WebRequestNS::OnBeforeSendHeaders(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
BeforeSendHeadersCallback callback,
net::HttpRequestHeaders* headers) {
// TODO(zcbenz): Figure out how to handle this generally.
return net::OK;
return HandleResponseEvent(
kOnBeforeSendHeaders, info,
base::BindOnce(std::move(callback), std::set<std::string>(),
std::set<std::string>()),
headers, request);
}
int WebRequestNS::OnHeadersReceived(
extensions::WebRequestInfo* request,
extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
net::CompletionOnceCallback callback,
const net::HttpResponseHeaders* original_response_headers,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
GURL* allowed_unsafe_redirect_url) {
return HandleResponseEvent(kOnHeadersReceived, request, std::move(callback),
original_response_headers,
override_response_headers,
allowed_unsafe_redirect_url);
return HandleResponseEvent(
kOnHeadersReceived, info, std::move(callback),
std::make_pair(override_response_headers,
original_response_headers->GetStatusLine()),
request);
}
void WebRequestNS::OnSendHeaders(extensions::WebRequestInfo* request,
void WebRequestNS::OnSendHeaders(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
const net::HttpRequestHeaders& headers) {
HandleSimpleEvent(kOnSendHeaders, request, headers);
HandleSimpleEvent(kOnSendHeaders, info, request, headers);
}
void WebRequestNS::OnBeforeRedirect(extensions::WebRequestInfo* request,
void WebRequestNS::OnBeforeRedirect(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
const GURL& new_location) {
HandleSimpleEvent(kOnBeforeRedirect, request, new_location);
HandleSimpleEvent(kOnBeforeRedirect, info, request, new_location);
}
void WebRequestNS::OnResponseStarted(extensions::WebRequestInfo* request) {
HandleSimpleEvent(kOnResponseStarted, request);
void WebRequestNS::OnResponseStarted(extensions::WebRequestInfo* info,
const network::ResourceRequest& request) {
HandleSimpleEvent(kOnResponseStarted, info, request);
}
void WebRequestNS::OnErrorOccurred(extensions::WebRequestInfo* request,
void WebRequestNS::OnErrorOccurred(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
int net_error) {
HandleSimpleEvent(kOnErrorOccurred, request, net_error);
callbacks_.erase(info->id);
HandleSimpleEvent(kOnErrorOccurred, info, request, net_error);
}
void WebRequestNS::OnCompleted(extensions::WebRequestInfo* request,
void WebRequestNS::OnCompleted(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
int net_error) {
HandleSimpleEvent(kOnCompleted, request, net_error);
callbacks_.erase(info->id);
HandleSimpleEvent(kOnCompleted, info, request, net_error);
}
template <WebRequestNS::SimpleEvent event>
@ -199,27 +341,64 @@ void WebRequestNS::SetListener(Event event,
template <typename... Args>
void WebRequestNS::HandleSimpleEvent(SimpleEvent event,
extensions::WebRequestInfo* request,
extensions::WebRequestInfo* request_info,
Args... args) {
const auto& info = simple_listeners_[event];
if (!MatchesFilterCondition(request, info.url_patterns))
if (!MatchesFilterCondition(request_info, info.url_patterns))
return;
// TODO(zcbenz): Invoke the listener.
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handle_scope(isolate);
gin::Dictionary details(isolate, v8::Object::New(isolate));
FillDetails(&details, request_info, args...);
info.listener.Run(gin::ConvertToV8(isolate, details));
}
template <typename Out, typename... Args>
int WebRequestNS::HandleResponseEvent(ResponseEvent event,
extensions::WebRequestInfo* request,
extensions::WebRequestInfo* request_info,
net::CompletionOnceCallback callback,
Out out,
Args... args) {
const auto& info = response_listeners_[event];
if (!MatchesFilterCondition(request, info.url_patterns))
if (!MatchesFilterCondition(request_info, info.url_patterns))
return net::OK;
// TODO(zcbenz): Invoke the listener.
return net::OK;
callbacks_[request_info->id] = std::move(callback);
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handle_scope(isolate);
gin::Dictionary details(isolate, v8::Object::New(isolate));
FillDetails(&details, request_info, args...);
ResponseCallback response =
base::BindOnce(&WebRequestNS::OnListenerResult<Out>,
base::Unretained(this), request_info->id, out);
info.listener.Run(gin::ConvertToV8(isolate, details), std::move(response));
return net::ERR_IO_PENDING;
}
template <typename T>
void WebRequestNS::OnListenerResult(uint64_t id,
T out,
v8::Local<v8::Value> response) {
if (!base::Contains(callbacks_, id))
return;
int result = net::OK;
if (response->IsObject()) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
gin::Dictionary dict(isolate, response.As<v8::Object>());
bool cancel = false;
dict.Get("cancel", &cancel);
if (cancel)
result = net::ERR_BLOCKED_BY_CLIENT;
else
ReadFromResponse(isolate, &dict, out);
}
std::move(callbacks_[id]).Run(result);
}
// static

View file

@ -57,26 +57,35 @@ class WebRequestNS : public gin::Wrappable<WebRequestNS>, public WebRequestAPI {
~WebRequestNS() override;
// WebRequestAPI:
int OnBeforeRequest(extensions::WebRequestInfo* request,
int OnBeforeRequest(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
net::CompletionOnceCallback callback,
GURL* new_url) override;
int OnBeforeSendHeaders(extensions::WebRequestInfo* request,
int OnBeforeSendHeaders(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
BeforeSendHeadersCallback callback,
net::HttpRequestHeaders* headers) override;
int OnHeadersReceived(
extensions::WebRequestInfo* request,
extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
net::CompletionOnceCallback callback,
const net::HttpResponseHeaders* original_response_headers,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
GURL* allowed_unsafe_redirect_url) override;
void OnSendHeaders(extensions::WebRequestInfo* request,
void OnSendHeaders(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
const net::HttpRequestHeaders& headers) override;
void OnBeforeRedirect(extensions::WebRequestInfo* request,
void OnBeforeRedirect(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
const GURL& new_location) override;
void OnResponseStarted(extensions::WebRequestInfo* request) override;
void OnErrorOccurred(extensions::WebRequestInfo* request,
void OnResponseStarted(extensions::WebRequestInfo* info,
const network::ResourceRequest& request) override;
void OnErrorOccurred(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
int net_error) override;
void OnCompleted(extensions::WebRequestInfo* request, int net_error) override;
void OnCompleted(extensions::WebRequestInfo* info,
const network::ResourceRequest& request,
int net_error) override;
enum SimpleEvent {
kOnSendHeaders,
@ -91,10 +100,10 @@ class WebRequestNS : public gin::Wrappable<WebRequestNS>, public WebRequestAPI {
kOnHeadersReceived,
};
using SimpleListener = base::RepeatingCallback<void(const base::Value&)>;
using ResponseCallback = base::OnceCallback<void(const base::Value&)>;
using SimpleListener = base::RepeatingCallback<void(v8::Local<v8::Value>)>;
using ResponseCallback = base::OnceCallback<void(v8::Local<v8::Value>)>;
using ResponseListener =
base::RepeatingCallback<void(const base::Value&, ResponseCallback)>;
base::RepeatingCallback<void(v8::Local<v8::Value>, ResponseCallback)>;
template <SimpleEvent event>
void SetSimpleListener(gin::Arguments* args);
@ -105,15 +114,18 @@ class WebRequestNS : public gin::Wrappable<WebRequestNS>, public WebRequestAPI {
template <typename... Args>
void HandleSimpleEvent(SimpleEvent event,
extensions::WebRequestInfo* request,
extensions::WebRequestInfo* info,
Args... args);
template <typename Out, typename... Args>
int HandleResponseEvent(ResponseEvent event,
extensions::WebRequestInfo* request,
extensions::WebRequestInfo* info,
net::CompletionOnceCallback callback,
Out out,
Args... args);
template <typename T>
void OnListenerResult(uint64_t id, T out, v8::Local<v8::Value> response);
struct SimpleListenerInfo {
std::set<URLPattern> url_patterns;
SimpleListener listener;