[chrome/browser/local_discovery] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/local_discovery/privet_traffic_detector.cc

 // Copyright 2013 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/local_discovery/privet_traffic_detector.h"
 
 #include "base/metrics/histogram.h"
 #include "base/sys_byteorder.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/mdns_client.h"
 #include "net/log/net_log.h"
 #include "net/udp/datagram_server_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 namespace {
 
 const int kMaxRestartAttempts = 10;
 const char kPrivetDeviceTypeDnsString[] = "\x07_privet";
 
 void GetNetworkListOnFileThread(
     const base::Callback<void(const net::NetworkInterfaceList&)> callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   net::NetworkInterfaceList networks;
   if (!GetNetworkList(&networks, net::INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES))
     return;
 
   net::NetworkInterfaceList ip4_networks;
   for (size_t i = 0; i < networks.size(); ++i) {
     net::AddressFamily address_family =
         net::GetAddressFamily(networks[i].address);
     if (address_family == net::ADDRESS_FAMILY_IPV4 &&
         networks[i].prefix_length >= 24) {
@@ skipping 33 matching lines @@
 
 void PrivetTrafficDetector::Start() {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&PrivetTrafficDetector::StartOnIOThread,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 PrivetTrafficDetector::~PrivetTrafficDetector() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void PrivetTrafficDetector::StartOnIOThread() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   ScheduleRestart();
 }
 
 void PrivetTrafficDetector::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   restart_attempts_ = kMaxRestartAttempts;
   if (type != net::NetworkChangeNotifier::CONNECTION_NONE)
     ScheduleRestart();
 }
 
 void PrivetTrafficDetector::ScheduleRestart() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   socket_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
   content::BrowserThread::PostDelayedTask(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&GetNetworkListOnFileThread,
                  base::Bind(&PrivetTrafficDetector::Restart,
                             weak_ptr_factory_.GetWeakPtr())),
       base::TimeDelta::FromSeconds(3));
 }
 
 void PrivetTrafficDetector::Restart(const net::NetworkInterfaceList& networks) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   networks_ = networks;
   if (Bind() < net::OK || DoLoop(0) < net::OK) {
     if ((restart_attempts_--) > 0)
       ScheduleRestart();
   } else {
     // Reset on success.
     restart_attempts_ = kMaxRestartAttempts;
   }
 }
 
 int PrivetTrafficDetector::Bind() {
   if (!start_time_.is_null()) {
     base::TimeDelta time_delta = base::Time::Now() - start_time_;
     UMA_HISTOGRAM_LONG_TIMES("LocalDiscovery.DetectorRestartTime", time_delta);
   }
   start_time_ = base::Time::Now();
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
   net::IPEndPoint multicast_addr = net::GetMDnsIPEndPoint(address_family_);
   net::IPAddressNumber address_any(multicast_addr.address().size());
   net::IPEndPoint bind_endpoint(address_any, multicast_addr.port());
   socket_->AllowAddressReuse();
   int rv = socket_->Listen(bind_endpoint);
   if (rv < net::OK)
     return rv;
   socket_->SetMulticastLoopbackMode(false);
   return socket_->JoinGroup(multicast_addr.address());
@@ skipping 24 matching lines @@
     return false;
   const char* substring_begin = kPrivetDeviceTypeDnsString;
   const char* substring_end = substring_begin +
                               arraysize(kPrivetDeviceTypeDnsString) - 1;
   // Check for expected substring, any Privet device must include this.
   return std::search(buffer_begin, buffer_end, substring_begin,
                      substring_end) != buffer_end;
 }
 
 int PrivetTrafficDetector::DoLoop(int rv) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   do {
     if (IsPrivetPacket(rv)) {
       socket_.reset();
       callback_runner_->PostTask(FROM_HERE, on_traffic_detected_);
       base::TimeDelta time_delta = base::Time::Now() - start_time_;
       UMA_HISTOGRAM_LONG_TIMES("LocalDiscovery.DetectorTriggerTime",
                                time_delta);
       return net::OK;
     }
 
     rv = socket_->RecvFrom(
         io_buffer_.get(),
         io_buffer_->size(),
         &recv_addr_,
         base::Bind(base::IgnoreResult(&PrivetTrafficDetector::DoLoop),
                    base::Unretained(this)));
   } while (rv > 0);
 
   if (rv != net::ERR_IO_PENDING)
     return rv;
 
   return net::OK;
 }
 
 }  // namespace local_discovery