Fixed logging for network portal detector.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 21 matching lines @@
 // Minimum timeout between consecutive portal checks for the same
 // network.
 const int kMinTimeBetweenAttemptsSec = 3;
 
 // Delay before portal detection caused by changes in proxy settings.
 const int kProxyChangeDelaySec = 1;
 
 // Delay between consecutive portal checks for a network in lazy mode.
 const int kLazyCheckIntervalSec = 5;
 
+const char kCaptivePortalStatusUnknown[] = "Unknown";
+const char kCaptivePortalStatusOffline[] = "Offline";
+const char kCaptivePortalStatusOnline[]  = "Online";
+const char kCaptivePortalStatusPortal[]  = "Portal";
+const char kCaptivePortalStatusProxyAuthRequired[] =
+    "Proxy authentication required";
+const char kCaptivePortalStatusUnrecognized[] = "Unrecognized";
+
 std::string CaptivePortalStatusString(
     NetworkPortalDetectorImpl::CaptivePortalStatus status) {
   switch (status) {
     case NetworkPortalDetectorImpl::CAPTIVE_PORTAL_STATUS_UNKNOWN:
-      return l10n_util::GetStringUTF8(
-          IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_UNKNOWN);
+      return kCaptivePortalStatusUnknown;
     case NetworkPortalDetectorImpl::CAPTIVE_PORTAL_STATUS_OFFLINE:
-      return l10n_util::GetStringUTF8(
-          IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_OFFLINE);
+      return kCaptivePortalStatusOffline;
     case NetworkPortalDetectorImpl::CAPTIVE_PORTAL_STATUS_ONLINE:
-      return l10n_util::GetStringUTF8(
-          IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_ONLINE);
+      return kCaptivePortalStatusOnline;
     case NetworkPortalDetectorImpl::CAPTIVE_PORTAL_STATUS_PORTAL:
-      return l10n_util::GetStringUTF8(
-          IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_PORTAL);
+      return kCaptivePortalStatusPortal;
     case NetworkPortalDetectorImpl::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
-      return l10n_util::GetStringUTF8(
-          IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED);
+      return kCaptivePortalStatusProxyAuthRequired;
     case NetworkPortalDetectorImpl::CAPTIVE_PORTAL_STATUS_COUNT:
       NOTREACHED();
   }
-  return l10n_util::GetStringUTF8(
-      IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_UNRECOGNIZED);
+  return kCaptivePortalStatusUnrecognized;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkPortalDetectorImpl, public:
 
 NetworkPortalDetectorImpl::NetworkPortalDetectorImpl(
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : state_(STATE_IDLE),
@@ skipping 121 matching lines @@
   lazy_detection_enabled_ = false;
   if (attempt_count_ == kMaxRequestAttempts && IsPortalCheckPending())
     CancelPortalDetection();
   VLOG(1) << "Lazy detection mode disabled.";
 }
 
 void NetworkPortalDetectorImpl::DefaultNetworkChanged(
     const NetworkState* default_network) {
   DCHECK(CalledOnValidThread());
   if (!default_network) {
+    default_network_name_.clear();
     default_network_id_.clear();
     return;
   }
 
+  default_network_name_ = default_network->name();
   default_network_id_ = default_network->guid();
 
   bool network_changed = (default_service_path_ != default_network->path());
   default_service_path_ = default_network->path();
 
   bool connection_state_changed = (default_connection_state_ !=
                                    default_network->connection_state());
   default_connection_state_ = default_network->connection_state();
 
   if (network_changed || connection_state_changed) {
@@ skipping 63 matching lines @@
 
 void NetworkPortalDetectorImpl::DetectCaptivePortalTask() {
   DCHECK(IsPortalCheckPending());
 
   state_ = STATE_CHECKING_FOR_PORTAL;
   attempt_start_time_ = GetCurrentTimeTicks();
 
   if (attempt_count_ < kMaxRequestAttempts) {
     ++attempt_count_;
     VLOG(1) << "Portal detection started: "
-            << "network=" << default_network_id_ << ", "
+            << "name=" << default_network_name_ << ", "
+            << "id=" << default_network_id_ << ", "
             << "attempt=" << attempt_count_ << " of " << kMaxRequestAttempts;
   } else {
     DCHECK(lazy_detection_enabled());
     VLOG(1) << "Lazy portal detection attempt started";
   }
 
   captive_portal_detector_->DetectCaptivePortal(
       test_url_,
       base::Bind(&NetworkPortalDetectorImpl::OnPortalDetectionCompleted,
                  weak_ptr_factory_.GetWeakPtr()));
   detection_timeout_.Reset(
       base::Bind(&NetworkPortalDetectorImpl::PortalDetectionTimeout,
                  weak_ptr_factory_.GetWeakPtr()));
   base::TimeDelta request_timeout;
 
   // For easier unit testing check for testing state is performed here
   // and not in the GetRequestTimeoutSec().
   if (request_timeout_for_testing_initialized_)
     request_timeout = request_timeout_for_testing_;
   else
     request_timeout = base::TimeDelta::FromSeconds(GetRequestTimeoutSec());
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, detection_timeout_.callback(), request_timeout);
 }
 
 void NetworkPortalDetectorImpl::PortalDetectionTimeout() {
   DCHECK(CalledOnValidThread());
   DCHECK(IsCheckingForPortal());
 
-  VLOG(1) << "Portal detection timeout: network=" << default_network_id_;
+  VLOG(1) << "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;
   OnPortalDetectionCompleted(results);
 }
 
 void NetworkPortalDetectorImpl::CancelPortalDetection() {
   if (IsPortalCheckPending())
     detection_task_.Cancel();
@@ skipping 10 matching lines @@
 
   if (shill_stub_helper::IsStubPortalledWifiEnabled(default_service_path_)) {
     result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
     response_code = 200;
   }
 
   DCHECK(CalledOnValidThread());
   DCHECK(IsCheckingForPortal());
 
   VLOG(1) << "Portal detection completed: "
-          << "network=" << default_network_id_ << ", "
+          << "name=" << default_network_name_ << ", "
+          << "id=" << default_network_id_ << ", "
           << "result=" << CaptivePortalDetector::CaptivePortalResultToString(
               results.result) << ", "
           << "response_code=" << results.response_code;
 
   state_ = STATE_IDLE;
   detection_timeout_.Cancel();
 
   const NetworkState* default_network =
       NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
 
   CaptivePortalState state;
   state.response_code = response_code;
   switch (result) {
     case captive_portal::RESULT_NO_RESPONSE:
       if (attempt_count_ >= kMaxRequestAttempts) {
         if (state.response_code == net::HTTP_PROXY_AUTHENTICATION_REQUIRED) {
           state.status = CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
         } else if (default_network && (default_network->connection_state() ==
                                        shill::kStatePortal)) {
           // Take into account shill's detection results.
           state.status = CAPTIVE_PORTAL_STATUS_PORTAL;
-          LOG(WARNING) << "Network " << default_network->guid() << " "
+          LOG(WARNING) << "Network name=" << default_network->name() << ", "
+                       << "id=" << default_network->guid() << " "
                        << "is marked as "
                        << CaptivePortalStatusString(state.status) << " "
                        << "despite the fact that CaptivePortalDetector "
                        << "received no response";
         } else {
           state.status = CAPTIVE_PORTAL_STATUS_OFFLINE;
         }
         SetCaptivePortalState(default_network, state);
       } else {
         DCHECK(CanPerformDetection());
@@ skipping 57 matching lines @@
     NotifyPortalDetectionCompleted(network, state);
     return;
   }
 
   CaptivePortalStateMap::const_iterator it =
       portal_state_map_.find(network->path());
   if (it == portal_state_map_.end() ||
       it->second.status != state.status ||
       it->second.response_code != state.response_code) {
     VLOG(1) << "Updating Chrome Captive Portal state: "
-            << "network=" << network->guid() << ", "
+            << "name=" << network->name() << ", "
+            << "id=" << network->guid() << ", "
             << "status=" << CaptivePortalStatusString(state.status) << ", "
             << "response_code=" << state.response_code;
     portal_state_map_[network->path()] = state;
   }
   NotifyPortalDetectionCompleted(network, state);
 }
 
 void NetworkPortalDetectorImpl::NotifyPortalDetectionCompleted(
     const NetworkState* network,
     const CaptivePortalState& state) {
@@ skipping 16 matching lines @@
   const NetworkState* network =
       NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (!network)
     return kBaseRequestTimeoutSec;
   if (lazy_detection_enabled_)
     return kLazyRequestTimeoutSec;
   return attempt_count_ * kBaseRequestTimeoutSec;
 }
 
 }  // namespace chromeos