http: use arrow fns for lexical this in Agent

PR-URL: #16475
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Yuta Hiroto <hello@about-hiroppy.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

lib/_http_agent.js

@@ -46,33 +46,31 @@ function Agent(options) {
 
   EventEmitter.call(this);
 
-  var self = this;
+  this.defaultPort = 80;
+  this.protocol = 'http:';
 
-  self.defaultPort = 80;
-  self.protocol = 'http:';
-
-  self.options = util._extend({}, options);
+  this.options = util._extend({}, options);
 
   // don't confuse net and make it think that we're connecting to a pipe
-  self.options.path = null;
-  self.requests = {};
-  self.sockets = {};
-  self.freeSockets = {};
-  self.keepAliveMsecs = self.options.keepAliveMsecs || 1000;
-  self.keepAlive = self.options.keepAlive || false;
-  self.maxSockets = self.options.maxSockets || Agent.defaultMaxSockets;
-  self.maxFreeSockets = self.options.maxFreeSockets || 256;
-
-  self.on('free', function(socket, options) {
-    var name = self.getName(options);
+  this.options.path = null;
+  this.requests = {};
+  this.sockets = {};
+  this.freeSockets = {};
+  this.keepAliveMsecs = this.options.keepAliveMsecs || 1000;
+  this.keepAlive = this.options.keepAlive || false;
+  this.maxSockets = this.options.maxSockets || Agent.defaultMaxSockets;
+  this.maxFreeSockets = this.options.maxFreeSockets || 256;
+
+  this.on('free', (socket, options) => {
+    var name = this.getName(options);
     debug('agent.on(free)', name);
 
     if (socket.writable &&
-        self.requests[name] && self.requests[name].length) {
-      self.requests[name].shift().onSocket(socket);
-      if (self.requests[name].length === 0) {
+        this.requests[name] && this.requests[name].length) {
+      this.requests[name].shift().onSocket(socket);
+      if (this.requests[name].length === 0) {
         // don't leak
-        delete self.requests[name];
+        delete this.requests[name];
       }
     } else {
       // If there are no pending requests, then put it in
@@ -81,21 +79,21 @@ function Agent(options) {
       if (req &&
           req.shouldKeepAlive &&
           socket.writable &&
-          self.keepAlive) {
-        var freeSockets = self.freeSockets[name];
+          this.keepAlive) {
+        var freeSockets = this.freeSockets[name];
         var freeLen = freeSockets ? freeSockets.length : 0;
         var count = freeLen;
-        if (self.sockets[name])
-          count += self.sockets[name].length;
+        if (this.sockets[name])
+          count += this.sockets[name].length;
 
-        if (count > self.maxSockets || freeLen >= self.maxFreeSockets) {
+        if (count > this.maxSockets || freeLen >= this.maxFreeSockets) {
           socket.destroy();
-        } else if (self.keepSocketAlive(socket)) {
+        } else if (this.keepSocketAlive(socket)) {
           freeSockets = freeSockets || [];
-          self.freeSockets[name] = freeSockets;
+          this.freeSockets[name] = freeSockets;
           socket[async_id_symbol] = -1;
           socket._httpMessage = null;
-          self.removeSocket(socket, options);
+          this.removeSocket(socket, options);
           freeSockets.push(socket);
         } else {
           // Implementation doesn't want to keep socket alive
@@ -196,39 +194,39 @@ Agent.prototype.addRequest = function addRequest(req, options, port/*legacy*/,
 };
 
 Agent.prototype.createSocket = function createSocket(req, options, cb) {
-  var self = this;
   options = util._extend({}, options);
-  util._extend(options, self.options);
+  util._extend(options, this.options);
   if (options.socketPath)
     options.path = options.socketPath;
 
   if (!options.servername)
     options.servername = calculateServerName(options, req);
 
-  var name = self.getName(options);
+  var name = this.getName(options);
   options._agentKey = name;
 
   debug('createConnection', name, options);
   options.encoding = null;
   var called = false;
-  const newSocket = self.createConnection(options, oncreate);
-  if (newSocket)
-    oncreate(null, newSocket);
 
-  function oncreate(err, s) {
+  const oncreate = (err, s) => {
     if (called)
       return;
     called = true;
     if (err)
       return cb(err);
-    if (!self.sockets[name]) {
-      self.sockets[name] = [];
+    if (!this.sockets[name]) {
+      this.sockets[name] = [];
     }
-    self.sockets[name].push(s);
-    debug('sockets', name, self.sockets[name].length);
-    installListeners(self, s, options);
+    this.sockets[name].push(s);
+    debug('sockets', name, this.sockets[name].length);
+    installListeners(this, s, options);
     cb(null, s);
-  }
+  };
+
+  const newSocket = this.createConnection(options, oncreate);
+  if (newSocket)
+    oncreate(null, newSocket);
 };
 
 function calculateServerName(options, req) {