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

Make the webRequest listener asynchronous

Browse source
This commit is contained in:
Cheng Zhao 2015-12-11 23:54:32 +08:00
parent d3c8363450
commit fed94aada0
7 changed files with 197 additions and 180 deletions
Download patch file Download diff file Expand all files Collapse all files

1
atom/browser/api/atom_api_web_contents.cc
View file

@ -5,6 +5,7 @@
#include "atom/browser/api/atom_api_web_contents.h" #include "atom/browser/api/atom_api_web_contents.h"
#include <set> #include <set>
#include <string>
#include "atom/browser/api/atom_api_session.h" #include "atom/browser/api/atom_api_session.h"
#include "atom/browser/api/atom_api_window.h" #include "atom/browser/api/atom_api_window.h"

45
atom/browser/api/atom_api_web_request.cc
View file

@ -41,8 +41,20 @@ WebRequest::WebRequest(AtomBrowserContext* browser_context)
WebRequest::~WebRequest() { WebRequest::~WebRequest() {
} }
template<AtomNetworkDelegate::EventType type> template<AtomNetworkDelegate::SimpleEvent type>
void WebRequest::SetListener(mate::Arguments* args) { void WebRequest::SetSimpleListener(mate::Arguments* args) {
SetListener<AtomNetworkDelegate::SimpleListener>(
&AtomNetworkDelegate::SetSimpleListenerInIO, type, args);
}
template<AtomNetworkDelegate::ResponseEvent type>
void WebRequest::SetResponseListener(mate::Arguments* args) {
SetListener<AtomNetworkDelegate::ResponseListener>(
&AtomNetworkDelegate::SetResponseListenerInIO, type, args);
}
template<typename Listener, typename Method, typename Event>
void WebRequest::SetListener(Method method, Event type, mate::Arguments* args) {
// { urls }. // { urls }.
URLPatterns patterns; URLPatterns patterns;
mate::Dictionary dict; mate::Dictionary dict;
@ -50,8 +62,8 @@ void WebRequest::SetListener(mate::Arguments* args) {
// Function or null. // Function or null.
v8::Local<v8::Value> value; v8::Local<v8::Value> value;
AtomNetworkDelegate::Listener callback; Listener listener;
if (!args->GetNext(&callback) && if (!args->GetNext(&listener) &&
!(args->GetNext(&value) && value->IsNull())) { !(args->GetNext(&value) && value->IsNull())) {
args->ThrowError("Must pass null or a Function"); args->ThrowError("Must pass null or a Function");
return; return;
@ -59,9 +71,8 @@ void WebRequest::SetListener(mate::Arguments* args) {
auto delegate = browser_context_->network_delegate(); auto delegate = browser_context_->network_delegate();
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(&AtomNetworkDelegate::SetListenerInIO, base::Bind(method, base::Unretained(delegate), type,
base::Unretained(delegate), patterns, listener));
type, patterns, callback));
} }
// static // static
@ -76,28 +87,28 @@ void WebRequest::BuildPrototype(v8::Isolate* isolate,
v8::Local<v8::ObjectTemplate> prototype) { v8::Local<v8::ObjectTemplate> prototype) {
mate::ObjectTemplateBuilder(isolate, prototype) mate::ObjectTemplateBuilder(isolate, prototype)
.SetMethod("onBeforeRequest", .SetMethod("onBeforeRequest",
&WebRequest::SetListener< &WebRequest::SetResponseListener<
AtomNetworkDelegate::kOnBeforeRequest>) AtomNetworkDelegate::kOnBeforeRequest>)
.SetMethod("onBeforeSendHeaders", .SetMethod("onBeforeSendHeaders",
&WebRequest::SetListener< &WebRequest::SetResponseListener<
AtomNetworkDelegate::kOnBeforeSendHeaders>) AtomNetworkDelegate::kOnBeforeSendHeaders>)
.SetMethod("onSendHeaders",
&WebRequest::SetListener<
AtomNetworkDelegate::kOnSendHeaders>)
.SetMethod("onHeadersReceived", .SetMethod("onHeadersReceived",
&WebRequest::SetListener< &WebRequest::SetResponseListener<
AtomNetworkDelegate::kOnHeadersReceived>) AtomNetworkDelegate::kOnHeadersReceived>)
.SetMethod("onSendHeaders",
&WebRequest::SetSimpleListener<
AtomNetworkDelegate::kOnSendHeaders>)
.SetMethod("onBeforeRedirect", .SetMethod("onBeforeRedirect",
&WebRequest::SetListener< &WebRequest::SetSimpleListener<
AtomNetworkDelegate::kOnBeforeRedirect>) AtomNetworkDelegate::kOnBeforeRedirect>)
.SetMethod("onResponseStarted", .SetMethod("onResponseStarted",
&WebRequest::SetListener< &WebRequest::SetSimpleListener<
AtomNetworkDelegate::kOnResponseStarted>) AtomNetworkDelegate::kOnResponseStarted>)
.SetMethod("onCompleted", .SetMethod("onCompleted",
&WebRequest::SetListener< &WebRequest::SetSimpleListener<
AtomNetworkDelegate::kOnCompleted>) AtomNetworkDelegate::kOnCompleted>)
.SetMethod("onErrorOccurred", .SetMethod("onErrorOccurred",
&WebRequest::SetListener< &WebRequest::SetSimpleListener<
AtomNetworkDelegate::kOnErrorOccurred>); AtomNetworkDelegate::kOnErrorOccurred>);
} }

9
atom/browser/api/atom_api_web_request.h
View file

@ -29,8 +29,13 @@ class WebRequest : public mate::TrackableObject<WebRequest> {
explicit WebRequest(AtomBrowserContext* browser_context); explicit WebRequest(AtomBrowserContext* browser_context);
~WebRequest(); ~WebRequest();
template<AtomNetworkDelegate::EventType Event> // C++ can not distinguish overloaded member function.
void SetListener(mate::Arguments* args); template<AtomNetworkDelegate::SimpleEvent type>
void SetSimpleListener(mate::Arguments* args);
template<AtomNetworkDelegate::ResponseEvent type>
void SetResponseListener(mate::Arguments* args);
template<typename Listener, typename Method, typename Event>
void SetListener(Method method, Event type, mate::Arguments* args);
private: private:
scoped_refptr<AtomBrowserContext> browser_context_; scoped_refptr<AtomBrowserContext> browser_context_;

231
atom/browser/net/atom_network_delegate.cc
View file

@ -4,6 +4,8 @@
#include "atom/browser/net/atom_network_delegate.h" #include "atom/browser/net/atom_network_delegate.h"
#include <string>
#include "atom/common/native_mate_converters/net_converter.h" #include "atom/common/native_mate_converters/net_converter.h"
#include "base/stl_util.h" #include "base/stl_util.h"
#include "base/strings/string_util.h" #include "base/strings/string_util.h"
@ -38,12 +40,19 @@ const char* ResourceTypeToString(content::ResourceType type) {
} }
} }
AtomNetworkDelegate::BlockingResponse RunListener( void RunSimpleListener(const AtomNetworkDelegate::SimpleListener& listener,
const AtomNetworkDelegate::Listener& callback, scoped_ptr<base::DictionaryValue> details) {
scoped_ptr<base::DictionaryValue> details) { return listener.Run(*(details.get()));
return callback.Run(*(details.get()));
} }
void RunResponseListener(
const AtomNetworkDelegate::ResponseListener& listener,
scoped_ptr<base::DictionaryValue> details,
const AtomNetworkDelegate::ResponseCallback& callback) {
return listener.Run(*(details.get()), callback);
}
// Test whether the URL of |request| matches |patterns|.
bool MatchesFilterCondition(net::URLRequest* request, bool MatchesFilterCondition(net::URLRequest* request,
const URLPatterns& patterns) { const URLPatterns& patterns) {
if (patterns.empty()) if (patterns.empty())
@ -56,6 +65,7 @@ bool MatchesFilterCondition(net::URLRequest* request,
return false; return false;
} }
// Overloaded by multiple types to fill the |details| object.
void FillDetailsObject(base::DictionaryValue* details, void FillDetailsObject(base::DictionaryValue* details,
net::URLRequest* request) { net::URLRequest* request) {
details->SetInteger("id", request->identifier()); details->SetInteger("id", request->identifier());
@ -122,41 +132,65 @@ void FillDetailsObject(base::DictionaryValue* details,
details->SetString("error", net::ErrorToString(status.error())); details->SetString("error", net::ErrorToString(status.error()));
} }
void OnBeforeURLRequestResponse( // Fill the native types with the result from the response object.
const net::CompletionCallback& callback, void ReadFromResponseObject(const base::DictionaryValue& response,
GURL* new_url, GURL* new_location) {
const AtomNetworkDelegate::BlockingResponse& result) { std::string url;
if (!result.redirect_url.is_empty()) if (response.GetString("redirectURL", &url))
*new_url = result.redirect_url; *new_location = GURL(url);
callback.Run(result.code());
} }
void OnBeforeSendHeadersResponse( void ReadFromResponseObject(const base::DictionaryValue& response,
const net::CompletionCallback& callback, net::HttpRequestHeaders* headers) {
net::HttpRequestHeaders* headers, const base::DictionaryValue* dict;
const AtomNetworkDelegate::BlockingResponse& result) { if (response.GetDictionary("requestHeaders", &dict)) {
if (!result.request_headers.IsEmpty()) for (base::DictionaryValue::Iterator it(*dict);
*headers = result.request_headers; !it.IsAtEnd();
callback.Run(result.code()); it.Advance()) {
} std::string value;
if (it.value().GetAsString(&value))
void OnHeadersReceivedResponse( headers->SetHeader(it.key(), value);
const net::CompletionCallback& callback,
const net::HttpResponseHeaders* original_response_headers,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
const AtomNetworkDelegate::BlockingResponse& result) {
if (result.response_headers.get()) {
*override_response_headers = new net::HttpResponseHeaders(
original_response_headers->raw_headers());
void* iter = nullptr;
std::string key;
std::string value;
while (result.response_headers->EnumerateHeaderLines(&iter, &key, &value)) {
(*override_response_headers)->RemoveHeader(key);
(*override_response_headers)->AddHeader(key + ": " + value);
} }
} }
callback.Run(result.code()); }
void ReadFromResponseObject(const base::DictionaryValue& response,
scoped_refptr<net::HttpResponseHeaders>* headers) {
const base::DictionaryValue* dict;
if (response.GetDictionary("responseHeaders", &dict)) {
*headers = new net::HttpResponseHeaders("");
for (base::DictionaryValue::Iterator it(*dict);
!it.IsAtEnd();
it.Advance()) {
std::string value;
if (it.value().GetAsString(&value)) {
(*headers)->RemoveHeader(it.key());
(*headers)->AddHeader(it.key() + " : " + value);
}
}
}
}
// Deal with the results of Listener.
template<typename T>
void OnListenerResultInIO(const net::CompletionCallback& callback,
T out,
scoped_ptr<base::DictionaryValue> response) {
ReadFromResponseObject(*response.get(), out);
bool cancel = false;
response->GetBoolean("cancel", &cancel);
callback.Run(cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK);
}
template<typename T>
void OnListenerResultInUI(const net::CompletionCallback& callback,
T out,
const base::DictionaryValue& response) {
scoped_ptr<base::DictionaryValue> copy = response.CreateDeepCopy();
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(OnListenerResultInIO<T>, callback, out, base::Passed(&copy)));
} }
} // namespace } // namespace
@ -167,36 +201,47 @@ AtomNetworkDelegate::AtomNetworkDelegate() {
AtomNetworkDelegate::~AtomNetworkDelegate() { AtomNetworkDelegate::~AtomNetworkDelegate() {
} }
void AtomNetworkDelegate::SetListenerInIO(EventType type, void AtomNetworkDelegate::SetSimpleListenerInIO(
const URLPatterns& patterns, SimpleEvent type,
const Listener& callback) { const URLPatterns& patterns,
if (callback.is_null()) { const SimpleListener& callback) {
event_listener_map_.erase(type); if (callback.is_null())
return; simple_listeners_.erase(type);
} else
simple_listeners_[type] = { patterns, callback };
}
event_listener_map_[type] = { patterns, callback }; void AtomNetworkDelegate::SetResponseListenerInIO(
ResponseEvent type,
const URLPatterns& patterns,
const ResponseListener& callback) {
if (callback.is_null())
response_listeners_.erase(type);
else
response_listeners_[type] = { patterns, callback };
} }
int AtomNetworkDelegate::OnBeforeURLRequest( int AtomNetworkDelegate::OnBeforeURLRequest(
net::URLRequest* request, net::URLRequest* request,
const net::CompletionCallback& callback, const net::CompletionCallback& callback,
GURL* new_url) { GURL* new_url) {
if (!ContainsKey(event_listener_map_, kOnBeforeRequest)) if (!ContainsKey(response_listeners_, kOnBeforeRequest))
return brightray::NetworkDelegate::OnBeforeURLRequest( return brightray::NetworkDelegate::OnBeforeURLRequest(
request, callback, new_url); request, callback, new_url);
const ListenerInfo& info = event_listener_map_[kOnBeforeRequest]; const auto& info = response_listeners_[kOnBeforeRequest];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return net::OK; return net::OK;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue); scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request); FillDetailsObject(details.get(), request);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE, ResponseCallback response =
base::Bind(&RunListener, info.callback, base::Passed(&details)), base::Bind(OnListenerResultInUI<GURL*>, callback, new_url);
base::Bind(&OnBeforeURLRequestResponse, BrowserThread::PostTask(
callback, new_url)); BrowserThread::UI, FROM_HERE,
base::Bind(RunResponseListener, info.listener, base::Passed(&details),
response));
return net::ERR_IO_PENDING; return net::ERR_IO_PENDING;
} }
@ -204,11 +249,11 @@ int AtomNetworkDelegate::OnBeforeSendHeaders(
net::URLRequest* request, net::URLRequest* request,
const net::CompletionCallback& callback, const net::CompletionCallback& callback,
net::HttpRequestHeaders* headers) { net::HttpRequestHeaders* headers) {
if (!ContainsKey(event_listener_map_, kOnBeforeSendHeaders)) if (!ContainsKey(response_listeners_, kOnBeforeSendHeaders))
return brightray::NetworkDelegate::OnBeforeSendHeaders( return brightray::NetworkDelegate::OnBeforeSendHeaders(
request, callback, headers); request, callback, headers);
const ListenerInfo& info = event_listener_map_[kOnBeforeSendHeaders]; const auto& info = response_listeners_[kOnBeforeSendHeaders];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return net::OK; return net::OK;
@ -216,22 +261,25 @@ int AtomNetworkDelegate::OnBeforeSendHeaders(
FillDetailsObject(details.get(), request); FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), *headers); FillDetailsObject(details.get(), *headers);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE, ResponseCallback response =
base::Bind(&RunListener, info.callback, base::Passed(&details)), base::Bind(OnListenerResultInUI<net::HttpRequestHeaders*>,
base::Bind(&OnBeforeSendHeadersResponse, callback, headers);
callback, headers)); BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(RunResponseListener, info.listener, base::Passed(&details),
response));
return net::ERR_IO_PENDING; return net::ERR_IO_PENDING;
} }
void AtomNetworkDelegate::OnSendHeaders( void AtomNetworkDelegate::OnSendHeaders(
net::URLRequest* request, net::URLRequest* request,
const net::HttpRequestHeaders& headers) { const net::HttpRequestHeaders& headers) {
if (!ContainsKey(event_listener_map_, kOnSendHeaders)) { if (!ContainsKey(simple_listeners_, kOnSendHeaders)) {
brightray::NetworkDelegate::OnSendHeaders(request, headers); brightray::NetworkDelegate::OnSendHeaders(request, headers);
return; return;
} }
const ListenerInfo& info = event_listener_map_[kOnSendHeaders]; const auto& info = simple_listeners_[kOnSendHeaders];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return; return;
@ -239,10 +287,9 @@ void AtomNetworkDelegate::OnSendHeaders(
FillDetailsObject(details.get(), request); FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), headers); FillDetailsObject(details.get(), headers);
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, BrowserThread::PostTask(
base::Bind(base::IgnoreResult(&RunListener), BrowserThread::UI, FROM_HERE,
info.callback, base::Bind(&RunSimpleListener, info.listener, base::Passed(&details)));
base::Passed(&details)));
} }
int AtomNetworkDelegate::OnHeadersReceived( int AtomNetworkDelegate::OnHeadersReceived(
@ -251,12 +298,12 @@ int AtomNetworkDelegate::OnHeadersReceived(
const net::HttpResponseHeaders* original_response_headers, const net::HttpResponseHeaders* original_response_headers,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers, scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
GURL* allowed_unsafe_redirect_url) { GURL* allowed_unsafe_redirect_url) {
if (!ContainsKey(event_listener_map_, kOnHeadersReceived)) if (!ContainsKey(response_listeners_, kOnHeadersReceived))
return brightray::NetworkDelegate::OnHeadersReceived( return brightray::NetworkDelegate::OnHeadersReceived(
request, callback, original_response_headers, override_response_headers, request, callback, original_response_headers, override_response_headers,
allowed_unsafe_redirect_url); allowed_unsafe_redirect_url);
const ListenerInfo& info = event_listener_map_[kOnHeadersReceived]; const auto& info = response_listeners_[kOnHeadersReceived];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return net::OK; return net::OK;
@ -264,23 +311,24 @@ int AtomNetworkDelegate::OnHeadersReceived(
FillDetailsObject(details.get(), request); FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), original_response_headers); FillDetailsObject(details.get(), original_response_headers);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE, ResponseCallback response =
base::Bind(&RunListener, info.callback, base::Passed(&details)), base::Bind(OnListenerResultInUI<scoped_refptr<net::HttpResponseHeaders>*>,
base::Bind(&OnHeadersReceivedResponse, callback, override_response_headers);
callback, BrowserThread::PostTask(
original_response_headers, BrowserThread::UI, FROM_HERE,
override_response_headers)); base::Bind(RunResponseListener, info.listener, base::Passed(&details),
response));
return net::ERR_IO_PENDING; return net::ERR_IO_PENDING;
} }
void AtomNetworkDelegate::OnBeforeRedirect(net::URLRequest* request, void AtomNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
const GURL& new_location) { const GURL& new_location) {
if (!ContainsKey(event_listener_map_, kOnBeforeRedirect)) { if (!ContainsKey(simple_listeners_, kOnBeforeRedirect)) {
brightray::NetworkDelegate::OnBeforeRedirect(request, new_location); brightray::NetworkDelegate::OnBeforeRedirect(request, new_location);
return; return;
} }
const ListenerInfo& info = event_listener_map_[kOnBeforeRedirect]; const auto& info = simple_listeners_[kOnBeforeRedirect];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return; return;
@ -291,14 +339,13 @@ void AtomNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
FillDetailsObject(details.get(), request->GetSocketAddress()); FillDetailsObject(details.get(), request->GetSocketAddress());
FillDetailsObject(details.get(), request->was_cached()); FillDetailsObject(details.get(), request->was_cached());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, BrowserThread::PostTask(
base::Bind(base::IgnoreResult(&RunListener), BrowserThread::UI, FROM_HERE,
info.callback, base::Bind(&RunSimpleListener, info.listener, base::Passed(&details)));
base::Passed(&details)));
} }
void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) { void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
if (!ContainsKey(event_listener_map_, kOnResponseStarted)) { if (!ContainsKey(simple_listeners_, kOnResponseStarted)) {
brightray::NetworkDelegate::OnResponseStarted(request); brightray::NetworkDelegate::OnResponseStarted(request);
return; return;
} }
@ -306,7 +353,7 @@ void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
if (request->status().status() != net::URLRequestStatus::SUCCESS) if (request->status().status() != net::URLRequestStatus::SUCCESS)
return; return;
const ListenerInfo& info = event_listener_map_[kOnResponseStarted]; const auto& info = simple_listeners_[kOnResponseStarted];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return; return;
@ -315,17 +362,16 @@ void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
FillDetailsObject(details.get(), request->response_headers()); FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->was_cached()); FillDetailsObject(details.get(), request->was_cached());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, BrowserThread::PostTask(
base::Bind(base::IgnoreResult(&RunListener), BrowserThread::UI, FROM_HERE,
info.callback, base::Bind(RunSimpleListener, info.listener, base::Passed(&details)));
base::Passed(&details)));
} }
void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) { void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
if (request->status().status() == net::URLRequestStatus::FAILED || if (request->status().status() == net::URLRequestStatus::FAILED ||
request->status().status() == net::URLRequestStatus::CANCELED) { request->status().status() == net::URLRequestStatus::CANCELED) {
// Error event. // Error event.
if (ContainsKey(event_listener_map_, kOnErrorOccurred)) if (ContainsKey(simple_listeners_, kOnErrorOccurred))
OnErrorOccurred(request); OnErrorOccurred(request);
else else
brightray::NetworkDelegate::OnCompleted(request, started); brightray::NetworkDelegate::OnCompleted(request, started);
@ -338,12 +384,12 @@ void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
return; return;
} }
if (!ContainsKey(event_listener_map_, kOnCompleted)) { if (!ContainsKey(simple_listeners_, kOnCompleted)) {
brightray::NetworkDelegate::OnCompleted(request, started); brightray::NetworkDelegate::OnCompleted(request, started);
return; return;
} }
const ListenerInfo& info = event_listener_map_[kOnCompleted]; const auto& info = simple_listeners_[kOnCompleted];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return; return;
@ -352,15 +398,13 @@ void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
FillDetailsObject(details.get(), request->response_headers()); FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->was_cached()); FillDetailsObject(details.get(), request->was_cached());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, BrowserThread::PostTask(
base::Bind(base::IgnoreResult(&RunListener), BrowserThread::UI, FROM_HERE,
info.callback, base::Bind(RunSimpleListener, info.listener, base::Passed(&details)));
base::Passed(&details)));
} }
void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request) { void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request) {
const auto& info = simple_listeners_[kOnErrorOccurred];
const ListenerInfo& info = event_listener_map_[kOnErrorOccurred];
if (!MatchesFilterCondition(request, info.url_patterns)) if (!MatchesFilterCondition(request, info.url_patterns))
return; return;
@ -369,10 +413,9 @@ void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request) {
FillDetailsObject(details.get(), request->was_cached()); FillDetailsObject(details.get(), request->was_cached());
FillDetailsObject(details.get(), request->status()); FillDetailsObject(details.get(), request->status());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, BrowserThread::PostTask(
base::Bind(base::IgnoreResult(&RunListener), BrowserThread::UI, FROM_HERE,
info.callback, base::Bind(RunSimpleListener, info.listener, base::Passed(&details)));
base::Passed(&details)));
} }
} // namespace atom } // namespace atom

49
atom/browser/net/atom_network_delegate.h
View file

@ -26,46 +26,44 @@ using URLPatterns = std::set<extensions::URLPattern>;
class AtomNetworkDelegate : public brightray::NetworkDelegate { class AtomNetworkDelegate : public brightray::NetworkDelegate {
public: public:
struct BlockingResponse; using ResponseCallback = base::Callback<void(const base::DictionaryValue&)>;
using Listener = using SimpleListener = base::Callback<void(const base::DictionaryValue&)>;
base::Callback<BlockingResponse(const base::DictionaryValue&)>; using ResponseListener = base::Callback<void(const base::DictionaryValue&,
const ResponseCallback&)>;
enum EventType { enum SimpleEvent {
kOnBeforeRequest,
kOnBeforeSendHeaders,
kOnSendHeaders, kOnSendHeaders,
kOnHeadersReceived,
kOnBeforeRedirect, kOnBeforeRedirect,
kOnResponseStarted, kOnResponseStarted,
kOnCompleted, kOnCompleted,
kOnErrorOccurred, kOnErrorOccurred,
}; };
struct ListenerInfo { enum ResponseEvent {
URLPatterns url_patterns; kOnBeforeRequest,
AtomNetworkDelegate::Listener callback; kOnBeforeSendHeaders,
kOnHeadersReceived,
}; };
struct BlockingResponse { struct SimpleListenerInfo {
BlockingResponse() : cancel(false) {} URLPatterns url_patterns;
~BlockingResponse() {} SimpleListener listener;
};
int code() const { struct ResponseListenerInfo {
return cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK; URLPatterns url_patterns;
} ResponseListener listener;
bool cancel;
GURL redirect_url;
net::HttpRequestHeaders request_headers;
scoped_refptr<net::HttpResponseHeaders> response_headers;
}; };
AtomNetworkDelegate(); AtomNetworkDelegate();
~AtomNetworkDelegate() override; ~AtomNetworkDelegate() override;
void SetListenerInIO(EventType type, void SetSimpleListenerInIO(SimpleEvent type,
const URLPatterns& patterns, const URLPatterns& patterns,
const Listener& callback); const SimpleListener& callback);
void SetResponseListenerInIO(ResponseEvent type,
const URLPatterns& patterns,
const ResponseListener& callback);
protected: protected:
// net::NetworkDelegate: // net::NetworkDelegate:
@ -91,7 +89,8 @@ class AtomNetworkDelegate : public brightray::NetworkDelegate {
void OnErrorOccurred(net::URLRequest* request); void OnErrorOccurred(net::URLRequest* request);
private: private:
std::map<EventType, ListenerInfo> event_listener_map_; std::map<SimpleEvent, SimpleListenerInfo> simple_listeners_;
std::map<ResponseEvent, ResponseListenerInfo> response_listeners_;;
DISALLOW_COPY_AND_ASSIGN(AtomNetworkDelegate); DISALLOW_COPY_AND_ASSIGN(AtomNetworkDelegate);
}; };

34
atom/common/native_mate_converters/net_converter.cc
View file

@ -82,38 +82,4 @@ v8::Local<v8::Value> Converter<scoped_refptr<net::X509Certificate>>::ToV8(
return dict.GetHandle(); return dict.GetHandle();
} }
// static
bool Converter<atom::AtomNetworkDelegate::BlockingResponse>::FromV8(
v8::Isolate* isolate, v8::Local<v8::Value> val,
atom::AtomNetworkDelegate::BlockingResponse* out) {
mate::Dictionary dict;
if (!ConvertFromV8(isolate, val, &dict))
return false;
if (!dict.Get("cancel", &(out->cancel)))
return false;
dict.Get("redirectURL", &(out->redirect_url));
base::DictionaryValue request_headers;
if (dict.Get("requestHeaders", &request_headers)) {
for (base::DictionaryValue::Iterator it(request_headers);
!it.IsAtEnd();
it.Advance()) {
std::string value;
CHECK(it.value().GetAsString(&value));
out->request_headers.SetHeader(it.key(), value);
}
}
base::DictionaryValue response_headers;
if (dict.Get("responseHeaders", &response_headers)) {
out->response_headers = new net::HttpResponseHeaders("");
for (base::DictionaryValue::Iterator it(response_headers);
!it.IsAtEnd();
it.Advance()) {
std::string value;
CHECK(it.value().GetAsString(&value));
out->response_headers->AddHeader(it.key() + " : " + value);
}
}
return true;
}
} // namespace mate } // namespace mate

8
atom/common/native_mate_converters/net_converter.h
View file

@ -5,7 +5,6 @@
#ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_NET_CONVERTER_H_ #ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_NET_CONVERTER_H_
#define ATOM_COMMON_NATIVE_MATE_CONVERTERS_NET_CONVERTER_H_ #define ATOM_COMMON_NATIVE_MATE_CONVERTERS_NET_CONVERTER_H_
#include "atom/browser/net/atom_network_delegate.h"
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "native_mate/converter.h" #include "native_mate/converter.h"
@ -35,13 +34,6 @@ struct Converter<scoped_refptr<net::X509Certificate>> {
const scoped_refptr<net::X509Certificate>& val); const scoped_refptr<net::X509Certificate>& val);
}; };
template<>
struct Converter<atom::AtomNetworkDelegate::BlockingResponse> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
atom::AtomNetworkDelegate::BlockingResponse* out);
};
} // namespace mate } // namespace mate
#endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_NET_CONVERTER_H_ #endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_NET_CONVERTER_H_