Update from https://crrev.com/316786

net/udp/udp_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/udp/udp_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <net/if.h>
 #include <netinet/in.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/sparse_histogram.h"
-#include "base/metrics/stats_counters.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.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_activity_monitor.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/udp/udp_net_log_parameters.h"
@@ skipping 90 matching lines @@
   write_buf_ = NULL;
   write_buf_len_ = 0;
   write_callback_.Reset();
   send_to_address_.reset();
 
   bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
   DCHECK(ok);
   ok = write_socket_watcher_.StopWatchingFileDescriptor();
   DCHECK(ok);
 
-  if (IGNORE_EINTR(close(socket_)) < 0)
-    PLOG(ERROR) << "close";
+  PCHECK(0 == IGNORE_EINTR(close(socket_)));
 
   socket_ = kInvalidSocket;
   addr_family_ = 0;
   is_connected_ = false;
 }
 
 int UDPSocketLibevent::GetPeerAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!is_connected())
@@ skipping 279 matching lines @@
 
     IPEndPoint address;
     bool is_address_valid = address.FromSockAddr(addr, addr_len);
     net_log_.AddEvent(
         NetLog::TYPE_UDP_BYTES_RECEIVED,
         CreateNetLogUDPDataTranferCallback(
             result, bytes,
             is_address_valid ? &address : NULL));
   }
 
-  base::StatsCounter read_bytes("udp.read_bytes");
-  read_bytes.Add(result);
   NetworkActivityMonitor::GetInstance()->IncrementBytesReceived(result);
 }
 
 void UDPSocketLibevent::DidCompleteWrite() {
   int result =
       InternalSendTo(write_buf_.get(), write_buf_len_, send_to_address_.get());
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
     write_buf_len_ = 0;
@@ skipping 10 matching lines @@
     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_SEND_ERROR, result);
     return;
   }
 
   if (net_log_.IsLogging()) {
     net_log_.AddEvent(
         NetLog::TYPE_UDP_BYTES_SENT,
         CreateNetLogUDPDataTranferCallback(result, bytes, address));
   }
 
-  base::StatsCounter write_bytes("udp.write_bytes");
-  write_bytes.Add(result);
   NetworkActivityMonitor::GetInstance()->IncrementBytesSent(result);
 }
 
 int UDPSocketLibevent::InternalRecvFrom(IOBuffer* buf, int buf_len,
                                         IPEndPoint* address) {
   int bytes_transferred;
   int flags = 0;
 
   SockaddrStorage storage;
 
@@ skipping 274 matching lines @@
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketLibevent::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net