Merge pull request #3640 from deepak1556/webrequest_api_patch

session: add webrequest api

atom/browser/api/atom_api_session.cc

@@ -10,6 +10,7 @@
 #include "atom/browser/api/atom_api_cookies.h"
 #include "atom/browser/api/atom_api_download_item.h"
 #include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/api/atom_api_web_request.h"
 #include "atom/browser/api/save_page_handler.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
@@ -368,6 +369,14 @@ v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
   return v8::Local<v8::Value>::New(isolate, cookies_);
 }
 
+v8::Local<v8::Value> Session::WebRequest(v8::Isolate* isolate) {
+  if (web_request_.IsEmpty()) {
+    auto handle = atom::api::WebRequest::Create(isolate, browser_context());
+    web_request_.Reset(isolate, handle.ToV8());
+  }
+  return v8::Local<v8::Value>::New(isolate, web_request_);
+}
+
 // static
 mate::Handle<Session> Session::CreateFrom(
     v8::Isolate* isolate, AtomBrowserContext* browser_context) {
@@ -401,7 +410,8 @@ void Session::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("enableNetworkEmulation", &Session::EnableNetworkEmulation)
       .SetMethod("disableNetworkEmulation", &Session::DisableNetworkEmulation)
       .SetMethod("setCertificateVerifyProc", &Session::SetCertVerifyProc)
-      .SetProperty("cookies", &Session::Cookies);
+      .SetProperty("cookies", &Session::Cookies)
+      .SetProperty("webRequest", &Session::WebRequest);
 }
 
 void ClearWrapSession() {

atom/browser/api/atom_api_session.h

@@ -70,9 +70,11 @@ class Session: public mate::TrackableObject<Session>,
   void DisableNetworkEmulation();
   void SetCertVerifyProc(v8::Local<v8::Value> proc, mate::Arguments* args);
   v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
+  v8::Local<v8::Value> WebRequest(v8::Isolate* isolate);
 
-  // Cached object for cookies API.
+  // Cached object.
   v8::Global<v8::Value> cookies_;
+  v8::Global<v8::Value> web_request_;
 
   scoped_refptr<AtomBrowserContext> browser_context_;
 

atom/browser/api/atom_api_web_request.cc

@@ -0,0 +1,87 @@
+// 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/api/atom_api_web_request.h"
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/net/atom_network_delegate.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace api {
+
+WebRequest::WebRequest(AtomBrowserContext* browser_context)
+    : browser_context_(browser_context) {
+}
+
+WebRequest::~WebRequest() {
+}
+
+template<AtomNetworkDelegate::EventTypes type>
+void WebRequest::SetListener(mate::Arguments* args) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  scoped_ptr<base::DictionaryValue> filter(new base::DictionaryValue());
+  args->GetNext(filter.get());
+  AtomNetworkDelegate::Listener callback;
+  if (!args->GetNext(&callback)) {
+    args->ThrowError("Must pass null or a function");
+    return;
+  }
+
+  auto delegate = browser_context_->network_delegate();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AtomNetworkDelegate::SetListenerInIO,
+                                     base::Unretained(delegate),
+                                     type, base::Passed(&filter), callback));
+}
+
+// static
+mate::Handle<WebRequest> WebRequest::Create(
+    v8::Isolate* isolate,
+    AtomBrowserContext* browser_context) {
+  return mate::CreateHandle(isolate, new WebRequest(browser_context));
+}
+
+// static
+void WebRequest::BuildPrototype(v8::Isolate* isolate,
+                                v8::Local<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("onBeforeRequest",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnBeforeRequest>)
+      .SetMethod("onBeforeSendHeaders",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnBeforeSendHeaders>)
+      .SetMethod("onSendHeaders",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnSendHeaders>)
+      .SetMethod("onHeadersReceived",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnHeadersReceived>)
+      .SetMethod("onBeforeRedirect",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnBeforeRedirect>)
+      .SetMethod("onResponseStarted",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnResponseStarted>)
+      .SetMethod("onCompleted",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnCompleted>)
+      .SetMethod("onErrorOccurred",
+                 &WebRequest::SetListener<
+                    AtomNetworkDelegate::kOnErrorOccurred>);
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_web_request.h

@@ -0,0 +1,47 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_WEB_REQUEST_H_
+#define ATOM_BROWSER_API_ATOM_API_WEB_REQUEST_H_
+
+#include <string>
+
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/net/atom_network_delegate.h"
+#include "native_mate/arguments.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+class AtomBrowserContext;
+
+namespace api {
+
+class WebRequest : public mate::TrackableObject<WebRequest> {
+ public:
+  static mate::Handle<WebRequest> Create(v8::Isolate* isolate,
+                                         AtomBrowserContext* browser_context);
+
+  // mate::TrackableObject:
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::ObjectTemplate> prototype);
+
+ protected:
+  explicit WebRequest(AtomBrowserContext* browser_context);
+  ~WebRequest();
+
+  template<AtomNetworkDelegate::EventTypes Event>
+  void SetListener(mate::Arguments* args);
+
+ private:
+  scoped_refptr<AtomBrowserContext> browser_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebRequest);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_WEB_REQUEST_H_

atom/browser/api/lib/session.coffee

@@ -14,7 +14,7 @@ exports.fromPartition = (partition='') ->
 # Returns the default session.
 Object.defineProperty exports, 'defaultSession',
   enumerable: true
-  get: -> exports.fromPartition ''
+  get: -> exports.fromPartition 'persist:'
 
 wrapSession = (session) ->
   # session is an EventEmitter.

atom/browser/atom_browser_context.cc

@@ -8,6 +8,7 @@
 #include "atom/browser/atom_download_manager_delegate.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/net/atom_cert_verifier.h"
+#include "atom/browser/net/atom_network_delegate.h"
 #include "atom/browser/net/atom_ssl_config_service.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/asar/asar_protocol_handler.h"
@@ -63,12 +64,17 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
     : brightray::BrowserContext(partition, in_memory),
       cert_verifier_(nullptr),
       job_factory_(new AtomURLRequestJobFactory),
+      network_delegate_(new AtomNetworkDelegate),
       allow_ntlm_everywhere_(false) {
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
 }
 
+net::NetworkDelegate* AtomBrowserContext::CreateNetworkDelegate() {
+  return network_delegate_;
+}
+
 std::string AtomBrowserContext::GetUserAgent() {
   Browser* browser = Browser::Get();
   std::string name = RemoveWhitespace(browser->GetName());

atom/browser/atom_browser_context.h

@@ -13,6 +13,7 @@ namespace atom {
 
 class AtomDownloadManagerDelegate;
 class AtomCertVerifier;
+class AtomNetworkDelegate;
 class AtomURLRequestJobFactory;
 class WebViewManager;
 
@@ -22,6 +23,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
   ~AtomBrowserContext() override;
 
   // brightray::URLRequestContextGetter::Delegate:
+  net::NetworkDelegate* CreateNetworkDelegate() override;
   std::string GetUserAgent() override;
   scoped_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
       content::ProtocolHandlerMap* handlers,
@@ -45,6 +47,8 @@ class AtomBrowserContext : public brightray::BrowserContext {
 
   AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
 
+  AtomNetworkDelegate* network_delegate() const { return network_delegate_; }
+
  private:
   scoped_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
   scoped_ptr<WebViewManager> guest_manager_;
@@ -52,6 +56,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
   // Managed by brightray::BrowserContext.
   AtomCertVerifier* cert_verifier_;
   AtomURLRequestJobFactory* job_factory_;
+  AtomNetworkDelegate* network_delegate_;
 
   bool allow_ntlm_everywhere_;
 

atom/browser/net/atom_network_delegate.cc

@@ -0,0 +1,393 @@
+// 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 "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/url_request/url_request.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+std::string ResourceTypeToString(content::ResourceType type) {
+  switch (type) {
+    case content::RESOURCE_TYPE_MAIN_FRAME:
+      return "mainFrame";
+    case content::RESOURCE_TYPE_SUB_FRAME:
+      return "subFrame";
+    case content::RESOURCE_TYPE_STYLESHEET:
+      return "stylesheet";
+    case content::RESOURCE_TYPE_SCRIPT:
+      return "script";
+    case content::RESOURCE_TYPE_IMAGE:
+      return "image";
+    case content::RESOURCE_TYPE_OBJECT:
+      return "object";
+    case content::RESOURCE_TYPE_XHR:
+      return "xhr";
+    default:
+      return "other";
+  }
+}
+
+AtomNetworkDelegate::BlockingResponse RunListener(
+    const AtomNetworkDelegate::Listener& callback,
+    scoped_ptr<base::DictionaryValue> details) {
+  return callback.Run(*(details.get()));
+}
+
+bool MatchesFilterCondition(
+    net::URLRequest* request,
+    const AtomNetworkDelegate::ListenerInfo& info) {
+  if (!info.url_patterns.empty()) {
+    auto url = request->url();
+    for (auto& pattern : info.url_patterns)
+      if (pattern.MatchesURL(url))
+        return true;
+    return false;
+  }
+
+  return true;
+}
+
+scoped_ptr<base::DictionaryValue> ExtractRequestInfo(net::URLRequest* request) {
+  scoped_ptr<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->SetString("resourceType", ResourceTypeToString(resourceType));
+  dict->SetDouble("timestamp", base::Time::Now().ToDoubleT() * 1000);
+
+  return dict.Pass();
+}
+
+scoped_ptr<base::DictionaryValue> GetRequestHeadersDict(
+    const net::HttpRequestHeaders& headers) {
+  scoped_ptr<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.Pass();
+}
+
+scoped_ptr<base::DictionaryValue> GetResponseHeadersDict(
+    const net::HttpResponseHeaders* headers) {
+  scoped_ptr<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.Pass();
+}
+
+void OnBeforeURLRequestResponse(
+    const net::CompletionCallback& callback,
+    GURL* new_url,
+    const AtomNetworkDelegate::BlockingResponse& result) {
+  if (!result.redirect_url.is_empty())
+    *new_url = result.redirect_url;
+  callback.Run(result.Code());
+}
+
+void OnBeforeSendHeadersResponse(
+    const net::CompletionCallback& callback,
+    net::HttpRequestHeaders* headers,
+    const AtomNetworkDelegate::BlockingResponse& result) {
+  if (!result.request_headers.IsEmpty())
+    *headers = result.request_headers;
+  callback.Run(result.Code());
+}
+
+void OnHeadersReceivedResponse(
+    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());
+}
+
+}  // namespace
+
+AtomNetworkDelegate::AtomNetworkDelegate() {
+}
+
+AtomNetworkDelegate::~AtomNetworkDelegate() {
+}
+
+void AtomNetworkDelegate::SetListenerInIO(
+    EventTypes type,
+    scoped_ptr<base::DictionaryValue> filter,
+    const Listener& callback) {
+  if (callback.is_null()) {
+    event_listener_map_.erase(type);
+    return;
+  }
+
+  ListenerInfo info;
+  info.callback = callback;
+
+  const base::ListValue* url_list = nullptr;
+  if (filter->GetList("urls", &url_list)) {
+    for (size_t i = 0; i < url_list->GetSize(); ++i) {
+      std::string url;
+      extensions::URLPattern pattern;
+      if (url_list->GetString(i, &url) &&
+          pattern.Parse(url) == extensions::URLPattern::PARSE_SUCCESS) {
+        info.url_patterns.insert(pattern);
+      }
+    }
+  }
+
+  event_listener_map_[type] = info;
+}
+
+int AtomNetworkDelegate::OnBeforeURLRequest(
+    net::URLRequest* request,
+    const net::CompletionCallback& callback,
+    GURL* new_url) {
+  auto listener_info = event_listener_map_.find(kOnBeforeRequest);
+  if (listener_info != event_listener_map_.end()) {
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return net::OK;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+
+    BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
+        base::Bind(&RunListener, wrapped_callback, base::Passed(&details)),
+        base::Bind(&OnBeforeURLRequestResponse,
+                   callback, new_url));
+
+    return net::ERR_IO_PENDING;
+  }
+
+  return brightray::NetworkDelegate::OnBeforeURLRequest(request,
+                                                        callback,
+                                                        new_url);
+}
+
+int AtomNetworkDelegate::OnBeforeSendHeaders(
+    net::URLRequest* request,
+    const net::CompletionCallback& callback,
+    net::HttpRequestHeaders* headers) {
+  auto listener_info = event_listener_map_.find(kOnBeforeSendHeaders);
+  if (listener_info != event_listener_map_.end()) {
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return net::OK;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->Set("requestHeaders", GetRequestHeadersDict(*headers).release());
+
+    BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
+        base::Bind(&RunListener, wrapped_callback, base::Passed(&details)),
+        base::Bind(&OnBeforeSendHeadersResponse,
+                   callback, headers));
+
+    return net::ERR_IO_PENDING;
+  }
+
+  return brightray::NetworkDelegate::OnBeforeSendHeaders(request,
+                                                         callback,
+                                                         headers);
+}
+
+void AtomNetworkDelegate::OnSendHeaders(
+    net::URLRequest* request,
+    const net::HttpRequestHeaders& headers) {
+  auto listener_info = event_listener_map_.find(kOnSendHeaders);
+  if (listener_info != event_listener_map_.end()) {
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->Set("requestHeaders", GetRequestHeadersDict(headers).release());
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(base::IgnoreResult(&RunListener),
+                                       wrapped_callback,
+                                       base::Passed(&details)));
+  } else {
+    brightray::NetworkDelegate::OnSendHeaders(request, headers);
+  }
+}
+
+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_.find(kOnHeadersReceived);
+  if (listener_info != event_listener_map_.end()) {
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return net::OK;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->SetString("statusLine",
+                       original_response_headers->GetStatusLine());
+    details->SetInteger("statusCode",
+                        original_response_headers->response_code());
+    details->Set("responseHeaders",
+                 GetResponseHeadersDict(original_response_headers).release());
+
+    BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
+        base::Bind(&RunListener, wrapped_callback, base::Passed(&details)),
+        base::Bind(&OnHeadersReceivedResponse,
+                   callback,
+                   original_response_headers,
+                   override_response_headers));
+
+    return net::ERR_IO_PENDING;
+  }
+
+  return brightray::NetworkDelegate::OnHeadersReceived(
+      request, callback, original_response_headers, override_response_headers,
+      allowed_unsafe_redirect_url);
+}
+
+void AtomNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
+                                            const GURL& new_location) {
+  auto listener_info = event_listener_map_.find(kOnBeforeRedirect);
+  if (listener_info != event_listener_map_.end()) {
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->SetString("redirectURL", new_location.spec());
+    details->SetInteger("statusCode", request->GetResponseCode());
+    auto ip = request->GetSocketAddress().host();
+    if (!ip.empty())
+      details->SetString("ip", ip);
+    details->SetBoolean("fromCache", request->was_cached());
+    details->Set("responseHeaders",
+                 GetResponseHeadersDict(request->response_headers()).release());
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(base::IgnoreResult(&RunListener),
+                                       wrapped_callback,
+                                       base::Passed(&details)));
+  } else {
+    brightray::NetworkDelegate::OnBeforeRedirect(request, new_location);
+  }
+}
+
+void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
+  auto listener_info = event_listener_map_.find(kOnResponseStarted);
+  if (listener_info != event_listener_map_.end()) {
+    if (request->status().status() != net::URLRequestStatus::SUCCESS)
+      return;
+
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->Set("responseHeaders",
+                 GetResponseHeadersDict(request->response_headers()).release());
+    details->SetBoolean("fromCache", request->was_cached());
+
+    auto response_headers = request->response_headers();
+    details->SetInteger("statusCode",
+                        response_headers ?
+                            response_headers->response_code() : 200);
+    details->SetString("statusLine",
+                       response_headers ?
+                          response_headers->GetStatusLine() : std::string());
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(base::IgnoreResult(&RunListener),
+                                       wrapped_callback,
+                                       base::Passed(&details)));
+  } else {
+    brightray::NetworkDelegate::OnResponseStarted(request);
+  }
+}
+
+void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
+  auto listener_info = event_listener_map_.find(kOnCompleted);
+  if (listener_info != event_listener_map_.end()) {
+    if (request->status().status() == net::URLRequestStatus::FAILED ||
+        request->status().status() == net::URLRequestStatus::CANCELED) {
+      OnErrorOccurred(request);
+      return;
+    } else {
+      bool is_redirect = request->response_headers() &&
+          net::HttpResponseHeaders::IsRedirectResponseCode(
+              request->response_headers()->response_code());
+      if (is_redirect)
+        return;
+    }
+
+    if (!MatchesFilterCondition(request, listener_info->second))
+      return;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->Set("responseHeaders",
+                 GetResponseHeadersDict(request->response_headers()).release());
+    details->SetBoolean("fromCache", request->was_cached());
+
+    auto response_headers = request->response_headers();
+    details->SetInteger("statusCode",
+                        response_headers ?
+                            response_headers->response_code() : 200);
+    details->SetString("statusLine",
+                       response_headers ?
+                          response_headers->GetStatusLine() : std::string());
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(base::IgnoreResult(&RunListener),
+                                       wrapped_callback,
+                                       base::Passed(&details)));
+  } else {
+    brightray::NetworkDelegate::OnCompleted(request, started);
+  }
+}
+
+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;
+
+    auto wrapped_callback = listener_info->second.callback;
+    auto details = ExtractRequestInfo(request);
+    details->SetBoolean("fromCache", request->was_cached());
+    details->SetString("error", net::ErrorToString(request->status().error()));
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(base::IgnoreResult(&RunListener),
+                                       wrapped_callback,
+                                       base::Passed(&details)));
+  }
+}
+
+}  // namespace atom

atom/browser/net/atom_network_delegate.h

@@ -0,0 +1,101 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NET_ATOM_NETWORK_DELEGATE_H_
+#define ATOM_BROWSER_NET_ATOM_NETWORK_DELEGATE_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "brightray/browser/network_delegate.h"
+#include "base/callback.h"
+#include "base/values.h"
+#include "extensions/common/url_pattern.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+
+namespace extensions {
+class URLPattern;
+}
+
+namespace atom {
+
+class AtomNetworkDelegate : public brightray::NetworkDelegate {
+ public:
+  struct BlockingResponse;
+  using Listener =
+      base::Callback<BlockingResponse(const base::DictionaryValue&)>;
+
+  enum EventTypes {
+    kInvalidEvent = 0,
+    kOnBeforeRequest = 1 << 0,
+    kOnBeforeSendHeaders = 1 << 1,
+    kOnSendHeaders = 1 << 2,
+    kOnHeadersReceived = 1 << 3,
+    kOnBeforeRedirect = 1 << 4,
+    kOnResponseStarted = 1 << 5,
+    kOnCompleted = 1 << 6,
+    kOnErrorOccurred = 1 << 7,
+  };
+
+  struct ListenerInfo {
+    std::set<extensions::URLPattern> url_patterns;
+    AtomNetworkDelegate::Listener callback;
+  };
+
+  struct BlockingResponse {
+    BlockingResponse() : cancel(false) {}
+    ~BlockingResponse() {}
+
+    int Code() const {
+      return cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK;
+    }
+
+    bool cancel;
+    GURL redirect_url;
+    net::HttpRequestHeaders request_headers;
+    scoped_refptr<net::HttpResponseHeaders> response_headers;
+  };
+
+  AtomNetworkDelegate();
+  ~AtomNetworkDelegate() override;
+
+  void SetListenerInIO(EventTypes type,
+                       scoped_ptr<base::DictionaryValue> filter,
+                       const Listener& callback);
+
+ protected:
+  void OnErrorOccurred(net::URLRequest* request);
+
+  // net::NetworkDelegate:
+  int OnBeforeURLRequest(net::URLRequest* request,
+                         const net::CompletionCallback& callback,
+                         GURL* new_url) override;
+  int OnBeforeSendHeaders(net::URLRequest* request,
+                          const net::CompletionCallback& callback,
+                          net::HttpRequestHeaders* headers) override;
+  void OnSendHeaders(net::URLRequest* request,
+                     const net::HttpRequestHeaders& headers) override;
+  int 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) override;
+  void OnBeforeRedirect(net::URLRequest* request,
+                        const GURL& new_location) override;
+  void OnResponseStarted(net::URLRequest* request) override;
+  void OnCompleted(net::URLRequest* request, bool started) override;
+
+ private:
+  std::map<EventTypes, ListenerInfo> event_listener_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomNetworkDelegate);
+};
+
+}   // namespace atom
+
+#endif  // ATOM_BROWSER_NET_ATOM_NETWORK_DELEGATE_H_