Adding URLResponse to emit response events, implementing status code.

atom/browser/api/atom_api_menu.cc

@@ -191,7 +191,8 @@ using atom::api::Menu;
 void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context, void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Menu::SetConstructor(isolate, base::Bind(&Menu::New));
+  Menu::thehub
+    SetConstructor(isolate, base::Bind(&Menu::New));
 
   mate::Dictionary dict(isolate, exports);
   dict.Set("Menu", Menu::GetConstructor(isolate)->GetFunction());

atom/browser/api/atom_api_url_request.cc

@@ -39,16 +39,7 @@ mate::WrappableBase* URLRequest::New(mate::Arguments* args) {
 
   auto browser_context = session->browser_context();
 
-  //auto url_request_context_getter = browser_context->url_request_context_getter();
- // auto url_request_context = url_request_context_getter->GetURLRequestContext();
 
-  //auto net_url_request = url_request_context->CreateRequest(GURL(url), 
-                                              //          net::RequestPriority::DEFAULT_PRIORITY, 
-                                               //         nullptr);
- // net_url_request->set_method(method);
-   
- // auto atom_url_request = new URLRequest(args->isolate(), args->GetThis(), net_url_request.release());
-  
   auto api_url_request = new URLRequest(args->isolate(), args->GetThis());
   auto weak_ptr = api_url_request->weak_ptr_factory_.GetWeakPtr();
   auto atom_url_request = AtomURLRequest::create(browser_context, url, weak_ptr);
@@ -67,20 +58,75 @@ void URLRequest::BuildPrototype(v8::Isolate* isolate,
                                 v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "URLRequest"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .MakeDestroyable()
+    // Request API
-      .SetMethod("start", &URLRequest::start);
+    .MakeDestroyable()
+    .SetMethod("write", &URLRequest::Write)
+    .SetMethod("end", &URLRequest::End)
+    .SetMethod("abort", &URLRequest::Abort)
+    .SetMethod("setHeader", &URLRequest::SetHeader)
+    .SetMethod("getHeader", &URLRequest::GetHeader)
+    .SetMethod("removaHeader", &URLRequest::RemoveHeader)
+    // Response APi
+    .SetProperty("statusCode", &URLRequest::StatusCode)
+    .SetProperty("statusMessage", &URLRequest::StatusMessage)
+    .SetProperty("responseHeaders", &URLRequest::ResponseHeaders)
+    .SetProperty("responseHttpVersion", &URLRequest::ResponseHttpVersion);
 }
 
-void URLRequest::start() {
+void URLRequest::Write() {
+  atom_url_request_->Write();
+}
+
+void URLRequest::End() {
   pin();
-  atom_url_request_->Start();
+  atom_url_request_->End();
 }
 
-void URLRequest::stop() {
+void URLRequest::Abort() {
-
+  atom_url_request_->Abort();
 }
+
+void URLRequest::SetHeader() {
+  atom_url_request_->SetHeader();
+}
+void URLRequest::GetHeader() {
+  atom_url_request_->GetHeader();
+}
+void URLRequest::RemoveHeader() {
+  atom_url_request_->RemoveHeader();
+}
+
+
 void URLRequest::OnResponseStarted() {
-  Emit("response-started");
+  v8::Local<v8::Function> _emitResponse;
+
+  auto wrapper = GetWrapper();
+  if (mate::Dictionary(isolate(), wrapper).Get("_emitResponse", &_emitResponse))
+    _emitResponse->Call(wrapper, 0, nullptr);
+}
+
+void URLRequest::OnResponseData() {
+  Emit("data");
+}
+
+void URLRequest::OnResponseEnd() {
+  Emit("end");
+}
+
+int URLRequest::StatusCode() {
+  return atom_url_request_->StatusCode();
+}
+
+void URLRequest::StatusMessage() {
+  return atom_url_request_->StatusMessage();
+}
+
+void URLRequest::ResponseHeaders() {
+  return atom_url_request_->ResponseHeaders();
+}
+
+void URLRequest::ResponseHttpVersion() {
+  return atom_url_request_->ResponseHttpVersion();
 }
 
 void URLRequest::pin() {

atom/browser/api/atom_api_url_request.h

@@ -22,17 +22,31 @@ class URLRequest : public mate::EventEmitter<URLRequest> {
   static void BuildPrototype(v8::Isolate* isolate,
     v8::Local<v8::FunctionTemplate> prototype);
 
-  void start();
-  void stop();
-  void OnResponseStarted();
  protected:
   URLRequest(v8::Isolate* isolate, 
              v8::Local<v8::Object> wrapper);
   ~URLRequest() override;
 
 
+private:
+  void Write();
+  void End();
+  void Abort();
+  void SetHeader();
+  void GetHeader();
+  void RemoveHeader();
+
+  friend class AtomURLRequest;
+  void OnResponseStarted();
+  void OnResponseData();
+  void OnResponseEnd();
+
+  int StatusCode();
+  void StatusMessage();
+  void ResponseHeaders();
+  void ResponseHttpVersion();
+
 
- private:
   void pin();
   void unpin();
 

atom/browser/net/atom_url_request.cc

@@ -23,32 +23,71 @@ scoped_refptr<AtomURLRequest> AtomURLRequest::create(
   const std::string& url,
   base::WeakPtr<api::URLRequest> delegate) {
 
+  DCHECK(browser_context);
+  DCHECK(!url.empty());
 
-  auto url_request_context_getter = browser_context->url_request_context_getter();
+  auto request_context_getter = browser_context->url_request_context_getter();
-  auto url_request_context = url_request_context_getter->GetURLRequestContext();
 
-  auto net_url_request = url_request_context->CreateRequest(GURL(url),
+  DCHECK(request_context_getter);
-    net::RequestPriority::DEFAULT_PRIORITY,
+
-    nullptr);
+  auto context = request_context_getter->GetURLRequestContext();
- // net_url_request->set_method(method);
+
+  DCHECK(context);
 
   scoped_refptr<AtomURLRequest> atom_url_request = new AtomURLRequest(delegate);
 
-  net_url_request->set_delegate(atom_url_request.get());
+  atom_url_request->url_request_ = context->CreateRequest(GURL(url),
-
+    net::RequestPriority::DEFAULT_PRIORITY,
-  atom_url_request->url_request_ = std::move(net_url_request);
+    atom_url_request.get());
 
   return atom_url_request;
 
 }
 
-void AtomURLRequest::Start() {
+void AtomURLRequest::Write() {
+}
+
+void AtomURLRequest::End() {
   // post to io thread
   content::BrowserThread::PostTask(
     content::BrowserThread::IO, FROM_HERE,
     base::Bind(&AtomURLRequest::StartOnIOThread, this));
 }
 
+void AtomURLRequest::Abort() {
+}
+
+void AtomURLRequest::SetHeader() {
+
+}
+
+void AtomURLRequest::GetHeader() {
+
+}
+
+void AtomURLRequest::RemoveHeader() {
+
+}
+
+
+
+
+
+
+int AtomURLRequest::StatusCode() {
+  return url_request_->GetResponseCode();
+}
+
+void AtomURLRequest::StatusMessage() {
+}
+void AtomURLRequest::ResponseHeaders() {
+}
+
+void AtomURLRequest::ResponseHttpVersion() {
+}
+
+
+
 void AtomURLRequest::StartOnIOThread() {
   url_request_->Start();
 }

atom/browser/net/atom_url_request.h

@@ -25,9 +25,20 @@ public:
     const std::string& url,
     base::WeakPtr<api::URLRequest> delegate);
 
-  void Start();
   void set_method(const std::string& method);
 
+  void Write();
+  void End();
+  void Abort();
+  void SetHeader();
+  void GetHeader();
+  void RemoveHeader();
+
+  int StatusCode();
+  void StatusMessage();
+  void ResponseHeaders();
+  void ResponseHttpVersion();
+
 protected:
   // Overrides of net::URLRequest::Delegate
   virtual void OnResponseStarted(net::URLRequest* request) override;

lib/browser/api/net.js

@@ -8,5 +8,47 @@ const {URLRequest} = net
 Object.setPrototypeOf(Net.prototype, EventEmitter.prototype)
 Object.setPrototypeOf(URLRequest.prototype, EventEmitter.prototype)
 
+class URLResponse extends EventEmitter {
+    constructor(request) {
+        super();
+        this.request = request;
+    }
+
+    get statusCode() {
+        return this.request.statusCode;
+    }
+
+    get statusMessage() {
+        return this.request.statusMessage;
+    }
+
+    get headers() {
+        return this.request.responseHeaders;
+    }
+
+    get httpVersion() {
+        return this.request.responseHttpVersion;
+    }
+
+
+
+}
+
+Net.prototype.request = function(options, callback) {
+    let request = new URLRequest(options)
+
+    if (callback) {
+        request.once('response', callback)
+    }
+
+
+    return request
+}
+
+URLRequest.prototype._emitResponse = function() {
+    this.response = new URLResponse(this);
+    this.emit('response', this.response);
+}
+
 module.exports = net