Add quic_logging

net/tools/quic/quic_client.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/tools/quic/quic_client.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
-#include "base/logging.h"
 #include "base/run_loop.h"
 #include "net/base/sockaddr_storage.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_data_reader.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/tools/quic/platform/impl/quic_socket_utils.h"
 #include "net/tools/quic/quic_epoll_alarm_factory.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
 // TODO(rtenneti): Add support for MMSG_MORE.
 #define MMSG_MORE 0
@@ skipping 62 matching lines @@
     client_address = QuicSocketAddress(bind_to_address, local_port());
   } else if (server_address.host().address_family() == IpAddressFamily::IP_V4) {
     client_address = QuicSocketAddress(QuicIpAddress::Any4(), bind_to_port);
   } else {
     client_address = QuicSocketAddress(QuicIpAddress::Any6(), bind_to_port);
   }
 
   sockaddr_storage addr = client_address.generic_address();
   int rc = bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
   if (rc < 0) {
-    LOG(ERROR) << "Bind failed: " << strerror(errno);
+    QUIC_LOG(ERROR) << "Bind failed: " << strerror(errno);
     return false;
   }
 
   if (client_address.FromSocket(fd) != 0) {
-    LOG(ERROR) << "Unable to get self address.  Error: " << strerror(errno);
+    QUIC_LOG(ERROR) << "Unable to get self address.  Error: "
+                    << strerror(errno);
   }
 
   fd_address_map_[fd] = client_address;
 
   epoll_server_->RegisterFD(fd, this, kEpollFlags);
   return true;
 }
 
 void QuicClient::CleanUpUDPSocket(int fd) {
   CleanUpUDPSocketImpl(fd);
@@ skipping 30 matching lines @@
           GetLatestFD(), QuicClient::GetLatestClientAddress().port(),
           *helper()->GetClock(), this,
           overflow_supported_ ? &packets_dropped_ : nullptr);
     }
   }
   if (connected() && (event->in_events & EPOLLOUT)) {
     writer()->SetWritable();
     session()->connection()->OnCanWrite();
   }
   if (event->in_events & EPOLLERR) {
-    DVLOG(1) << "Epollerr";
+    QUIC_DLOG(INFO) << "Epollerr";
   }
 }
 
 QuicPacketWriter* QuicClient::CreateQuicPacketWriter() {
   return new QuicDefaultPacketWriter(GetLatestFD());
 }
 
 QuicSocketAddress QuicClient::GetLatestClientAddress() const {
   if (fd_address_map_.empty()) {
     return QuicSocketAddress();
@@ skipping 10 matching lines @@
   return fd_address_map_.back().first;
 }
 
 void QuicClient::ProcessPacket(const QuicSocketAddress& self_address,
                                const QuicSocketAddress& peer_address,
                                const QuicReceivedPacket& packet) {
   session()->ProcessUdpPacket(self_address, peer_address, packet);
 }
 
 }  // namespace net