Convert DLOG/DVLOG messages in chrome.dial to VLOG.

chrome/browser/extensions/api/dial/dial_service.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 "chrome/browser/extensions/api/dial/dial_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 99 matching lines @@
 }
 
 #if !defined(OS_CHROMEOS)
 void GetNetworkListOnFileThread(
     const scoped_refptr<base::MessageLoopProxy>& loop,
     const base::Callback<void(const NetworkInterfaceList& networks)>& cb) {
   NetworkInterfaceList list;
   bool success = net::GetNetworkList(
       &list, net::INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES);
   if (!success)
-    DVLOG(1) << "Could not retrieve network list!";
+    VLOG(1) << "Could not retrieve network list!";
 
   loop->PostTask(FROM_HERE, base::Bind(cb, list));
 }
 
 #else
 
 // Finds the IP address of the preferred interface of network type |type|
 // to bind the socket and inserts the address into |bind_address_list|. This
 // ChromeOS version can prioritize wifi and ethernet interfaces.
 void InsertBestBindAddressChromeOS(
     const chromeos::NetworkTypePattern& type,
     std::vector<IPAddressNumber>* bind_address_list) {
   const chromeos::NetworkState* state = chromeos::NetworkHandler::Get()
       ->network_state_handler()->ConnectedNetworkByType(type);
   IPAddressNumber bind_ip_address;
   if (state
       && net::ParseIPLiteralToNumber(state->ip_address(), &bind_ip_address)
       && bind_ip_address.size() == net::kIPv4AddressSize) {
-    DVLOG(1) << "Found " << state->type() << ", " << state->name() << ": "
-             << state->ip_address();
+    VLOG(2) << "Found " << state->type() << ", " << state->name() << ": "
+            << state->ip_address();
     bind_address_list->push_back(bind_ip_address);
   }
 }
 #endif  // !defined(OS_CHROMEOS)
 
 }  // namespace
 
 DialServiceImpl::DialSocket::DialSocket(
     const base::Closure& discovery_request_cb,
     const base::Callback<void(const DialDeviceData&)>& device_discovered_cb,
@@ skipping 33 matching lines @@
   DCHECK(socket_.get());
 
   recv_buffer_ = new IOBufferWithSize(kDialRecvBufferSize);
   return ReadSocket();
 }
 
 void DialServiceImpl::DialSocket::SendOneRequest(
     const net::IPEndPoint& send_address,
     const scoped_refptr<net::StringIOBuffer>& send_buffer) {
   if (!socket_.get()) {
-    DLOG(WARNING) << "Socket not connected.";
+    VLOG(1) << "Socket not connected.";
     return;
   }
 
   if (is_writing_) {
-    VLOG(2) << "Already writing.";
+    VLOG(1) << "Already writing.";
     return;
   }
 
   is_writing_ = true;
   int result = socket_->SendTo(
       send_buffer.get(), send_buffer->size(), send_address,
       base::Bind(&DialServiceImpl::DialSocket::OnSocketWrite,
                  base::Unretained(this),
                  send_buffer->size()));
   bool result_ok = CheckResult("SendTo", result);
   if (result_ok && result > 0) {
     // Synchronous write.
     OnSocketWrite(send_buffer->size(), result);
   }
 }
 
 bool DialServiceImpl::DialSocket::IsClosed() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !socket_.get();
 }
 
 bool DialServiceImpl::DialSocket::CheckResult(const char* operation,
                                               int result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(2) << "Operation " << operation << " result " << result;
   if (result < net::OK && result != net::ERR_IO_PENDING) {
     Close();
     std::string error_str(net::ErrorToString(result));
-    DVLOG(0) << "dial socket error: " << error_str;
+    VLOG(1) << "dial socket error: " << error_str;
     on_error_cb_.Run();
     return false;
   }
   return true;
 }
 
 void DialServiceImpl::DialSocket::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   is_reading_ = false;
   is_writing_ = false;
   socket_.reset();
 }
 
 void DialServiceImpl::DialSocket::OnSocketWrite(int send_buffer_size,
                                                 int result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   is_writing_ = false;
   if (!CheckResult("OnSocketWrite", result))
     return;
   if (result != send_buffer_size) {
-    DLOG(ERROR) << "Sent " << result << " chars, expected "
-                << send_buffer_size << " chars";
+    VLOG(1) << "Sent " << result << " chars, expected "
+            << send_buffer_size << " chars";
   }
   discovery_request_cb_.Run();
 }
 
 bool DialServiceImpl::DialSocket::ReadSocket() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!socket_.get()) {
-    DLOG(WARNING) << "Socket not connected.";
+    VLOG(1) << "Socket not connected.";
     return false;
   }
 
   if (is_reading_) {
-    VLOG(2) << "Already reading.";
+    VLOG(1) << "Already reading.";
     return false;
   }
 
   int result = net::OK;
   bool result_ok = true;
   do {
     is_reading_ = true;
     result = socket_->RecvFrom(
         recv_buffer_.get(),
         kDialRecvBufferSize, &recv_address_,
@@ skipping 19 matching lines @@
     HandleResponse(result);
 
   // Await next response.
   ReadSocket();
 }
 
 void DialServiceImpl::DialSocket::HandleResponse(int bytes_read) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_GT(bytes_read, 0);
   if (bytes_read > kDialRecvBufferSize) {
-    DLOG(ERROR) << bytes_read << " > " << kDialRecvBufferSize << "!?";
+    VLOG(1) << bytes_read << " > " << kDialRecvBufferSize << "!?";
     return;
   }
   VLOG(2) << "Read " << bytes_read << " bytes from "
           << recv_address_.ToString();
 
   std::string response(recv_buffer_->data(), bytes_read);
   Time response_time = Time::Now();
 
   // Attempt to parse response, notify observers if successful.
   DialDeviceData parsed_device;
   if (ParseResponse(response, response_time, &parsed_device))
     device_discovered_cb_.Run(parsed_device);
 }
 
 // static
 bool DialServiceImpl::DialSocket::ParseResponse(
     const std::string& response,
     const base::Time& response_time,
     DialDeviceData* device) {
   int headers_end = HttpUtil::LocateEndOfHeaders(response.c_str(),
                                                  response.size());
   if (headers_end < 1) {
-    VLOG(2) << "Headers invalid or empty, ignoring: " << response;
+    VLOG(1) << "Headers invalid or empty, ignoring: " << response;
     return false;
   }
   std::string raw_headers =
       HttpUtil::AssembleRawHeaders(response.c_str(), headers_end);
-  VLOG(2) << "raw_headers: " << raw_headers << "\n";
+  VLOG(3) << "raw_headers: " << raw_headers << "\n";
   scoped_refptr<HttpResponseHeaders> headers =
       new HttpResponseHeaders(raw_headers);
 
   std::string device_url_str;
   if (!GetHeader(headers.get(), kSsdpLocationHeader, &device_url_str) ||
       device_url_str.empty()) {
-    VLOG(2) << "No LOCATION header found.";
+    VLOG(1) << "No LOCATION header found.";
     return false;
   }
 
   GURL device_url(device_url_str);
   if (!DialDeviceData::IsDeviceDescriptionUrl(device_url)) {
-    VLOG(2) << "URL " << device_url_str << " not valid.";
+    VLOG(1) << "URL " << device_url_str << " not valid.";
     return false;
   }
 
   std::string device_id;
   if (!GetHeader(headers.get(), kSsdpUsnHeader, &device_id) ||
       device_id.empty()) {
-    VLOG(2) << "No USN header found.";
+    VLOG(1) << "No USN header found.";
     return false;
   }
 
   device->set_device_id(device_id);
   device->set_device_description_url(device_url);
   device->set_response_time(response_time);
 
   // TODO(mfoltz): Parse the max-age value from the cache control header.
   // http://crbug.com/165289
   std::string cache_control;
   GetHeader(headers.get(), kSsdpCacheControlHeader, &cache_control);
 
   std::string config_id;
   int config_id_int;
   if (GetHeader(headers.get(), kSsdpConfigIdHeader, &config_id) &&
       base::StringToInt(config_id, &config_id_int)) {
     device->set_config_id(config_id_int);
   } else {
-    VLOG(2) << "Malformed or missing " << kSsdpConfigIdHeader << ": "
+    VLOG(1) << "Malformed or missing " << kSsdpConfigIdHeader << ": "
             << config_id;
   }
 
   return true;
 }
 
 DialServiceImpl::DialServiceImpl(net::NetLog* net_log)
     : discovery_active_(false),
       num_requests_sent_(0),
       max_requests_(kDialMaxRequests),
@@ skipping 78 matching lines @@
   std::set<InterfaceIndexAddressFamily> interface_index_addr_family_seen;
   std::vector<IPAddressNumber> ip_addresses;
 
   // Binds a socket to each IPv4 network interface found. Note that
   // there may be duplicates in |networks|, so address family + interface index
   // is used to identify unique interfaces.
   // TODO(mfoltz): Support IPV6 multicast.  http://crbug.com/165286
   for (NetworkInterfaceList::const_iterator iter = networks.begin();
        iter != networks.end(); ++iter) {
     net::AddressFamily addr_family = net::GetAddressFamily(iter->address);
-    DVLOG(1) << "Found " << iter->name << ", "
-             << net::IPAddressToString(iter->address)
-             << ", address family: " << addr_family;
+    VLOG(2) << "Found " << iter->name << ", "
+            << net::IPAddressToString(iter->address)
+            << ", address family: " << addr_family;
     if (addr_family == net::ADDRESS_FAMILY_IPV4) {
       InterfaceIndexAddressFamily interface_index_addr_family =
           std::make_pair(iter->interface_index, addr_family);
       bool inserted = interface_index_addr_family_seen
           .insert(interface_index_addr_family)
           .second;
       // We have not seen this interface before, so add its IP address to the
       // discovery list.
       if (inserted) {
         VLOG(2) << "Encountered "
                 << "interface index: " << iter->interface_index << ", "
                 << "address family: " << addr_family << " for the first time, "
                 << "adding IP address " << net::IPAddressToString(iter->address)
                 << " to list.";
         ip_addresses.push_back(iter->address);
       } else {
         VLOG(2) << "Already encountered "
                 << "interface index: " << iter->interface_index << ", "
                 << "address family: " << addr_family << " before, not adding.";
       }
     }
   }
 
   DiscoverOnAddresses(ip_addresses);
 }
 
 void DialServiceImpl::DiscoverOnAddresses(
     const std::vector<IPAddressNumber>& ip_addresses) {
   if (ip_addresses.empty()) {
-    DVLOG(1) << "Could not find a valid interface to bind. Finishing discovery";
+    VLOG(1) << "Could not find a valid interface to bind. Finishing discovery";
     FinishDiscovery();
     return;
   }
 
   // Schedule a timer to finish the discovery process (and close the sockets).
   if (finish_delay_ > TimeDelta::FromSeconds(0)) {
     VLOG(2) << "Starting timer to finish discovery.";
     finish_timer_.Start(FROM_HERE,
                         finish_delay_,
                         this,
@@ skipping 103 matching lines @@
   for (ScopedVector<DialSocket>::const_iterator iter = dial_sockets_.begin();
        iter != dial_sockets_.end();
        ++iter) {
     if (!((*iter)->IsClosed()))
       return true;
   }
   return false;
 }
 
 }  // namespace extensions