Remove additional dependencies from InternetOptionsHandler

chrome/browser/ui/webui/options/chromeos/internet_options_handler.cc

 // Copyright (c) 2012 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/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "ash/system/chromeos/network/network_connect.h"
 #include "ash/system/chromeos/network/network_icon.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/net/onc_utils.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
-#include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 38 matching lines @@
 const char kRefreshNetworkDataFunction[] =
     "options.network.NetworkList.refreshNetworkData";
 const char kSetDefaultNetworkIconsFunction[] =
     "options.network.NetworkList.setDefaultNetworkIcons";
 const char kShowDetailedInfoFunction[] =
     "options.internet.DetailsInternetPage.showDetailedInfo";
 const char kUpdateConnectionDataFunction[] =
     "options.internet.DetailsInternetPage.updateConnectionData";
 const char kUpdateCarrierFunction[] =
     "options.internet.DetailsInternetPage.updateCarrier";
-const char kUpdateLoggedInUserTypeFunction[] =
-    "options.network.NetworkList.updateLoggedInUserType";
 const char kUpdateSecurityTabFunction[] =
     "options.internet.DetailsInternetPage.updateSecurityTab";
 
 // These are used to register message handlers with JavaScript.
 const char kBuyDataPlanMessage[] = "buyDataPlan";
 const char kChangePinMessage[] = "changePin";
 const char kDisableCellularMessage[] = "disableCellular";
 const char kDisableWifiMessage[] = "disableWifi";
 const char kDisableWimaxMessage[] = "disableWimax";
 const char kEnableCellularMessage[] = "enableCellular";
@@ skipping 60 matching lines @@
 const char kTagTrue[] = "true";
 const char kTagUsername[] = "username";
 const char kTagValue[] = "value";
 const char kTagVpnList[] = "vpnList";
 const char kTagWifiAvailable[] = "wifiAvailable";
 const char kTagWifiEnabled[] = "wifiEnabled";
 const char kTagWimaxAvailable[] = "wimaxAvailable";
 const char kTagWimaxEnabled[] = "wimaxEnabled";
 const char kTagWiredList[] = "wiredList";
 const char kTagWirelessList[] = "wirelessList";
-const char kTagLoggedInUserNone[] = "none";
-const char kTagLoggedInUserRegular[] = "regular";
-const char kTagLoggedInUserOwner[] = "owner";
-const char kTagLoggedInUserGuest[] = "guest";
-const char kTagLoggedInUserRetailMode[] = "retail-mode";
-const char kTagLoggedInUserPublicAccount[] = "public-account";
-const char kTagLoggedInUserLocallyManaged[] = "locally-managed";
-const char kTagLoggedInUserKioskApp[] = "kiosk-app";
 
 const int kPreferredPriority = 1;
 
 void ShillError(const std::string& function,
                 const std::string& error_name,
                 scoped_ptr<base::DictionaryValue> error_data) {
   // UpdateConnectionData may send requests for stale services; ignore
   // these errors.
   if (function == "UpdateConnectionData" &&
       error_name == network_handler::kDBusFailedError)
@@ skipping 12 matching lines @@
                         base::Value* value) {
   NET_LOG_EVENT("SetNetworkProperty: " + property, service_path);
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(property, value);
   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
       service_path, properties,
       base::Bind(&base::DoNothing),
       base::Bind(&ShillError, "SetNetworkProperty"));
 }
 
-std::string LoggedInUserTypeToJSString(LoginState::LoggedInUserType type) {
-  switch (type) {
-    case LoginState::LOGGED_IN_USER_NONE:
-      return kTagLoggedInUserNone;
-    case LoginState::LOGGED_IN_USER_REGULAR:
-      return kTagLoggedInUserRegular;
-    case LoginState::LOGGED_IN_USER_OWNER:
-      return kTagLoggedInUserOwner;
-    case LoginState::LOGGED_IN_USER_GUEST:
-      return kTagLoggedInUserGuest;
-    case LoginState::LOGGED_IN_USER_RETAIL_MODE:
-      return kTagLoggedInUserRetailMode;
-    case LoginState::LOGGED_IN_USER_PUBLIC_ACCOUNT:
-      return kTagLoggedInUserPublicAccount;
-    case LoginState::LOGGED_IN_USER_LOCALLY_MANAGED:
-      return kTagLoggedInUserLocallyManaged;
-    case LoginState::LOGGED_IN_USER_KIOSK_APP:
-      return kTagLoggedInUserKioskApp;
-  }
-  NOTREACHED();
-  return std::string();
-}
-
 // Builds a dictionary with network information and an icon used for the
 // NetworkList on the settings page. Ownership of the returned pointer is
 // transferred to the caller.
 base::DictionaryValue* BuildNetworkDictionary(
     const NetworkState* network,
     float icon_scale_factor,
     const PrefService* profile_prefs) {
   scoped_ptr<base::DictionaryValue> network_info =
       network_util::TranslateNetworkStateToONC(network);
 
@@ skipping 273 matching lines @@
   // These default to empty and are only set if device != NULL.
   std::string carrier_id;
   std::string mdn;
 
   // Device settings.
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           cellular->device_path());
   if (device) {
     const base::DictionaryValue& device_properties = device->properties();
-    const NetworkPropertyUIData cellular_property_ui_data(
-        cellular->ui_data().onc_source());
+    ::onc::ONCSource onc_source;
+    NetworkHandler::Get()->managed_network_configuration_handler()->
+        FindPolicyByGUID(LoginState::Get()->primary_user_hash(),

[pneubeck (no reviews), 2014/07/11 20:35:06]

once we refer to the 'right user' more than once, i'd put it into a helper
function. So that this decision what the right user is, is kept in a single
place.

[stevenjb, 2014/07/11 21:26:10]

That's kind of what LoginState::Get()->primary_user_hash() is supposed to be.
Given that this code is extremely temporary, I'd just as soon not do too much
re-factoring here. The recent NetworkingPrivateApi re-factor I did handles
profiles correctly, and I plan to use that class for NetworkConfig.cc also,
using the profile associated with the WebUI, so everything will be correct and
primary_user_hash() can go away (at least for networking code).

+                         cellular->guid(), &onc_source);
+    const NetworkPropertyUIData cellular_property_ui_data(onc_source);
     SetValueDictionary(dictionary,
                        kTagSimCardLockEnabled,
                        new base::FundamentalValue(device->sim_lock_enabled()),
                        cellular_property_ui_data);
 
     carrier_id = device->home_provider_id();
     device_properties.GetStringWithoutPathExpansion(shill::kMdnProperty, &mdn);
 
     MobileConfig* config = MobileConfig::GetInstance();
     if (config->IsReady()) {
@@ skipping 14 matching lines @@
           base::DictionaryValue* apn = new base::DictionaryValue;
           CreateDictionaryFromCellularApn(dict, apn);
           apn_list_value->Append(apn);
         }
       }
     }
     SetValueDictionary(dictionary,
                        kTagProviderApnList,
                        apn_list_value,
                        cellular_property_ui_data);
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
-            chromeos::switches::kEnableCarrierSwitching)) {
-      const base::ListValue* supported_carriers;
-      if (device_properties.GetListWithoutPathExpansion(
-              shill::kSupportedCarriersProperty, &supported_carriers)) {
-        dictionary->Set(kTagCarriers, supported_carriers->DeepCopy());
-        dictionary->SetInteger(
-            kTagCurrentCarrierIndex,
-            FindCurrentCarrierIndex(supported_carriers, device));
-      } else {
-        // In case of any error, set the current carrier tag to -1 indicating
-        // to the JS code to fallback to a single carrier.
-        dictionary->SetInteger(kTagCurrentCarrierIndex, -1);
-      }
+    const base::ListValue* supported_carriers;
+    if (device_properties.GetListWithoutPathExpansion(
+            shill::kSupportedCarriersProperty, &supported_carriers)) {
+      dictionary->Set(kTagCarriers, supported_carriers->DeepCopy());
+      dictionary->SetInteger(
+          kTagCurrentCarrierIndex,
+          FindCurrentCarrierIndex(supported_carriers, device));
+    } else {
+      // In case of any error, set the current carrier tag to -1 indicating
+      // to the JS code to fallback to a single carrier.
+      dictionary->SetInteger(kTagCurrentCarrierIndex, -1);
     }
   }
 
   // Don't show any account management related buttons if the activation
   // state is unknown or no payment portal URL is available.
   std::string support_url;
   if (cellular->activation_state() == shill::kActivationStateUnknown ||
       !dictionary->GetString(kTagSupportUrl, &support_url) ||
       support_url.empty()) {
     VLOG(2) << "No support URL is available. Don't display buttons.";
@@ skipping 136 matching lines @@
 
 }  // namespace
 
 InternetOptionsHandler::InternetOptionsHandler()
     : weak_factory_(this) {
   registrar_.Add(this, chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_ENTER_PIN_ENDED,
                  content::NotificationService::AllSources());
   NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
-  LoginState::Get()->AddObserver(this);
 }
 
 InternetOptionsHandler::~InternetOptionsHandler() {
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
         this, FROM_HERE);
   }
-  if (LoginState::Get()->IsInitialized())
-    LoginState::Get()->RemoveObserver(this);
 }
 
 void InternetOptionsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
   internet_options_strings::RegisterLocalizedStrings(localized_strings);
 
+  // TODO(stevenjb): Find a better way to populate initial data before

[pneubeck (no reviews), 2014/07/11 20:35:07]

i think, other WebUIs have a kind of handshake:

1) If JS is done loading, it calls to C++.
2) C++ calls back to JS with initial data.

(IIRC the internet_details page does this already?)

[stevenjb, 2014/07/11 21:26:09]

This is being done so that the initial layout doesn't jump. The settings page
takes so long to load that if we wait for the JS to complete we see the layout
shift. I'm planning to dive deeper into the WebUI code to do this properly in
one of the next stages.

+  // InitializePage() gets called.
   std::string owner;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
   localized_strings->SetString("ownerUserId", base::UTF8ToUTF16(owner));
+  bool logged_in_as_owner = LoginState::Get()->GetLoggedInUserType() ==
+                            LoginState::LOGGED_IN_USER_OWNER;
+  localized_strings->SetBoolean("loggedInAsOwner", logged_in_as_owner);
 
   base::DictionaryValue* network_dictionary = new base::DictionaryValue;
   FillNetworkInfo(network_dictionary);
   localized_strings->Set("networkData", network_dictionary);
 }
 
 void InternetOptionsHandler::InitializePage() {
   base::DictionaryValue dictionary;
   dictionary.SetString(::onc::network_type::kCellular,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK));
   dictionary.SetString(::onc::network_type::kWiFi,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK));
   dictionary.SetString(::onc::network_type::kVPN,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_VPN));
   web_ui()->CallJavascriptFunction(kSetDefaultNetworkIconsFunction,
                                    dictionary);
   NetworkHandler::Get()->network_state_handler()->RequestScan();
   RefreshNetworkData();
-  UpdateLoggedInUserType();
 }
 
 void InternetOptionsHandler::RegisterMessages() {
   // Setup handlers specific to this panel.
   web_ui()->RegisterMessageCallback(kNetworkCommandMessage,
       base::Bind(&InternetOptionsHandler::NetworkCommandCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kRefreshNetworksMessage,
       base::Bind(&InternetOptionsHandler::RefreshNetworksCallback,
                  base::Unretained(this)));
@@ skipping 318 matching lines @@
 }
 
 void InternetOptionsHandler::NetworkPropertiesUpdated(
     const NetworkState* network) {
   if (!web_ui())
     return;
   RefreshNetworkData();
   UpdateConnectionData(network->path());
 }
 
-void InternetOptionsHandler::LoggedInStateChanged() {
-  UpdateLoggedInUserType();
-}
-
-void InternetOptionsHandler::UpdateLoggedInUserType() {
-  if (!web_ui())
-    return;
-  base::StringValue login_type(
-      LoggedInUserTypeToJSString(LoginState::Get()->GetLoggedInUserType()));
-  web_ui()->CallJavascriptFunction(kUpdateLoggedInUserTypeFunction, login_type);
-}
-
 void InternetOptionsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED) {
     base::FundamentalValue require_pin(*content::Details<bool>(details).ptr());
     web_ui()->CallJavascriptFunction(
         kUpdateSecurityTabFunction, require_pin);
   } else if (type == chrome::NOTIFICATION_ENTER_PIN_ENDED) {
     // We make an assumption (which is valid for now) that the SIM
@@ skipping 462 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos