NetworkPortalDetector/NetworkStateInformer: Switch over to use NetworkStateHandler

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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/browser_shutdown.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h"
 #include "chrome/browser/chromeos/login/hwid_checker.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/screens/error_screen_actor.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/net/network_portal_detector.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chromeos/login/error_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/native_window_delegate.h"
 #include "chrome/browser/ui/webui/chromeos/login/network_state_informer.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/ime/xkeyboard.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_switches.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(USE_AURA)
 #include "ash/shell.h"
 #include "ash/wm/session_state_controller.h"
 #endif
 
 using content::BrowserThread;
 using content::RenderViewHost;
 
@@ skipping 111 matching lines @@
       screen == OobeUI::SCREEN_ACCOUNT_PICKER;
 }
 
 bool IsSigninScreenError(ErrorScreen::ErrorState error_state) {
   return error_state == ErrorScreen::ERROR_STATE_PORTAL ||
       error_state == ErrorScreen::ERROR_STATE_OFFLINE ||
       error_state == ErrorScreen::ERROR_STATE_PROXY ||
       error_state == ErrorScreen::ERROR_STATE_AUTH_EXT_TIMEOUT;
 }
 
-// Returns a pointer to a Network instance by service path or NULL if
-// network can not be found.
-Network* FindNetworkByPath(const std::string& service_path) {
-  CrosLibrary* cros = CrosLibrary::Get();
-  if (!cros)
-    return NULL;
-  NetworkLibrary* network_library = cros->GetNetworkLibrary();
-  if (!network_library)
-    return NULL;
-  return network_library->FindNetworkByPath(service_path);
-}
-
 // Returns network name by service path.
 std::string GetNetworkName(const std::string& service_path) {
-  Network* network = FindNetworkByPath(service_path);
+  const NetworkState* network =
+      NetworkStateHandler::Get()->GetNetworkState(service_path);
   if (!network)
     return std::string();
   return network->name();
 }
 
 // Returns network unique id by service path.
 std::string GetNetworkUniqueId(const std::string& service_path) {
-  Network* network = FindNetworkByPath(service_path);
+  const NetworkState* network =
+      NetworkStateHandler::Get()->GetNetworkState(service_path);
   if (!network)
     return std::string();
-  return network->unique_id();
+  return network->guid();
 }
 
 // Returns captive portal state for a network by its service path.
 NetworkPortalDetector::CaptivePortalState GetCaptivePortalState(
     const std::string& service_path) {
   NetworkPortalDetector* detector = NetworkPortalDetector::GetInstance();
-  Network* network = FindNetworkByPath(service_path);
+  const NetworkState* network =
+      NetworkStateHandler::Get()->GetNetworkState(service_path);
   if (!detector || !network)
     return NetworkPortalDetector::CaptivePortalState();
   return detector->GetCaptivePortalState(network);
 }
 
 void RecordDiscrepancyWithShill(
-    const Network* network,
+    const NetworkState* network,
     const NetworkPortalDetector::CaptivePortalStatus status) {
-  if (network->online()) {
+  if (network->connection_state() == flimflam::kStateOnline) {
     UMA_HISTOGRAM_ENUMERATION(
         "CaptivePortal.OOBE.DiscrepancyWithShill_Online",
         status,
         NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
-  } else if (network->restricted_pool()) {
+  } else if (network->connection_state() == flimflam::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 Network* network = FindNetworkByPath(service_path);
+  const NetworkState* network =
+      NetworkStateHandler::Get()->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->online() || network->restricted_pool())
+      if (network->connection_state() == flimflam::kStateOnline ||
+          network->connection_state() == flimflam::kStatePortal)
         RecordDiscrepancyWithShill(network, state.status);
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE:
-      if (!network->online())
+      if (network->connection_state() != flimflam::kStateOnline)
         RecordDiscrepancyWithShill(network, state.status);
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL:
-      if (!network->restricted_pool())
+      if (network->connection_state() != flimflam::kStatePortal)
         RecordDiscrepancyWithShill(network, state.status);
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
-      if (!network->online())
+      if (network->connection_state() != flimflam::kStateOnline)
         RecordDiscrepancyWithShill(network, state.status);
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace
 
@@ skipping 160 matching lines @@
     NativeWindowDelegate* native_window_delegate) {
   native_window_delegate_ = native_window_delegate;
 }
 
 void SigninScreenHandler::OnNetworkReady() {
   MaybePreloadAuthExtension();
 }
 
 void SigninScreenHandler::UpdateState(NetworkStateInformer::State state,
                                       const std::string& service_path,
-                                      ConnectionType connection_type,
+                                      const std::string& connection_type,
                                       const std::string& reason) {
   UpdateStateInternal(state, service_path, connection_type, reason, false);
 }
 
 // SigninScreenHandler, private: -----------------------------------------------
 
 void SigninScreenHandler::UpdateUIState(UIState ui_state,
                                         DictionaryValue* params) {
   switch (ui_state) {
     case UI_STATE_GAIA_SIGNIN:
@@ skipping 10 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 // TODO (ygorshenin@): split this method into small parts.
 void SigninScreenHandler::UpdateStateInternal(
     NetworkStateInformer::State state,
-    const std::string service_path,
-    ConnectionType connection_type,
-    std::string reason,
+    const std::string& service_path,
+    const std::string& connection_type,
+    const std::string& reason,
     bool force_update) {
   // Skip "update" notification about OFFLINE state from
   // NetworkStateInformer if previous notification already was
   // delayed.
   if (state == NetworkStateInformer::OFFLINE &&
       reason == ErrorScreenActor::kErrorReasonUpdate &&
       !update_state_closure_.IsCancelled()) {
     return;
   }
 
@@ skipping 92 matching lines @@
     LOG(WARNING) << "Retry page load due to reason: " << reason;
     ReloadGaiaScreen();
     is_gaia_reloaded = true;
   }
 
   if (is_online || !is_under_captive_portal)
     error_screen_actor_->HideCaptivePortal();
 
   if ((!is_online || is_gaia_loading_timeout) && is_gaia_signin &&
       !offline_login_active_) {
-    SetupAndShowOfflineMessage(state, service_path, connection_type, reason,
+    SetupAndShowOfflineMessage(state, service_path, reason,
                                is_proxy_error, is_under_captive_portal,
                                is_gaia_loading_timeout);
   } else {
     HideOfflineMessage(state, service_path, reason, is_gaia_signin,
                        is_gaia_reloaded);
   }
 }
 
 void SigninScreenHandler::SetupAndShowOfflineMessage(
     NetworkStateInformer:: State state,
     const std::string& service_path,
-    ConnectionType connection_type,
     const std::string& reason,
     bool is_proxy_error,
     bool is_under_captive_portal,
     bool is_gaia_loading_timeout) {
   std::string network_id = GetNetworkUniqueId(service_path);
   LOG(WARNING) << "Show offline message: "
                << "state=" << NetworkStateStatusString(state) << ", "
                << "network_id=" << network_id << ", "
                << "reason=" << reason << ", "
                << "is_under_captive_portal=" << is_under_captive_portal;
@@ skipping 31 matching lines @@
   error_screen_actor_->AllowGuestSignin(guest_signin_allowed);
 
   bool offline_login_allowed = IsOfflineLoginAllowed() &&
       IsSigninScreenError(error_screen_actor_->error_state()) &&
       error_screen_actor_->error_state() !=
       ErrorScreen::ERROR_STATE_AUTH_EXT_TIMEOUT;
   error_screen_actor_->AllowOfflineLogin(offline_login_allowed);
 
   if (GetCurrentScreen() != OobeUI::SCREEN_ERROR_MESSAGE) {
     DictionaryValue params;
-    params.SetInteger("lastNetworkType", static_cast<int>(connection_type));
     error_screen_actor_->SetUIState(ErrorScreen::UI_STATE_SIGNIN);
     error_screen_actor_->Show(OobeUI::SCREEN_GAIA_SIGNIN, &params);
   }
 }
 
 void SigninScreenHandler::HideOfflineMessage(NetworkStateInformer::State state,
                                              const std::string& service_path,
                                              const std::string& reason,
                                              bool is_gaia_signin,
                                              bool is_gaia_reloaded) {
@@ skipping 877 matching lines @@
   if (!cros_settings)
     return false;
 
   // Offline login is allowed only when user pods are hidden.
   bool show_pods;
   cros_settings->GetBoolean(kAccountsPrefShowUserNamesOnSignIn, &show_pods);
   return !show_pods;
 }
 
 }  // namespace chromeos