LOG(INFO) tidying in net/

net/tools/quic/quic_dispatcher.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_dispatcher.h"
 
 #include <errno.h>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 92 matching lines @@
     }
 
     // Ensure the packet has a version negotiation bit set before creating a new
     // session for it.  All initial packets for a new connection are required to
     // have the flag set.  Otherwise it may be a stray packet.
     if (has_version_flag) {
       session = CreateQuicSession(guid, client_address);
     }
 
     if (session == NULL) {
-      DLOG(INFO) << "Failed to create session for " << guid;
+      DVLOG(0) << "Failed to create session for " << guid;
       // Add this guid fo the time-wait state, to safely reject future packets.
       // We don't know the version here, so assume latest.
       // TODO(ianswett): Produce a no-version version negotiation packet.
       time_wait_list_manager_->AddGuidToTimeWait(guid,
                                                  supported_versions_.front(),
                                                  NULL);
       time_wait_list_manager_->ProcessPacket(server_address,
                                              client_address,
                                              guid,
                                              packet);
       return;
     }
-    DLOG(INFO) << "Created new session for " << guid;
+    DVLOG(0) << "Created new session for " << guid;
     session_map_.insert(make_pair(guid, session));
   } else {
     session = it->second;
   }
 
   session->connection()->ProcessUdpPacket(
       server_address, client_address, packet);
 }
 
 void QuicDispatcher::CleanUpSession(SessionMap::iterator it) {
@@ skipping 56 matching lines @@
 }
 
 void QuicDispatcher::OnConnectionClosed(QuicGuid guid, QuicErrorCode error) {
   SessionMap::iterator it = session_map_.find(guid);
   if (it == session_map_.end()) {
     LOG(DFATAL) << "GUID " << guid << " does not exist in the session map.  "
                 << "Error: " << QuicUtils::ErrorToString(error);
     return;
   }
 
-  DLOG_IF(INFO, error != QUIC_NO_ERROR) << "Closing connection (" << guid
+  DVLOG_IF(0, error != QUIC_NO_ERROR) << "Closing connection (" << guid
                                         << ") due to error: "
                                         << QuicUtils::ErrorToString(error);
 
   if (closed_session_list_.empty()) {
     epoll_server_->RegisterAlarmApproximateDelta(
         0, delete_sessions_alarm_.get());
   }
   closed_session_list_.push_back(it->second);
   CleanUpSession(it);
 }
 
 QuicSession* QuicDispatcher::CreateQuicSession(
     QuicGuid guid,
     const IPEndPoint& client_address) {
   QuicServerSession* session = new QuicServerSession(
       config_, new QuicConnection(guid, client_address, helper_.get(), this,
                                   true, supported_versions_), this);
   session->InitializeSession(crypto_config_);
   return session;
 }
 
 }  // namespace tools
 }  // namespace net