Implementing URLRequest API, getting response body.

atom/browser/api/atom_api_menu.cc

@@ -191,8 +191,7 @@ 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::thehub
-    SetConstructor(isolate, base::Bind(&Menu::New));
+  Menu::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

@@ -7,12 +7,49 @@
 
 #include "native_mate/dictionary.h"
 #include "atom/browser/net/atom_url_request.h"
+#include "atom/common/node_includes.h"
 
+namespace {
 
+const char* const kResponse = "response";
+const char* const kData = "data";
+const char* const kEnd = "end";
+
+}
+namespace mate {
+
+template<>
+struct Converter<scoped_refptr<net::HttpResponseHeaders>> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+    scoped_refptr<net::HttpResponseHeaders> val) {
+
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+    if (val) {
+      size_t iter = 0;
+      std::string name;
+      std::string value;
+      while (val->EnumerateHeaderLines(&iter, &name, &value)) {
+        dict.Set(name, value);
+      }  
+    }
+    return dict.GetHandle();
+  }
+};
+
+template<>
+struct Converter<scoped_refptr<net::IOBufferWithSize>> {
+  static v8::Local<v8::Value> ToV8(
+    v8::Isolate* isolate,
+    scoped_refptr<net::IOBufferWithSize> buffer) {
+      return node::Buffer::Copy(isolate, buffer->data(), buffer->size()).ToLocalChecked();
+  }
+};
+
+}
 namespace atom {
 
 namespace api {
-  
+
 URLRequest::URLRequest(v8::Isolate* isolate, 
                        v8::Local<v8::Object> wrapper)
   : weak_ptr_factory_(this) {
@@ -69,8 +106,11 @@ void URLRequest::BuildPrototype(v8::Isolate* isolate,
     // Response APi
     .SetProperty("statusCode", &URLRequest::StatusCode)
     .SetProperty("statusMessage", &URLRequest::StatusMessage)
-    .SetProperty("responseHeaders", &URLRequest::ResponseHeaders)
-    .SetProperty("responseHttpVersion", &URLRequest::ResponseHttpVersion);
+    .SetProperty("rawResponseHeaders", &URLRequest::RawResponseHeaders)
+    .SetProperty("httpVersionMajor", &URLRequest::ResponseHttpVersionMajor)
+    .SetProperty("httpVersionMinor", &URLRequest::ResponseHttpVersionMinor);
+  
+    
 }
 
 void URLRequest::Write() {
@@ -98,35 +138,71 @@ void URLRequest::RemoveHeader() {
 
 
 void URLRequest::OnResponseStarted() {
-  v8::Local<v8::Function> _emitResponse;
+  //v8::Local<v8::Function> _emitResponse;
 
-  auto wrapper = GetWrapper();
-  if (mate::Dictionary(isolate(), wrapper).Get("_emitResponse", &_emitResponse))
-    _emitResponse->Call(wrapper, 0, nullptr);
+  //auto wrapper = GetWrapper();
+  //if (mate::Dictionary(isolate(), wrapper).Get("_emitResponse", &_emitResponse))
+  //  _emitResponse->Call(wrapper, 0, nullptr);
+  EmitRequestEvent("response");
 }
 
-void URLRequest::OnResponseData() {
-  Emit("data");
+void URLRequest::OnResponseData(scoped_refptr<net::IOBufferWithSize> buffer) {
+  if (!buffer || !buffer->data() || !buffer->size()) {
+    return;
+  }
+
+  EmitResponseEvent("data", buffer);
+  //v8::Local<v8::Function> _emitData;
+  //auto data = mate::ConvertToV8(isolate(), buffer);
+
+  //auto wrapper = GetWrapper();
+  //if (mate::Dictionary(isolate(), wrapper).Get("_emitData", &_emitData))
+  //  _emitData->Call(wrapper, 1, &data);
 }
 
-void URLRequest::OnResponseEnd() {
-  Emit("end");
+void URLRequest::OnResponseCompleted() {
+
+  //v8::Local<v8::Function> _emitEnd;
+
+  //auto wrapper = GetWrapper();
+  //if (mate::Dictionary(isolate(), wrapper).Get("_emitEnd", &_emitEnd))
+  //  _emitEnd->Call(wrapper, 0, nullptr);
+
+  EmitResponseEvent("end");
 }
 
+
 int URLRequest::StatusCode() {
-  return atom_url_request_->StatusCode();
+  if (auto response_headers = atom_url_request_->GetResponseHeaders()) {
+    return response_headers->response_code();
+  }
+  return -1;
 }
 
-void URLRequest::StatusMessage() {
-  return atom_url_request_->StatusMessage();
+std::string URLRequest::StatusMessage() {
+  std::string result;
+  if (auto response_headers = atom_url_request_->GetResponseHeaders()) {
+    result = response_headers->GetStatusText();
+  }
+  return result;
 }
 
-void URLRequest::ResponseHeaders() {
-  return atom_url_request_->ResponseHeaders();
+scoped_refptr<net::HttpResponseHeaders> URLRequest::RawResponseHeaders() {
+	return atom_url_request_->GetResponseHeaders();
 }
 
-void URLRequest::ResponseHttpVersion() {
-  return atom_url_request_->ResponseHttpVersion();
+uint32_t URLRequest::ResponseHttpVersionMajor() {
+  if (auto response_headers = atom_url_request_->GetResponseHeaders()) {
+     return response_headers->GetHttpVersion().major_value();
+  }
+  return 0;
+}
+
+uint32_t URLRequest::ResponseHttpVersionMinor() {
+  if (auto response_headers = atom_url_request_->GetResponseHeaders()) {
+    return response_headers->GetHttpVersion().minor_value();
+  }
+  return 0;
 }
 
 void URLRequest::pin() {

atom/browser/api/atom_api_url_request.h

@@ -5,9 +5,12 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_URL_REQUEST_H_
 #define ATOM_BROWSER_API_ATOM_API_URL_REQUEST_H_
 
+#include <array>
 #include "atom/browser/api/trackable_object.h"
 #include "native_mate/handle.h"
 #include "net/url_request/url_request_context.h"
+#include "net/http/http_response_headers.h"
+
 
 namespace atom {
 
@@ -38,13 +41,26 @@ private:
 
   friend class AtomURLRequest;
   void OnResponseStarted();
-  void OnResponseData();
-  void OnResponseEnd();
+  void OnResponseData(scoped_refptr<net::IOBufferWithSize> data);
+  void OnResponseCompleted();
 
   int StatusCode();
-  void StatusMessage();
-  void ResponseHeaders();
-  void ResponseHttpVersion();
+  std::string StatusMessage();
+  scoped_refptr<net::HttpResponseHeaders> RawResponseHeaders();
+  uint32_t ResponseHttpVersionMajor();
+  uint32_t ResponseHttpVersionMinor();
+
+
+  template <typename ... ArgTypes>
+  std::array<v8::Local<v8::Value>, sizeof...(ArgTypes)> 
+  BuildArgsArray(ArgTypes... args);
+
+  template <typename ... ArgTypes>
+  void EmitRequestEvent(ArgTypes... args);
+
+  template <typename ... ArgTypes>
+  void EmitResponseEvent(ArgTypes... args);
+
 
 
   void pin();
@@ -53,10 +69,41 @@ private:
   scoped_refptr<AtomURLRequest> atom_url_request_;
   v8::Global<v8::Object> wrapper_;
   base::WeakPtrFactory<URLRequest> weak_ptr_factory_;
+  
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
+template <typename ... ArgTypes>
+std::array<v8::Local<v8::Value>, sizeof...(ArgTypes)>
+URLRequest::BuildArgsArray(ArgTypes... args) {
+  std::array<v8::Local<v8::Value>, sizeof...(ArgTypes)> result
+    = { mate::ConvertToV8(isolate(), args)... };
+  return result;
+}
+
+template <typename ... ArgTypes>
+void URLRequest::EmitRequestEvent(ArgTypes... args) {
+  auto arguments = BuildArgsArray(args...);
+  v8::Local<v8::Function> _emitRequestEvent;
+  auto wrapper = GetWrapper();
+  if (mate::Dictionary(isolate(), wrapper).Get("_emitRequestEvent", &_emitRequestEvent))
+    _emitRequestEvent->Call(wrapper, arguments.size(), arguments.data());
+}
+
+
+template <typename ... ArgTypes>
+void URLRequest::EmitResponseEvent(ArgTypes... args) {
+  auto arguments = BuildArgsArray(args...);
+  v8::Local<v8::Function> _emitResponseEvent;
+  auto wrapper = GetWrapper();
+  if (mate::Dictionary(isolate(), wrapper).Get("_emitResponseEvent", &_emitResponseEvent))
+    _emitResponseEvent->Call(wrapper, arguments.size(), arguments.data());
+}
+
+
+
+
 }  // namepsace api
 
 }  // namepsace atom