NetLogEventParameter to Callback refactoring 9.

net/socket/tcp_client_socket_libevent.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/tcp_client_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <netinet/tcp.h>
 #if defined(OS_POSIX)
 #include <netinet/in.h>
 #endif
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string_util.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
-#include "net/socket/socket_error_params.h"
+#include "net/socket/socket_net_log_params.h"
 
 namespace net {
 
 namespace {
 
 const int kInvalidSocket = -1;
 const int kTCPKeepAliveSeconds = 45;
 
 // SetTCPNoDelay turns on/off buffering in the kernel. By default, TCP sockets
 // will wait up to 200ms for more data to complete a packet before transmitting.
@@ skipping 93 matching lines @@
       current_address_index_(-1),
       read_watcher_(this),
       write_watcher_(this),
       next_connect_state_(CONNECT_STATE_NONE),
       connect_os_error_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
       previously_disconnected_(false),
       use_tcp_fastopen_(false),
       tcp_fastopen_connected_(false),
       num_bytes_read_(0) {
-  scoped_refptr<NetLog::EventParameters> params;
-  if (source.is_valid())
-    params = new NetLogSourceParameter("source_dependency", source);
-  net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE, params);
+  net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
+                      source.ToEventParametersCallback());
 
   if (is_tcp_fastopen_enabled())
     use_tcp_fastopen_ = true;
 }
 
 TCPClientSocketLibevent::~TCPClientSocketLibevent() {
   Disconnect();
-  net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE, NULL);
+  net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
 
 int TCPClientSocketLibevent::AdoptSocket(int socket) {
   DCHECK_EQ(socket_, kInvalidSocket);
 
   int error = SetupSocket(socket);
   if (error)
     return MapSystemError(error);
 
   socket_ = socket;
@@ skipping 99 matching lines @@
   DCHECK_EQ(0, connect_os_error_);
 
   const IPEndPoint& endpoint = addresses_[current_address_index_];
 
   if (previously_disconnected_) {
     use_history_.Reset();
     previously_disconnected_ = false;
   }
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
-                      make_scoped_refptr(new NetLogStringParameter(
-                          "address",
-                          endpoint.ToString())));
+                      CreateNetLogIPEndPointCallback(&endpoint));
 
   next_connect_state_ = CONNECT_STATE_CONNECT_COMPLETE;
 
   if (bound_socket_ != kInvalidSocket) {
     DCHECK(bind_address_.get());
     socket_ = bound_socket_;
     bound_socket_ = kInvalidSocket;
   } else {
     // Create a non-blocking socket.
     connect_os_error_ = CreateSocket(endpoint.GetFamily(), &socket_);
@@ skipping 41 matching lines @@
     return MapSystemError(connect_os_error_);
   }
 
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketLibevent::DoConnectComplete(int result) {
   // Log the end of this attempt (and any OS error it threw).
   int os_error = connect_os_error_;
   connect_os_error_ = 0;
-  scoped_refptr<NetLog::EventParameters> params;
-  if (result != OK)
-    params = new NetLogIntegerParameter("os_error", os_error);
-  net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT, params);
+  if (result != OK) {
+    net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
+                      NetLog::IntegerCallback("os_error", os_error));
+  } else {
+    net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT);
+  }
 
   if (result == OK) {
     connect_time_micros_ = base::TimeTicks::Now() - connect_start_time_;
     write_socket_watcher_.StopWatchingFileDescriptor();
     use_history_.set_was_ever_connected();
     return OK;  // Done!
   }
 
   // Close whatever partially connected socket we currently have.
   DoDisconnect();
@@ skipping 95 matching lines @@
     num_bytes_read_ += static_cast<int64>(nread);
     if (nread > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, nread,
                                   buf->data());
     return nread;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     int net_error = MapSystemError(errno);
     net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
-        make_scoped_refptr(new SocketErrorParams(net_error, errno)));
+                      CreateNetLogSocketErrorCallback(net_error, errno));
     return net_error;
   }
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_READ,
           &read_socket_watcher_, &read_watcher_)) {
     DVLOG(1) << "WatchFileDescriptor failed on read, errno " << errno;
     return MapSystemError(errno);
   }
 
@@ skipping 20 matching lines @@
     write_bytes.Add(nwrite);
     if (nwrite > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, nwrite,
                                   buf->data());
     return nwrite;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     int net_error = MapSystemError(errno);
     net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
-        make_scoped_refptr(new SocketErrorParams(net_error, errno)));
+                      CreateNetLogSocketErrorCallback(net_error, errno));
     return net_error;
   }
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_WRITE,
           &write_socket_watcher_, &write_watcher_)) {
     DVLOG(1) << "WatchFileDescriptor failed on write, errno " << errno;
     return MapSystemError(errno);
   }
 
@@ skipping 83 matching lines @@
 
   SockaddrStorage storage;
   int rv = getsockname(socket_, storage.addr, &storage.addr_len);
   if (rv != 0) {
     PLOG(ERROR) << "getsockname() [rv: " << rv << "] error: ";
     NOTREACHED();
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, rv);
     return;
   }
 
-  const std::string source_address_str =
-      NetAddressToStringWithPort(storage.addr, storage.addr_len);
   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
-                    make_scoped_refptr(new NetLogStringParameter(
-                        "source address",
-                        source_address_str)));
+                    CreateNetLogSourceAddressCallback(storage.addr,
+                                                      storage.addr_len));
 }
 
 void TCPClientSocketLibevent::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   DCHECK(!read_callback_.is_null());
 
   // since Run may result in Read being called, clear read_callback_ up front.
   CompletionCallback c = read_callback_;
   read_callback_.Reset();
   c.Run(rv);
@@ skipping 44 matching lines @@
     read_bytes.Add(bytes_transferred);
     num_bytes_read_ += static_cast<int64>(bytes_transferred);
     if (bytes_transferred > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, result,
                                   read_buf_->data());
   } else {
     result = MapSystemError(errno);
     if (result != ERR_IO_PENDING) {
       net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
-          make_scoped_refptr(new SocketErrorParams(result, errno)));
+                        CreateNetLogSocketErrorCallback(result, errno));
     }
   }
 
   if (result != ERR_IO_PENDING) {
     read_buf_ = NULL;
     read_buf_len_ = 0;
     bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
     DCHECK(ok);
     DoReadCallback(result);
   }
@@ skipping 10 matching lines @@
     base::StatsCounter write_bytes("tcp.write_bytes");
     write_bytes.Add(bytes_transferred);
     if (bytes_transferred > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, result,
                                   write_buf_->data());
   } else {
     result = MapSystemError(errno);
     if (result != ERR_IO_PENDING) {
       net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
-          make_scoped_refptr(new SocketErrorParams(result, errno)));
+                        CreateNetLogSocketErrorCallback(result, errno));
     }
   }
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
     write_buf_len_ = 0;
     write_socket_watcher_.StopWatchingFileDescriptor();
     DoWriteCallback(result);
   }
 }
@@ skipping 48 matching lines @@
 
 base::TimeDelta TCPClientSocketLibevent::GetConnectTimeMicros() const {
   return connect_time_micros_;
 }
 
 NextProto TCPClientSocketLibevent::GetNegotiatedProtocol() const {
   return kProtoUnknown;
 }
 
 }  // namespace net