mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

refactor: ginify net.request (#22779)

Browse source
This commit is contained in:
Jeremy Apthorp 2020-03-23 13:09:45 -07:00 • committed by GitHub
parent d3d7b3eb54
commit decbca734f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 52 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

15
lib/browser/api/net.js
View file

@ -5,10 +5,7 @@ const { EventEmitter } = require('events');
const { Readable, Writable } = require('stream');
const { app } = require('electron');
const { Session } = process.electronBinding('session');
const { net, Net, _isValidHeaderName, _isValidHeaderValue } = process.electronBinding('net');
const { URLLoader } = net;
Object.setPrototypeOf(URLLoader.prototype, EventEmitter.prototype);
const { net, Net, isValidHeaderName, isValidHeaderValue, createURLLoader } = process.electronBinding('net');
const kSupportedProtocols = new Set(['http:', 'https:']);
@ -240,10 +237,10 @@ function parseOptions (options) {
useSessionCookies: options.useSessionCookies || false
};
for (const [name, value] of Object.entries(urlLoaderOptions.extraHeaders)) {
if (!_isValidHeaderName(name)) {
if (!isValidHeaderName(name)) {
throw new Error(`Invalid header name: '${name}'`);
}
if (!_isValidHeaderValue(value.toString())) {
if (!isValidHeaderValue(value.toString())) {
throw new Error(`Invalid value for header '${name}': '${value}'`);
}
}
@ -307,10 +304,10 @@ class ClientRequest extends Writable {
if (this._started || this._firstWrite) {
throw new Error('Can\'t set headers after they are sent');
}
if (!_isValidHeaderName(name)) {
if (!isValidHeaderName(name)) {
throw new Error(`Invalid header name: '${name}'`);
}
if (!_isValidHeaderValue(value.toString())) {
if (!isValidHeaderValue(value.toString())) {
throw new Error(`Invalid value for header '${name}': '${value}'`);
}
@ -374,7 +371,7 @@ class ClientRequest extends Writable {
return ret;
};
const opts = { ...this._urlLoaderOptions, extraHeaders: stringifyValues(this._urlLoaderOptions.extraHeaders) };
this._urlLoader = new URLLoader(opts);
this._urlLoader = createURLLoader(opts);
this._urlLoader.on('response-started', (event, finalUrl, responseHead) => {
const response = this._response = new IncomingMessage(responseHead);
this.emit('response', response);

17
shell/browser/api/electron_api_net.cc
View file

@ -33,15 +33,6 @@ v8::Local<v8::Value> Net::Create(v8::Isolate* isolate) {
void Net::BuildPrototype(v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> prototype) {
prototype->SetClassName(gin::StringToV8(isolate, "Net"));
gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
.SetProperty("URLLoader", &Net::URLLoader);
}
v8::Local<v8::Value> Net::URLLoader(v8::Isolate* isolate) {
v8::Local<v8::FunctionTemplate> constructor;
constructor = SimpleURLLoaderWrapper::GetConstructor(isolate);
return constructor->GetFunction(isolate->GetCurrentContext())
.ToLocalChecked();
}
} // namespace api
@ -67,15 +58,13 @@ void Initialize(v8::Local<v8::Object> exports,
void* priv) {
v8::Isolate* isolate = context->GetIsolate();
SimpleURLLoaderWrapper::SetConstructor(
isolate, base::BindRepeating(SimpleURLLoaderWrapper::New));
gin_helper::Dictionary dict(isolate, exports);
dict.Set("net", Net::Create(isolate));
dict.Set("Net",
Net::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());
dict.SetMethod("_isValidHeaderName", &IsValidHeaderName);
dict.SetMethod("_isValidHeaderValue", &IsValidHeaderValue);
dict.SetMethod("isValidHeaderName", &IsValidHeaderName);
dict.SetMethod("isValidHeaderValue", &IsValidHeaderValue);
dict.SetMethod("createURLLoader", &SimpleURLLoaderWrapper::Create);
}
} // namespace

49
shell/browser/api/electron_api_url_loader.cc
View file

@ -247,6 +247,9 @@ base::IDMap<SimpleURLLoaderWrapper*>& GetAllRequests() {
} // namespace
gin::WrapperInfo SimpleURLLoaderWrapper::kWrapperInfo = {
gin::kEmbedderNativeGin};
SimpleURLLoaderWrapper::SimpleURLLoaderWrapper(
std::unique_ptr<network::ResourceRequest> request,
network::mojom::URLLoaderFactory* url_loader_factory)
@ -279,14 +282,14 @@ SimpleURLLoaderWrapper::SimpleURLLoaderWrapper(
}
void SimpleURLLoaderWrapper::Pin() {
// Prevent ourselves from being GC'd until the request is complete.
// Must be called after InitWithArgs(), otherwise GetWrapper() isn't
// initialized.
pinned_wrapper_.Reset(isolate(), GetWrapper());
// Prevent ourselves from being GC'd until the request is complete. Must be
// called after gin::CreateHandle, otherwise the wrapper isn't initialized.
v8::Isolate* isolate = v8::Isolate::GetCurrent();
pinned_wrapper_.Reset(isolate, GetWrapper(isolate).ToLocalChecked());
}
void SimpleURLLoaderWrapper::PinBodyGetter(v8::Local<v8::Value> body_getter) {
pinned_chunk_pipe_getter_.Reset(isolate(), body_getter);
pinned_chunk_pipe_getter_.Reset(v8::Isolate::GetCurrent(), body_getter);
}
SimpleURLLoaderWrapper::~SimpleURLLoaderWrapper() {
@ -338,11 +341,12 @@ void SimpleURLLoaderWrapper::Cancel() {
}
// static
gin_helper::WrappableBase* SimpleURLLoaderWrapper::New(gin::Arguments* args) {
gin::Handle<SimpleURLLoaderWrapper> SimpleURLLoaderWrapper::Create(
gin::Arguments* args) {
gin_helper::Dictionary opts;
if (!args->GetNext(&opts)) {
args->ThrowTypeError("Expected a dictionary");
return nullptr;
return gin::Handle<SimpleURLLoaderWrapper>();
}
auto request = std::make_unique<network::ResourceRequest>();
request->attach_same_site_cookies = true;
@ -354,7 +358,7 @@ gin_helper::WrappableBase* SimpleURLLoaderWrapper::New(gin::Arguments* args) {
if (!net::HttpUtil::IsValidHeaderName(it.first) ||
!net::HttpUtil::IsValidHeaderValue(it.second)) {
args->ThrowTypeError("Invalid header name or value");
return nullptr;
return gin::Handle<SimpleURLLoaderWrapper>();
}
request->headers.SetHeader(it.first, it.second);
}
@ -404,9 +408,9 @@ gin_helper::WrappableBase* SimpleURLLoaderWrapper::New(gin::Arguments* args) {
auto url_loader_factory = session->browser_context()->GetURLLoaderFactory();
auto* ret =
new SimpleURLLoaderWrapper(std::move(request), url_loader_factory.get());
ret->InitWithArgs(args);
auto ret = gin::CreateHandle(
args->isolate(),
new SimpleURLLoaderWrapper(std::move(request), url_loader_factory.get()));
ret->Pin();
if (!chunk_pipe_getter.IsEmpty()) {
ret->PinBodyGetter(chunk_pipe_getter);
@ -417,8 +421,9 @@ gin_helper::WrappableBase* SimpleURLLoaderWrapper::New(gin::Arguments* args) {
void SimpleURLLoaderWrapper::OnDataReceived(base::StringPiece string_piece,
base::OnceClosure resume) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
v8::HandleScope handle_scope(isolate());
auto array_buffer = v8::ArrayBuffer::New(isolate(), string_piece.size());
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handle_scope(isolate);
auto array_buffer = v8::ArrayBuffer::New(isolate, string_piece.size());
auto backing_store = array_buffer->GetBackingStore();
memcpy(backing_store->Data(), string_piece.data(), string_piece.size());
Emit("data", array_buffer);
@ -441,8 +446,9 @@ void SimpleURLLoaderWrapper::OnRetry(base::OnceClosure start_retry) {}
void SimpleURLLoaderWrapper::OnResponseStarted(
const GURL& final_url,
const network::mojom::URLResponseHead& response_head) {
v8::HandleScope scope(isolate());
gin::Dictionary dict = gin::Dictionary::CreateEmpty(isolate());
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope scope(isolate);
gin::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
dict.Set("statusCode", response_head.headers->response_code());
dict.Set("statusMessage", response_head.headers->GetStatusText());
dict.Set("httpVersion", response_head.headers->GetHttpVersion());
@ -471,14 +477,17 @@ void SimpleURLLoaderWrapper::OnDownloadProgress(uint64_t current) {
}
// static
void SimpleURLLoaderWrapper::BuildPrototype(
v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> prototype) {
prototype->SetClassName(gin::StringToV8(isolate, "SimpleURLLoaderWrapper"));
gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
gin::ObjectTemplateBuilder SimpleURLLoaderWrapper::GetObjectTemplateBuilder(
v8::Isolate* isolate) {
return gin_helper::EventEmitterMixin<
SimpleURLLoaderWrapper>::GetObjectTemplateBuilder(isolate)
.SetMethod("cancel", &SimpleURLLoaderWrapper::Cancel);
}
const char* SimpleURLLoaderWrapper::GetTypeName() {
return "SimpleURLLoaderWrapper";
}
} // namespace api
} // namespace electron

21
shell/browser/api/electron_api_url_loader.h
View file

@ -10,18 +10,21 @@
#include <vector>
#include "base/memory/weak_ptr.h"
#include "gin/wrappable.h"
#include "net/base/auth.h"
#include "services/network/public/cpp/simple_url_loader_stream_consumer.h"
#include "services/network/public/mojom/network_context.mojom.h"
#include "services/network/public/mojom/url_loader_factory.mojom-forward.h"
#include "services/network/public/mojom/url_response_head.mojom.h"
#include "shell/common/gin_helper/event_emitter.h"
#include "shell/browser/event_emitter_mixin.h"
#include "url/gurl.h"
#include "v8/include/v8.h"
namespace gin {
class Arguments;
}
template <typename T>
class Handle;
} // namespace gin
namespace network {
class SimpleURLLoader;
@ -34,14 +37,12 @@ namespace api {
/** Wraps a SimpleURLLoader to make it usable from JavaScript */
class SimpleURLLoaderWrapper
: public gin_helper::EventEmitter<SimpleURLLoaderWrapper>,
: public gin::Wrappable<SimpleURLLoaderWrapper>,
public gin_helper::EventEmitterMixin<SimpleURLLoaderWrapper>,
public network::SimpleURLLoaderStreamConsumer {
public:
~SimpleURLLoaderWrapper() override;
static gin_helper::WrappableBase* New(gin::Arguments* args);
static void BuildPrototype(v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> prototype);
static gin::Handle<SimpleURLLoaderWrapper> Create(gin::Arguments* args);
static SimpleURLLoaderWrapper* FromID(uint32_t id);
@ -55,6 +56,12 @@ class SimpleURLLoaderWrapper
void Cancel();
// gin::Wrappable
static gin::WrapperInfo kWrapperInfo;
gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
v8::Isolate* isolate) override;
const char* GetTypeName() override;
private:
SimpleURLLoaderWrapper(std::unique_ptr<network::ResourceRequest> loader,
network::mojom::URLLoaderFactory* url_loader_factory);