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

Unify how listeners are handled

Browse source
This commit is contained in:
Cheng Zhao 2015-12-11 21:02:44 +08:00
parent 9d406b695f
commit 79a627014c
2 changed files with 152 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -5,6 +5,7 @@
#include "atom/browser/net/atom_network_delegate.h" #include "atom/browser/net/atom_network_delegate.h"
#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/strings/string_util.h" #include "base/strings/string_util.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
#include "content/public/browser/resource_request_info.h" #include "content/public/browser/resource_request_info.h"
@ -43,18 +44,16 @@ AtomNetworkDelegate::BlockingResponse RunListener(
return callback.Run(*(details.get())); return callback.Run(*(details.get()));
} }
bool MatchesFilterCondition( bool MatchesFilterCondition(net::URLRequest* request,
net::URLRequest* request, const URLPatterns& patterns) {
const AtomNetworkDelegate::ListenerInfo& info) { if (patterns.empty())
if (!info.url_patterns.empty()) { return true;
auto url = request->url();
for (auto& pattern : info.url_patterns)
if (pattern.MatchesURL(url))
return true;
return false;
}
return true; for (const auto& pattern : patterns) {
if (pattern.MatchesURL(request->url()))
return true;
}
return false;
} }
void FillDetailsObject(base::DictionaryValue* details, void FillDetailsObject(base::DictionaryValue* details,
@ -199,75 +198,67 @@ int AtomNetworkDelegate::OnBeforeURLRequest(
net::URLRequest* request, net::URLRequest* request,
const net::CompletionCallback& callback, const net::CompletionCallback& callback,
GURL* new_url) { GURL* new_url) {
auto listener_info = event_listener_map_.find(kOnBeforeRequest); if (!ContainsKey(event_listener_map_, kOnBeforeRequest))
if (listener_info != event_listener_map_.end()) { return brightray::NetworkDelegate::OnBeforeURLRequest(
if (!MatchesFilterCondition(request, listener_info->second)) request, callback, new_url);
return net::OK;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue); const ListenerInfo& info = event_listener_map_[kOnBeforeRequest];
FillDetailsObject(details.get(), request); if (!MatchesFilterCondition(request, info.url_patterns))
return net::OK;
auto wrapped_callback = listener_info->second.callback; scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE, FillDetailsObject(details.get(), request);
base::Bind(&RunListener, wrapped_callback, base::Passed(&details)),
base::Bind(&OnBeforeURLRequestResponse,
callback, new_url));
return net::ERR_IO_PENDING; BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
} base::Bind(&RunListener, info.callback, base::Passed(&details)),
base::Bind(&OnBeforeURLRequestResponse,
return brightray::NetworkDelegate::OnBeforeURLRequest(request, callback, new_url));
callback, return net::ERR_IO_PENDING;
new_url);
} }
int AtomNetworkDelegate::OnBeforeSendHeaders( int AtomNetworkDelegate::OnBeforeSendHeaders(
net::URLRequest* request, net::URLRequest* request,
const net::CompletionCallback& callback, const net::CompletionCallback& callback,
net::HttpRequestHeaders* headers) { net::HttpRequestHeaders* headers) {
auto listener_info = event_listener_map_.find(kOnBeforeSendHeaders); if (!ContainsKey(event_listener_map_, kOnBeforeSendHeaders))
if (listener_info != event_listener_map_.end()) { return brightray::NetworkDelegate::OnBeforeSendHeaders(
if (!MatchesFilterCondition(request, listener_info->second)) request, callback, headers);
return net::OK;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue); const ListenerInfo& info = event_listener_map_[kOnBeforeSendHeaders];
FillDetailsObject(details.get(), request); if (!MatchesFilterCondition(request, info.url_patterns))
FillDetailsObject(details.get(), *headers); return net::OK;
auto wrapped_callback = listener_info->second.callback; scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE, FillDetailsObject(details.get(), request);
base::Bind(&RunListener, wrapped_callback, base::Passed(&details)), FillDetailsObject(details.get(), *headers);
base::Bind(&OnBeforeSendHeadersResponse,
callback, headers));
return net::ERR_IO_PENDING; BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
} base::Bind(&RunListener, info.callback, base::Passed(&details)),
base::Bind(&OnBeforeSendHeadersResponse,
return brightray::NetworkDelegate::OnBeforeSendHeaders(request, callback, headers));
callback, return net::ERR_IO_PENDING;
headers);
} }
void AtomNetworkDelegate::OnSendHeaders( void AtomNetworkDelegate::OnSendHeaders(
net::URLRequest* request, net::URLRequest* request,
const net::HttpRequestHeaders& headers) { const net::HttpRequestHeaders& headers) {
auto listener_info = event_listener_map_.find(kOnSendHeaders); if (!ContainsKey(event_listener_map_, kOnSendHeaders)) {
if (listener_info != event_listener_map_.end()) {
if (!MatchesFilterCondition(request, listener_info->second))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), headers);
auto wrapped_callback = listener_info->second.callback;
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
wrapped_callback,
base::Passed(&details)));
} else {
brightray::NetworkDelegate::OnSendHeaders(request, headers); brightray::NetworkDelegate::OnSendHeaders(request, headers);
return;
} }
const ListenerInfo& info = event_listener_map_[kOnSendHeaders];
if (!MatchesFilterCondition(request, info.url_patterns))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), headers);
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
info.callback,
base::Passed(&details)));
} }
int AtomNetworkDelegate::OnHeadersReceived( int AtomNetworkDelegate::OnHeadersReceived(
@ -276,129 +267,128 @@ 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) {
auto listener_info = event_listener_map_.find(kOnHeadersReceived); if (!ContainsKey(event_listener_map_, kOnHeadersReceived))
if (listener_info != event_listener_map_.end()) { return brightray::NetworkDelegate::OnHeadersReceived(
if (!MatchesFilterCondition(request, listener_info->second)) request, callback, original_response_headers, override_response_headers,
return net::OK; allowed_unsafe_redirect_url);
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue); const ListenerInfo& info = event_listener_map_[kOnHeadersReceived];
FillDetailsObject(details.get(), request); if (!MatchesFilterCondition(request, info.url_patterns))
FillDetailsObject(details.get(), original_response_headers); return net::OK;
auto wrapped_callback = listener_info->second.callback; scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE, FillDetailsObject(details.get(), request);
base::Bind(&RunListener, wrapped_callback, base::Passed(&details)), FillDetailsObject(details.get(), original_response_headers);
base::Bind(&OnHeadersReceivedResponse,
callback,
original_response_headers,
override_response_headers));
return net::ERR_IO_PENDING; BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
} base::Bind(&RunListener, info.callback, base::Passed(&details)),
base::Bind(&OnHeadersReceivedResponse,
return brightray::NetworkDelegate::OnHeadersReceived( callback,
request, callback, original_response_headers, override_response_headers, original_response_headers,
allowed_unsafe_redirect_url); override_response_headers));
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) {
auto listener_info = event_listener_map_.find(kOnBeforeRedirect); if (!ContainsKey(event_listener_map_, kOnBeforeRedirect)) {
if (listener_info != event_listener_map_.end()) {
if (!MatchesFilterCondition(request, listener_info->second))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), new_location);
FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->GetSocketAddress());
FillDetailsObject(details.get(), request->was_cached());
auto wrapped_callback = listener_info->second.callback;
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
wrapped_callback,
base::Passed(&details)));
} else {
brightray::NetworkDelegate::OnBeforeRedirect(request, new_location); brightray::NetworkDelegate::OnBeforeRedirect(request, new_location);
return;
} }
const ListenerInfo& info = event_listener_map_[kOnBeforeRedirect];
if (!MatchesFilterCondition(request, info.url_patterns))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), new_location);
FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->GetSocketAddress());
FillDetailsObject(details.get(), request->was_cached());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
info.callback,
base::Passed(&details)));
} }
void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) { void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
auto listener_info = event_listener_map_.find(kOnResponseStarted); if (!ContainsKey(event_listener_map_, kOnResponseStarted)) {
if (listener_info != event_listener_map_.end()) {
if (request->status().status() != net::URLRequestStatus::SUCCESS)
return;
if (!MatchesFilterCondition(request, listener_info->second))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->was_cached());
auto wrapped_callback = listener_info->second.callback;
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
wrapped_callback,
base::Passed(&details)));
} else {
brightray::NetworkDelegate::OnResponseStarted(request); brightray::NetworkDelegate::OnResponseStarted(request);
return;
} }
if (request->status().status() != net::URLRequestStatus::SUCCESS)
return;
const ListenerInfo& info = event_listener_map_[kOnResponseStarted];
if (!MatchesFilterCondition(request, info.url_patterns))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->was_cached());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
info.callback,
base::Passed(&details)));
} }
void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) { void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
auto listener_info = event_listener_map_.find(kOnCompleted); if (request->status().status() == net::URLRequestStatus::FAILED ||
if (listener_info != event_listener_map_.end()) { request->status().status() == net::URLRequestStatus::CANCELED) {
if (request->status().status() == net::URLRequestStatus::FAILED || // Error event.
request->status().status() == net::URLRequestStatus::CANCELED) { if (ContainsKey(event_listener_map_, kOnErrorOccurred))
OnErrorOccurred(request); OnErrorOccurred(request);
return; else
} else { brightray::NetworkDelegate::OnCompleted(request, started);
bool is_redirect = request->response_headers() && return;
net::HttpResponseHeaders::IsRedirectResponseCode( } else if (request->response_headers() &&
request->response_headers()->response_code()); net::HttpResponseHeaders::IsRedirectResponseCode(
if (is_redirect) request->response_headers()->response_code())) {
return; // Redirect event.
}
if (!MatchesFilterCondition(request, listener_info->second))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->was_cached());
auto wrapped_callback = listener_info->second.callback;
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
wrapped_callback,
base::Passed(&details)));
} else {
brightray::NetworkDelegate::OnCompleted(request, started); brightray::NetworkDelegate::OnCompleted(request, started);
return;
} }
if (!ContainsKey(event_listener_map_, kOnCompleted)) {
brightray::NetworkDelegate::OnCompleted(request, started);
return;
}
const ListenerInfo& info = event_listener_map_[kOnCompleted];
if (!MatchesFilterCondition(request, info.url_patterns))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
FillDetailsObject(details.get(), request);
FillDetailsObject(details.get(), request->response_headers());
FillDetailsObject(details.get(), request->was_cached());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
info.callback,
base::Passed(&details)));
} }
void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request) { void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request) {
auto listener_info = event_listener_map_.find(kOnErrorOccurred);
if (listener_info != event_listener_map_.end()) {
if (!MatchesFilterCondition(request, listener_info->second))
return;
scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue); const ListenerInfo& info = event_listener_map_[kOnErrorOccurred];
FillDetailsObject(details.get(), request); if (!MatchesFilterCondition(request, info.url_patterns))
FillDetailsObject(details.get(), request->was_cached()); return;
FillDetailsObject(details.get(), request->status());
auto wrapped_callback = listener_info->second.callback; scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, FillDetailsObject(details.get(), request);
base::Bind(base::IgnoreResult(&RunListener), FillDetailsObject(details.get(), request->was_cached());
wrapped_callback, FillDetailsObject(details.get(), request->status());
base::Passed(&details)));
} BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(&RunListener),
info.callback,
base::Passed(&details)));
} }
} // namespace atom } // namespace atom

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

@ -22,6 +22,8 @@ class URLPattern;
namespace atom { namespace atom {
using URLPatterns = std::set<extensions::URLPattern>;
class AtomNetworkDelegate : public brightray::NetworkDelegate { class AtomNetworkDelegate : public brightray::NetworkDelegate {
public: public:
struct BlockingResponse; struct BlockingResponse;
@ -41,7 +43,7 @@ class AtomNetworkDelegate : public brightray::NetworkDelegate {
}; };
struct ListenerInfo { struct ListenerInfo {
std::set<extensions::URLPattern> url_patterns; URLPatterns url_patterns;
AtomNetworkDelegate::Listener callback; AtomNetworkDelegate::Listener callback;
}; };