Refactoring net module, adding a ClientRequest and IncomingMessage classes.

atom/browser/api/atom_api_url_request.cc

@@ -115,8 +115,6 @@ mate::WrappableBase* URLRequest::New(mate::Arguments* args) {
   auto session = Session::FromPartition(args->isolate(), session_name);
 
   auto browser_context = session->browser_context();
-
-
   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(
@@ -126,12 +124,10 @@ mate::WrappableBase* URLRequest::New(mate::Arguments* args) {
     weak_ptr);
   
   api_url_request->atom_request_ = atom_url_request;
-  
 
   return api_url_request;
 }
 
-
 // static
 void URLRequest::BuildPrototype(v8::Isolate* isolate,
                                 v8::Local<v8::FunctionTemplate> prototype) {
@@ -139,17 +135,17 @@ void URLRequest::BuildPrototype(v8::Isolate* isolate,
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
     // Request API
     .MakeDestroyable()
-    .SetMethod("_writeBuffer", &URLRequest::WriteBuffer)
+    .SetMethod("writeBuffer", &URLRequest::WriteBuffer)
     .SetMethod("abort", &URLRequest::Abort)
-    .SetMethod("_setHeader", &URLRequest::SetHeader)
+    .SetMethod("setExtraHeader", &URLRequest::SetExtraHeader)
-    .SetMethod("_getHeader", &URLRequest::GetHeader)
+    .SetMethod("removeExtraHeader", &URLRequest::RemoveExtraHeader)
-    .SetMethod("_removaHeader", &URLRequest::RemoveHeader)
+    .SetMethod("setChunkedUpload", &URLRequest::SetChunkedUpload)
     // Response APi
-    .SetProperty("_statusCode", &URLRequest::StatusCode)
+    .SetProperty("statusCode", &URLRequest::StatusCode)
-    .SetProperty("_statusMessage", &URLRequest::StatusMessage)
+    .SetProperty("statusMessage", &URLRequest::StatusMessage)
-    .SetProperty("_rawResponseHeaders", &URLRequest::RawResponseHeaders)
+    .SetProperty("rawResponseHeaders", &URLRequest::RawResponseHeaders)
-    .SetProperty("_httpVersionMajor", &URLRequest::ResponseHttpVersionMajor)
+    .SetProperty("httpVersionMajor", &URLRequest::ResponseHttpVersionMajor)
-    .SetProperty("_httpVersionMinor", &URLRequest::ResponseHttpVersionMinor);
+    .SetProperty("httpVersionMinor", &URLRequest::ResponseHttpVersionMinor);
   
     
 }
@@ -166,7 +162,7 @@ void URLRequest::Abort() {
   atom_request_->Abort();
 }
 
-bool URLRequest::SetHeader(const std::string& name,
+bool URLRequest::SetExtraHeader(const std::string& name,
                            const std::string& value) {
   if (!net::HttpUtil::IsValidHeaderName(name)) {
     return false;
@@ -176,14 +172,16 @@ bool URLRequest::SetHeader(const std::string& name,
     return false;
   }
 
-  atom_request_->SetHeader(name, value);
+  atom_request_->SetExtraHeader(name, value);
   return true;
 }
-std::string URLRequest::GetHeader(const std::string& name) {
+
-  return atom_request_->GetHeader(name);
+void URLRequest::RemoveExtraHeader(const std::string& name) {
+  atom_request_->RemoveExtraHeader(name);
 }
-void URLRequest::RemoveHeader(const std::string& name) {
+
-  atom_request_->RemoveHeader(name);
+void URLRequest::SetChunkedUpload(bool is_chunked_upload) {
+  atom_request_->SetChunkedUpload(is_chunked_upload);
 }
 
 void URLRequest::OnAuthenticationRequired(
@@ -196,7 +194,7 @@ void URLRequest::OnAuthenticationRequired(
  
 
 void URLRequest::OnResponseStarted() {
-  EmitRequestEvent("response");
+  Emit("response");
 }
 
 void URLRequest::OnResponseData(

atom/browser/api/atom_api_url_request.h

@@ -35,9 +35,9 @@ private:
   bool WriteBuffer(scoped_refptr<const net::IOBufferWithSize> buffer,
                    bool is_last);
   void Abort();
-  bool SetHeader(const std::string& name, const std::string& value);
+  bool SetExtraHeader(const std::string& name, const std::string& value);
-  std::string GetHeader(const std::string& name);
+  void RemoveExtraHeader(const std::string& name);
-  void RemoveHeader(const std::string& name);
+  void SetChunkedUpload(bool is_chunked_upload);
 
   friend class AtomURLRequest;
   void OnAuthenticationRequired(

atom/browser/net/atom_url_request.cc

@@ -95,13 +95,13 @@ bool AtomURLRequest::WriteBuffer(
       base::Bind(&AtomURLRequest::DoWriteBuffer, this, buffer, is_last));
 }
 
-void AtomURLRequest::SetChunkedUpload() {
+void AtomURLRequest::SetChunkedUpload(bool is_chunked_upload) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // The method can be called only before switching to multi-threaded mode,
   // i.e. before the first call to write.
   // So it is safe to change the object in the UI thread.
-  is_chunked_upload_ = true;
+  is_chunked_upload_ = is_chunked_upload;
 }
 
 
@@ -109,26 +109,14 @@ void AtomURLRequest::Abort() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
-void AtomURLRequest::SetHeader(const std::string& name,
+void AtomURLRequest::SetExtraHeader(const std::string& name,
                                const std::string& value) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   request_->SetExtraRequestHeaderByName(name, value, true);
 }
 
-std::string AtomURLRequest::GetHeader(const std::string& name) const {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  std::string result;
-  const auto& extra_headers = request_->extra_request_headers();
-  if (!extra_headers.GetHeader(name, &result)) {
-    net::HttpRequestHeaders* request_headers = nullptr;
-    if (request_->GetFullRequestHeaders(request_headers) && request_headers) {
-      request_headers->GetHeader(name, &result);
-    }
-  }
-  return result;
-}
 
-void AtomURLRequest::RemoveHeader(const std::string& name) const {
+void AtomURLRequest::RemoveExtraHeader(const std::string& name) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   request_->RemoveRequestHeaderByName(name);
 }

atom/browser/net/atom_url_request.h

@@ -36,11 +36,10 @@ public:
 
   bool WriteBuffer(scoped_refptr<const net::IOBufferWithSize> buffer,
                    bool is_last);
-  void SetChunkedUpload();
+  void SetChunkedUpload(bool is_chunked_upload);
   void Abort() const;
-  void SetHeader(const std::string& name, const std::string& value) const;
+  void SetExtraHeader(const std::string& name, const std::string& value) const;
-  std::string GetHeader(const std::string& name) const;
+  void RemoveExtraHeader(const std::string& name) const;
-  void RemoveHeader(const std::string& name) const;
   void PassLoginInformation(const base::string16& username,
     const base::string16& password) const;
   scoped_refptr<const net::HttpResponseHeaders> GetResponseHeaders() const;

lib/browser/api/net.js

@@ -8,22 +8,22 @@ const {URLRequest} = net
 Object.setPrototypeOf(Net.prototype, EventEmitter.prototype)
 Object.setPrototypeOf(URLRequest.prototype, EventEmitter.prototype)
 
-class URLResponse extends EventEmitter {
+class IncomingMessage extends EventEmitter {
-  constructor(request) {
+  constructor(url_request) {
     super();
-    this.request = request;
+    this._url_request = url_request;
   }
 
   get statusCode() {
-    return this.request._statusCode;
+    return this._url_request.statusCode;
   }
 
   get statusMessage() {
-    return this.request._statusMessage;
+    return this._url_request.statusMessage;
   }
 
   get headers() {
-    return this.request._rawResponseHeaders;
+    return this._url_request.rawResponseHeaders;
   }
 
   get httpVersion() {
@@ -31,161 +31,195 @@ class URLResponse extends EventEmitter {
   }
 
   get httpVersionMajor() {
-    return this.request._httpVersionMajor;
+    return this._url_request.httpVersionMajor;
   }
 
   get httpVersionMinor() {
-    return this.request._httpVersionMinor;
+    return this._url_request.httpVersionMinor;
   }
 
   get rawHeaders() {
-    return this.request._rawResponseHeaders;
+    return this._url_request.rawResponseHeaders;
   }
 
 }
 
-Net.prototype.request = function(options, callback) {
+URLRequest.prototype._emitRequestEvent = function() {
-  let request = new URLRequest(options)
+  this._request.emit.apply(this._request, arguments);
-
-  if (callback) {
-    request.once('response', callback)
-  }
-
-
-  return request
-}
-
-URLRequest.prototype._init = function() {
-  // Flag to prevent writings after end.
-  this._finished = false; 
-
-  // Set when the request uses chuned encoding. Can be switched
-  // to true only once and never set back to false.
-  this._chunkedEncoding = false;
-
-  // Flag to prevent request's headers modifications after 
-  // headers flush.
-  this._headersSent = false; 
-}
-
-
-URLRequest.prototype.setHeader = function(name, value) {
-  if (typeof name !== 'string')
-    throw new TypeError('`name` should be a string in setHeader(name, value).');
-  if (value === undefined)
-    throw new Error('`value` required in setHeader("' + name + '", value).');
-  if (this._headersSent)
-    throw new Error('Can\'t set headers after they are sent.');
-
-  this._setHeader(name, value)
-};
-
-
-URLRequest.prototype.getHeader = function(name) {
-  if (arguments.length < 1) {
-    throw new Error('`name` is required for getHeader(name).');
-  }
-
-  return this._getHeader(name);
-};
-
-
-URLRequest.prototype.removeHeader = function(name) {
-  if (arguments.length < 1) {
-    throw new Error('`name` is required for removeHeader(name).');
-  }
-
-  if (this._headersSent) {
-    throw new Error('Can\'t remove headers after they are sent.');
-  }
-
-  this._removeHeader(name);
-};
-
-
-URLRequest.prototype._emitRequestEvent = function(name) {
-  if (name === 'response') {
-    this.response = new URLResponse(this);
-    this.emit(name, this.response);
-  } else {
-    this.emit.apply(this, arguments);
-  }
 }
 
 URLRequest.prototype._emitResponseEvent = function() {
-  this.response.emit.apply(this.response, arguments);
+  this._response.emit.apply(this._response, arguments);
 }
 
+class ClientRequest extends EventEmitter {
 
-URLRequest.prototype._write = function(chunk, encoding, callback, is_last) {
+  constructor(options, callback) {
+    super();
+
+    // Flag to prevent writings after end.
+    this._finished = false; 
+
+    // Set when the request uses chuned encoding. Can be switched
+    // to true only once and never set back to false.
+    this._chunkedEncoding = false;
+
+    // Flag to prevent request's headers modifications after 
+    // headers flush.
+    this._headersSent = false; 
+
+    // This is a copy of the extra headers structure held by the native
+    // net::URLRequest. The main reason is to keep the getHeader API synchronous
+    // after the request starts.
+    this._extra_headers = {};
+
+    let url = options.url;
+    let method = options.method;
+    let session = options.session;
+
+    let url_request = new URLRequest({
+      url: url,
+      method: method,
+      session: session
+    });
+
+    this._url_request = url_request;
+    url_request._request = this;
+
+    url_request.on('response', ()=> {
+      let response = new IncomingMessage(url_request);
+      url_request._response = response;
+      this.emit('response', response);
+    });
+
+    if (callback) {
+      this.once('response', callback)
+    }
+  }
+
+
+  setHeader(name, value) {
+    if (typeof name !== 'string')
+      throw new TypeError('`name` should be a string in setHeader(name, value).');
+    if (value === undefined)
+      throw new Error('`value` required in setHeader("' + name + '", value).');
+    if (this._headersSent)
+      throw new Error('Can\'t set headers after they are sent.');
+
+    let key = name.toLowerCase();
+    this._extra_headers[key] = value;
+    this._url_request.setExtraHeader(name, value)
+  }
+
+
+  getHeader(name) {
+    if (arguments.length < 1) {
+      throw new Error('`name` is required for getHeader(name).');
+    }
+
+    if (!this._extra_headers) {
+      return;
+    }
+
+    var key = name.toLowerCase();
+    return this._extra_headers[key];
+  }
+
+
+  removeHeader(name) {
+    if (arguments.length < 1) {
+      throw new Error('`name` is required for removeHeader(name).');
+    }
+
+    if (this._headersSent) {
+      throw new Error('Can\'t remove headers after they are sent.');
+    }
+
+    var key = name.toLowerCase();
+    delete this._extra_headers[key];
+    this._url_request.removeExtraHeader(name);
+  }
+
+
+  _write(chunk, encoding, callback, is_last) {
   
-  let chunk_is_string = typeof chunk === 'string';
+    let chunk_is_string = typeof chunk === 'string';
-  let chunk_is_buffer = chunk instanceof Buffer;
+    let chunk_is_buffer = chunk instanceof Buffer;
-  if (!chunk_is_string && !chunk_is_buffer) {
+    if (!chunk_is_string && !chunk_is_buffer) {
-    throw new TypeError('First argument must be a string or Buffer.');
+      throw new TypeError('First argument must be a string or Buffer.');
+    }
+
+    if (chunk_is_string) {
+      // We convert all strings into binary buffers.
+      chunk = Buffer.from(chunk, encoding);
+    }
+
+    // Headers are assumed to be sent on first call to _writeBuffer,
+    // i.e. after the first call to write or end.
+    let result = this._url_request.writeBuffer(chunk, is_last);
+
+    // Since writing to the network is asynchronous, we conservatively 
+    // assume that request headers are written after delivering the first
+    // buffer to the network IO thread.
+    if (!this._headersSent) {
+      this._url_request.setChunkedUpload(this._chunkedEncoding);
+      this._headersSent = true;
+    }
+
+    // The write callback is fired asynchronously to mimic Node.js.
+    if (callback) {
+      process.nextTick(callback);
+    }
+
+    return result;
   }
 
-  if (chunk_is_string) {
+  write(data, encoding, callback) {
-    // We convert all strings into binary buffers.
+   
-    chunk = Buffer.from(chunk, encoding);
+    if (this._finished) {
+      let error = new Error('Write after end.');
+      process.nextTick(writeAfterEndNT, this, error, callback);
+      return true;
+    }
+
+    return this._write(data, encoding, callback, false);
   }
 
-  // Headers are assumed to be sent on first call to _writeBuffer,
-  // i.e. after the first call to write or end.
-  let result = this._writeBuffer(chunk, is_last);
 
-  // Since writing to the network is asynchronous, we conservatively 
+  end(data, encoding, callback) {
-  // assume that request headers are written after delivering the first
+    if (this._finished) {
-  // buffer to the network IO thread.
+      return false;
-  this._headersSent = true;
+    }
+   
+    this._finished = true;
 
-  // The write callback is fired asynchronously to mimic Node.js.
+    if (typeof data === 'function') {
-  if (callback) {
+      callback = data;
-    process.nextTick(callback);
+      encoding = null;
+      data = null;
+    } else if (typeof encoding === 'function') {
+      callback = encoding;
+      encoding = null;
+    }
+
+    data = data || '';
+
+    return this._write(data, encoding, callback, true);
   }
 
-  return result;
 }
 
-URLRequest.prototype.write = function(data, encoding, callback) {
-   
-  if (this._finished) {
-    let error = new Error('Write after end.');
-    process.nextTick(writeAfterEndNT, this, error, callback);
-    return true;
-  }
-
-  return this._write(data, encoding, callback, false);
-};
-
-
-URLRequest.prototype.end = function(data, encoding, callback) {
-  if (this._finished) {
-    return false;
-  }
-   
-  this._finished = true;
-
-  if (typeof data === 'function') {
-    callback = data;
-    encoding = null;
-    data = null;
-  } else if (typeof encoding === 'function') {
-    callback = encoding;
-    encoding = null;
-  }
-
-  data = data || '';
-
-  return this._write(data, encoding, callback, true);
-};
-
-
 function writeAfterEndNT(self, error, callback) {
   self.emit('error', error);
   if (callback) callback(error);
 }
 
 
+Net.prototype.request = function(options, callback) {
+  return new ClientRequest(options, callback);
+}
+
+net.ClientRequest = ClientRequest;
+
 module.exports = net