Fix network portal detector crash on shutdown

chrome/browser/chromeos/net/network_portal_detector_impl.cc

 // Copyright (c) 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/chromeos/net/network_portal_detector_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_profile_client.h"
+#include "chromeos/device_event_log.h"
 #include "chromeos/login/login_state.h"
-#include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/content_switches.h"
 #include "net/http/http_status_code.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using base::StringPrintf;
 using captive_portal::CaptivePortalDetector;
 
@@ skipping 125 matching lines @@
                                     captive_portal::CaptivePortalResult result,
                                     int response_code)
     : network_name(network_name),
       network_id(network_id),
       result(result),
       response_code(response_code) {
 }
 
 void NetworkPortalDetectorImpl::DetectionAttemptCompletedReport::Report()
     const {
-  // TODO (ygorshenin@): remove VLOG as soon as NET_LOG_EVENT will be dumped on
-  // a disk, crbug.com/293739.
-  VLOG(1) << "Detection attempt completed: "
-          << "name=" << network_name << ", "
-          << "id=" << network_id << ", "
-          << "result=" << captive_portal::CaptivePortalResultToString(result)
-          << ", "
-          << "response_code=" << response_code;
-  NET_LOG_EVENT(StringPrintf(
-                    "Portal detection completed: network_id=%s, result=%s, "
-                    "response_code=%d",
-                    network_id.c_str(),
-                    captive_portal::CaptivePortalResultToString(result).c_str(),
-                    response_code),
-                network_name);
+  // To see NET_LOG output, use '--vmodule=device_event_log*=1'
+  NET_LOG(EVENT) << "Detection attempt completed: "
+                 << "name=" << network_name << ", "
+                 << "id=" << network_id << ", "
+                 << "result="
+                 << captive_portal::CaptivePortalResultToString(result) << ", "
+                 << "response_code=" << response_code;
 }
 
 bool NetworkPortalDetectorImpl::DetectionAttemptCompletedReport::Equals(
     const DetectionAttemptCompletedReport& o) const {
   return network_name == o.network_name && network_id == o.network_id &&
          result == o.result && response_code == o.response_code;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkPortalDetectorImpl, public:
@@ skipping 24 matching lines @@
 const char NetworkPortalDetectorImpl::kSessionPortalToOnlineHistogram[] =
     "CaptivePortal.Session.PortalToOnlineTransition";
 
 // static
 void NetworkPortalDetectorImpl::Initialize(
     net::URLRequestContextGetter* url_context) {
   if (NetworkPortalDetector::set_for_testing())
     return;
   CHECK(!NetworkPortalDetector::network_portal_detector())
       << "NetworkPortalDetector was initialized twice.";
+  NET_LOG(EVENT) << "NetworkPortalDetectorImpl::Initialize()";
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestType))
     set_network_portal_detector(new NetworkPortalDetectorStubImpl());
   else
     set_network_portal_detector(new NetworkPortalDetectorImpl(url_context));
 }
 
 NetworkPortalDetectorImpl::NetworkPortalDetectorImpl(
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : state_(STATE_IDLE),
       test_url_(CaptivePortalDetector::kDefaultURL),
       enabled_(false),
       strategy_(PortalDetectorStrategy::CreateById(
           PortalDetectorStrategy::STRATEGY_ID_LOGIN_SCREEN, this)),
       last_detection_result_(CAPTIVE_PORTAL_STATUS_UNKNOWN),
       same_detection_result_count_(0),
       no_response_result_count_(0),
       weak_factory_(this) {
+  NET_LOG(EVENT) << "NetworkPortalDetectorImpl::NetworkPortalDetectorImpl()";
   captive_portal_detector_.reset(new CaptivePortalDetector(request_context));
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_PROXY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_SUPPLIED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_CANCELLED,
                  content::NotificationService::AllSources());
 
   NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
   StartDetectionIfIdle();
 }
 
 NetworkPortalDetectorImpl::~NetworkPortalDetectorImpl() {
+  NET_LOG(EVENT) << "NetworkPortalDetectorImpl::~NetworkPortalDetectorImpl()";
   DCHECK(CalledOnValidThread());
 
   attempt_task_.Cancel();
   attempt_timeout_.Cancel();
 
   captive_portal_detector_->Cancel();
   captive_portal_detector_.reset();
   observers_.Clear();
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
@@ skipping 31 matching lines @@
   DCHECK(CalledOnValidThread());
   if (enabled_)
     return;
 
   DCHECK(is_idle());
   enabled_ = true;
 
   const NetworkState* network = DefaultNetwork();
   if (!start_detection || !network)
     return;
-  NET_LOG_EVENT(StringPrintf("Starting detection attempt: network_id=%s",
-                             network->guid().c_str()),
-                network->name());
+  NET_LOG(EVENT) << "Starting detection attempt:"
+                 << " name=" << network->name() << " id=" << network->guid();
   portal_state_map_.erase(network->guid());
   StartDetection();
 }
 
 NetworkPortalDetectorImpl::CaptivePortalState
 NetworkPortalDetectorImpl::GetCaptivePortalState(const std::string& guid) {
   DCHECK(CalledOnValidThread());
   CaptivePortalStateMap::const_iterator it = portal_state_map_.find(guid);
   if (it == portal_state_map_.end())
     return CaptivePortalState();
@@ skipping 14 matching lines @@
   strategy_ = PortalDetectorStrategy::CreateById(id, this).Pass();
   StopDetection();
   StartDetectionIfIdle();
 }
 
 void NetworkPortalDetectorImpl::DefaultNetworkChanged(
     const NetworkState* default_network) {
   DCHECK(CalledOnValidThread());
 
   if (!default_network) {
-    NET_LOG_EVENT("Default network changed", "None");
+    NET_LOG(EVENT) << "Default network changed: None";
 
     default_network_name_.clear();
 
     StopDetection();
 
     CaptivePortalState state;
     state.status = CAPTIVE_PORTAL_STATUS_OFFLINE;
     OnDetectionCompleted(NULL, state);
     return;
   }
 
   default_network_name_ = default_network->name();
 
   bool network_changed = (default_network_id_ != default_network->guid());
   default_network_id_ = default_network->guid();
 
   bool connection_state_changed =
       (default_connection_state_ != default_network->connection_state());
   default_connection_state_ = default_network->connection_state();
 
-  NET_LOG_EVENT(StringPrintf(
-                    "Default network changed: network_id=%s, state=%s, "
-                    "changed=%d, state_changed=%d",
-                    default_network_id_.c_str(),
-                    default_connection_state_.c_str(),
-                    network_changed,
-                    connection_state_changed),
-                default_network_name_);
+  NET_LOG(EVENT) << "Default network changed:"
+                 << " name=" << default_network_name_
+                 << " id=" << default_network_id_
+                 << " state=" << default_connection_state_
+                 << " changed=" << network_changed
+                 << " state_changed=" << connection_state_changed;
 
   if (network_changed || connection_state_changed)
     StopDetection();
 
   if (is_idle() && NetworkState::StateIsConnected(default_connection_state_)) {
     // Initiate Captive Portal detection if network's captive
     // portal state is unknown (e.g. for freshly created networks),
     // offline or if network connection state was changed.
     CaptivePortalState state = GetCaptivePortalState(default_network->guid());
     if (state.status == CAPTIVE_PORTAL_STATUS_UNKNOWN ||
@@ skipping 72 matching lines @@
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       attempt_timeout_.callback(),
       strategy_->GetNextAttemptTimeout());
 }
 
 void NetworkPortalDetectorImpl::OnAttemptTimeout() {
   DCHECK(CalledOnValidThread());
   DCHECK(is_checking_for_portal());
 
-  NET_LOG_ERROR(StringPrintf("Portal detection timeout: network_id=%s",
-                             default_network_id_.c_str()),
-                default_network_name_);
+  NET_LOG(ERROR) << "Portal detection timeout: "
+                 << " name=" << default_network_name_
+                 << " id=" << default_network_id_;
 
   captive_portal_detector_->Cancel();
   CaptivePortalDetector::Results results;
   results.result = captive_portal::RESULT_NO_RESPONSE;
   OnAttemptCompleted(results);
 }
 
 void NetworkPortalDetectorImpl::OnAttemptCompleted(
     const CaptivePortalDetector::Results& results) {
   DCHECK(CalledOnValidThread());
@@ skipping 77 matching lines @@
   ScheduleAttempt(results.retry_after_delta);
 }
 
 void NetworkPortalDetectorImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_LOGIN_PROXY_CHANGED ||
       type == chrome::NOTIFICATION_AUTH_SUPPLIED ||
       type == chrome::NOTIFICATION_AUTH_CANCELLED) {
-    NET_LOG_EVENT(
-        "Restarting portal detection due to proxy change",
-        default_network_name_.empty() ? "None" : default_network_name_);
+    NET_LOG(EVENT) << "Restarting portal detection due to proxy change"
+                   << " name=" << default_network_name_;
     StopDetection();
     ScheduleAttempt(base::TimeDelta::FromSeconds(kProxyChangeDelaySec));
   }
 }
 
 void NetworkPortalDetectorImpl::OnDetectionCompleted(
     const NetworkState* network,
     const CaptivePortalState& state) {
   if (!network) {
     NotifyDetectionCompleted(network, state);
@@ skipping 71 matching lines @@
 }
 
 void NetworkPortalDetectorImpl::ResetStrategyAndCounters() {
   last_detection_result_ = CAPTIVE_PORTAL_STATUS_UNKNOWN;
   same_detection_result_count_ = 0;
   no_response_result_count_ = 0;
   strategy_->Reset();
 }
 
 }  // namespace chromeos