electron/atom/browser/net/atom_network_delegate.cc

221 lines
7.4 KiB
C++
Raw Normal View History

2015-12-01 04:52:22 +00:00
// Copyright (c) 2015 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/net/atom_network_delegate.h"
#include <map>
#include "atom/common/native_mate_converters/net_converter.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/resource_request_info.h"
#include "net/base/net_errors.h"
#include "net/url_request/url_request.h"
using content::BrowserThread;
namespace atom {
namespace {
base::DictionaryValue* ExtractRequestInfo(net::URLRequest* request) {
base::DictionaryValue* dict = new base::DictionaryValue();
dict->SetInteger("id", request->identifier());
dict->SetString("url", request->url().spec());
dict->SetString("method", request->method());
content::ResourceType resourceType = content::RESOURCE_TYPE_LAST_TYPE;
auto info = content::ResourceRequestInfo::ForRequest(request);
if (info)
resourceType = info->GetResourceType();
dict->SetInteger("resourceType", resourceType);
dict->SetDouble("timestamp", base::Time::Now().ToDoubleT() * 1000);
return dict;
}
base::DictionaryValue* GetRequestHeadersDict(
const net::HttpRequestHeaders& headers) {
base::DictionaryValue* header_dict = new base::DictionaryValue();
net::HttpRequestHeaders::Iterator it(headers);
while (it.GetNext())
header_dict->SetString(it.name(), it.value());
return header_dict;
}
base::DictionaryValue* GetResponseHeadersDict(
const net::HttpResponseHeaders* headers) {
base::DictionaryValue* header_dict = new base::DictionaryValue();
if (headers) {
void* iter = nullptr;
std::string key;
std::string value;
while (headers->EnumerateHeaderLines(&iter, &key, &value))
header_dict->SetString(key, value);
}
return header_dict;
}
void OnBeforeURLRequestResponse(
const net::CompletionCallback& callback,
GURL* new_url,
const AtomNetworkDelegate::BlockingResponse& result) {
if (!result.redirectURL.is_empty())
*new_url = result.redirectURL;
callback.Run(result.cancel);
}
void OnBeforeSendHeadersResponse(
const net::CompletionCallback& callback,
net::HttpRequestHeaders* headers,
const AtomNetworkDelegate::BlockingResponse& result) {
if (!result.requestHeaders.IsEmpty())
*headers = result.requestHeaders;
callback.Run(result.cancel);
}
void OnHeadersReceivedResponse(
const net::CompletionCallback& callback,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
const AtomNetworkDelegate::BlockingResponse& result) {
if (result.responseHeaders.get())
*override_response_headers = result.responseHeaders;
callback.Run(result.cancel);
}
} // namespace
// static
std::map<AtomNetworkDelegate::EventTypes, AtomNetworkDelegate::ListenerInfo>
AtomNetworkDelegate::event_listener_map_;
AtomNetworkDelegate::AtomNetworkDelegate() {
}
AtomNetworkDelegate::~AtomNetworkDelegate() {
}
void AtomNetworkDelegate::SetListenerInIO(
EventTypes type,
const base::DictionaryValue* filter,
const Listener& callback) {
ListenerInfo info;
info.callback = callback;
event_listener_map_[type] = info;
}
int AtomNetworkDelegate::OnBeforeURLRequest(
net::URLRequest* request,
const net::CompletionCallback& callback,
GURL* new_url) {
brightray::NetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
auto listener_info = event_listener_map_[kOnBeforeRequest];
if (!event_listener_map_.empty() && !listener_info.callback.is_null()) {
auto wrapped_callback = listener_info.callback;
auto details = ExtractRequestInfo(request);
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
base::Bind(wrapped_callback, details),
base::Bind(&OnBeforeURLRequestResponse,
callback, new_url));
return net::ERR_IO_PENDING;
}
return net::OK;
}
int AtomNetworkDelegate::OnBeforeSendHeaders(
net::URLRequest* request,
const net::CompletionCallback& callback,
net::HttpRequestHeaders* headers) {
auto listener_info = event_listener_map_[kOnBeforeSendHeaders];
if (!event_listener_map_.empty() && !listener_info.callback.is_null()) {
auto wrapped_callback = listener_info.callback;
auto details = ExtractRequestInfo(request);
details->Set("requestHeaders", GetRequestHeadersDict(*headers));
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
base::Bind(wrapped_callback, details),
base::Bind(&OnBeforeSendHeadersResponse,
callback, headers));
return net::ERR_IO_PENDING;
}
return net::OK;
}
void AtomNetworkDelegate::OnSendHeaders(
net::URLRequest* request,
const net::HttpRequestHeaders& headers) {
auto listener_info = event_listener_map_[kOnSendHeaders];
if (!event_listener_map_.empty() && !listener_info.callback.is_null()) {
auto wrapped_callback = listener_info.callback;
auto details = ExtractRequestInfo(request);
details->Set("requestHeaders", GetRequestHeadersDict(headers));
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(wrapped_callback),
details));
}
}
int AtomNetworkDelegate::OnHeadersReceived(
net::URLRequest* request,
const net::CompletionCallback& callback,
const net::HttpResponseHeaders* original_response_headers,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
GURL* allowed_unsafe_redirect_url) {
auto listener_info = event_listener_map_[kOnHeadersReceived];
if (!event_listener_map_.empty() && !listener_info.callback.is_null()) {
auto wrapped_callback = listener_info.callback;
auto details = ExtractRequestInfo(request);
details->Set("responseHeaders",
GetResponseHeadersDict(original_response_headers));
BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
base::Bind(wrapped_callback, details),
base::Bind(&OnHeadersReceivedResponse,
callback,
override_response_headers));
return net::ERR_IO_PENDING;
}
return net::OK;
}
void AtomNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
const GURL& new_location) {
auto listener_info = event_listener_map_[kOnBeforeRedirect];
if (!event_listener_map_.empty() && !listener_info.callback.is_null()) {
auto wrapped_callback = listener_info.callback;
auto details = ExtractRequestInfo(request);
details->SetString("redirectURL", new_location.spec());
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(wrapped_callback),
details));
}
}
void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
auto listener_info = event_listener_map_[kOnResponseStarted];
if (!event_listener_map_.empty() && !listener_info.callback.is_null()) {
auto wrapped_callback = listener_info.callback;
auto details = ExtractRequestInfo(request);
details->Set("responseHeaders",
GetResponseHeadersDict(request->response_headers()));
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(base::IgnoreResult(wrapped_callback),
details));
}
}
void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
}
} // namespace atom