Fixed current OOBE captive portal metrics.

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.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/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 106 matching lines @@
 
 namespace {
 
 bool IsOnline(NetworkStateInformer::State state,
               ErrorScreenActor::ErrorReason reason) {
   return state == NetworkStateInformer::ONLINE &&
       reason != ErrorScreenActor::ERROR_REASON_PORTAL_DETECTED &&
       reason != ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT;
 }
 
-bool IsUnderCaptivePortal(NetworkStateInformer::State state,
-                          ErrorScreenActor::ErrorReason reason) {
+bool IsBehindCaptivePortal(NetworkStateInformer::State state,
+                           ErrorScreenActor::ErrorReason reason) {
   return state == NetworkStateInformer::CAPTIVE_PORTAL ||
       reason == ErrorScreenActor::ERROR_REASON_PORTAL_DETECTED;
 }
 
 bool IsProxyError(NetworkStateInformer::State state,
                   ErrorScreenActor::ErrorReason reason,
                   net::Error frame_error) {
   return state == NetworkStateInformer::PROXY_AUTH_REQUIRED ||
       reason == ErrorScreenActor::ERROR_REASON_PROXY_AUTH_CANCELLED ||
       reason == ErrorScreenActor::ERROR_REASON_PROXY_CONNECTION_FAILED ||
@@ skipping 16 matching lines @@
 
 // Returns network name by service path.
 std::string GetNetworkName(const std::string& service_path) {
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!network)
     return std::string();
   return network->name();
 }
 
-// Returns captive portal state for a network by its service path.
-NetworkPortalDetector::CaptivePortalState GetCaptivePortalState(
-    const std::string& service_path) {
-  NetworkPortalDetector* detector = NetworkPortalDetector::Get();
-  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
-      GetNetworkState(service_path);
-  if (!detector || !network)
-    return NetworkPortalDetector::CaptivePortalState();
-  return detector->GetCaptivePortalState(network);
-}
-
-void RecordDiscrepancyWithShill(
-    const NetworkState* network,
-    const NetworkPortalDetector::CaptivePortalStatus status) {
-  if (network->connection_state() == shill::kStateOnline) {
-    UMA_HISTOGRAM_ENUMERATION(
-        "CaptivePortal.OOBE.DiscrepancyWithShill_Online",
-        status,
-        NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
-  } else if (network->connection_state() == shill::kStatePortal) {
-    UMA_HISTOGRAM_ENUMERATION(
-        "CaptivePortal.OOBE.DiscrepancyWithShill_RestrictedPool",
-        status,
-        NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION(
-        "CaptivePortal.OOBE.DiscrepancyWithShill_Offline",
-        status,
-        NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
-  }
-}
-
-// Record state and descripancies with shill (e.g. shill thinks that
-// network is online but NetworkPortalDetector claims that it's behind
-// portal) for the network identified by |service_path|.
-void RecordNetworkPortalDetectorStats(const std::string& service_path) {
-  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
-      GetNetworkState(service_path);
-  if (!network)
-    return;
-  NetworkPortalDetector::CaptivePortalState state =
-      GetCaptivePortalState(service_path);
-  if (state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN)
-    return;
-
-  UMA_HISTOGRAM_ENUMERATION("CaptivePortal.OOBE.DetectionResult",
-                            state.status,
-                            NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
-
-  switch (state.status) {
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN:
-      NOTREACHED();
-      break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE:
-      if (network->connection_state() == shill::kStateOnline ||
-          network->connection_state() == shill::kStatePortal)
-        RecordDiscrepancyWithShill(network, state.status);
-      break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE:
-      if (network->connection_state() != shill::kStateOnline)
-        RecordDiscrepancyWithShill(network, state.status);
-      break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL:
-      if (network->connection_state() != shill::kStatePortal)
-        RecordDiscrepancyWithShill(network, state.status);
-      break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
-      if (network->connection_state() != shill::kStateOnline)
-        RecordDiscrepancyWithShill(network, state.status);
-      break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT:
-      NOTREACHED();
-      break;
-  }
-}
-
 static bool SetUserInputMethodImpl(
     const std::string& username,
     chromeos::input_method::InputMethodManager* manager) {
   PrefService* const local_state = g_browser_process->local_state();
 
   const base::DictionaryValue* users_lru_input_methods =
       local_state->GetDictionary(prefs::kUsersLRUInputMethod);
 
   if (users_lru_input_methods == NULL) {
     DLOG(WARNING) << "SetUserInputMethod('" << username
@@ skipping 348 matching lines @@
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           connecting_closure_.callback(),
           base::TimeDelta::FromSeconds(kConnectingTimeoutSec));
     }
     return;
   }
   connecting_closure_.Cancel();
 
   const bool is_online = IsOnline(state, reason);
-  const bool is_under_captive_portal = IsUnderCaptivePortal(state, reason);
+  const bool is_behind_captive_portal = IsBehindCaptivePortal(state, reason);
   const bool is_gaia_loading_timeout =
       (reason == ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
   const bool is_gaia_error =
       FrameError() != net::OK && FrameError() != net::ERR_NETWORK_CHANGED;
   const bool is_gaia_signin = IsGaiaVisible() || IsGaiaHiddenByError();
   const bool error_screen_should_overlay =
       !offline_login_active_ && IsGaiaVisible();
   const bool from_not_online_to_online_transition =
       is_online && last_network_state_ != NetworkStateInformer::ONLINE;
   last_network_state_ = state;
 
-  if (is_online || !is_under_captive_portal)
+  if (is_online || !is_behind_captive_portal)
     error_screen_actor_->HideCaptivePortal();
 
   // Hide offline message (if needed) and return if current screen is
   // not a Gaia frame.
   if (!is_gaia_signin) {
     if (!IsSigninScreenHiddenByError())
       HideOfflineMessage(state, reason);
     return;
   }
 
@@ skipping 24 matching lines @@
     SetupAndShowOfflineMessage(state, reason);
   } else {
     HideOfflineMessage(state, reason);
   }
 }
 
 void SigninScreenHandler::SetupAndShowOfflineMessage(
     NetworkStateInformer:: State state,
     ErrorScreenActor::ErrorReason reason) {
   const std::string network_path = network_state_informer_->network_path();
-  const bool is_under_captive_portal = IsUnderCaptivePortal(state, reason);
+  const bool is_behind_captive_portal = IsBehindCaptivePortal(state, reason);
   const bool is_proxy_error = IsProxyError(state, reason, FrameError());
   const bool is_gaia_loading_timeout =
       (reason == ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
 
-  // Record portal detection stats only if we're going to show or
-  // change state of the error screen.
-  RecordNetworkPortalDetectorStats(network_path);
-
   if (is_proxy_error) {
     error_screen_actor_->SetErrorState(ErrorScreen::ERROR_STATE_PROXY,
                                        std::string());
-  } else if (is_under_captive_portal) {
+  } else if (is_behind_captive_portal) {
     // Do not bother a user with obsessive captive portal showing. This
     // check makes captive portal being shown only once: either when error
     // screen is shown for the first time or when switching from another
     // error screen (offline, proxy).
     if (IsGaiaVisible() ||
         (error_screen_actor_->error_state() !=
          ErrorScreen::ERROR_STATE_PORTAL)) {
       error_screen_actor_->FixCaptivePortal();
     }
     const std::string network_name = GetNetworkName(network_path);
@@ skipping 1016 matching lines @@
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_state();
 }
 
 net::Error SigninScreenHandler::FrameError() const {
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_error();
 }
 
 }  // namespace chromeos