Disable UI in chrome://settings/internet and details popup for policy-managed networks.

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 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/cros/network_library.h"
 
 #include <dbus/dbus-glib.h>
 #include <dbus/dbus-gtype-specialized.h>
 #include <glib-object.h>
 
@@ skipping 10 matching lines @@
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversion_utils.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/native_network_constants.h"
 #include "chrome/browser/chromeos/cros/native_network_parser.h"
 #include "chrome/browser/chromeos/cros/onc_network_parser.h"
+#include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/network_login_observer.h"
 #include "chrome/common/time_format.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/nss_util.h"  // crypto::GetTPMTokenInfo() for 802.1X and VPN.
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"
 
 using content::BrowserThread;
@@ skipping 289 matching lines @@
 void DumpDictionaryValue(const char* desc, const base::DictionaryValue* dict) {
   std::string json;
   base::JSONWriter::Write(dict, false, &json);
   LOG(WARNING) << desc << ": " << json;
 }
 
 }  // namespace
 
 // UI data keys.
 const char kUIDataKeyONCSource[] = "onc_source";
+const char kUIDataKeyProperties[] = "properties";
+const char kUIDataKeyPropertiesController[] = "controller";
+const char kUIDataKeyPropertiesControllerPolicy[] = "policy";
+const char kUIDataKeyPropertiesControllerUser[] = "user";
+const char kUIDataKeyPropertiesDefaultValue[] = "default_value";
+
+const char kUIDataPropertyAutoConnect[] = "auto_connect";
+const char kUIDataPropertyPreferred[] = "preferred";
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkPropertyUIData
+
+NetworkPropertyUIData::NetworkPropertyUIData()
+  : controller_(CONTROLLER_USER) {}
+
+void NetworkPropertyUIData::UpdateFromNetwork(const Network* network,
+                                              const char* property_key) {
+  // Initialize to defaults.

[stevenjb, 2011/11/29 07:23:19]

This comment confused me, since setting controller_ seems to be the entire
purpose of this function if property_key is NULL. 

[Mattias Nissler (ping if slow), 2011/11/29 14:48:50]

You are right. I clarified the comment.

+  controller_ =
+      network->IsManagedByPolicy() ? CONTROLLER_POLICY : CONTROLLER_USER;
+  default_value_.reset();
+
+  if (!property_key)
+    return;
+
+  const DictionaryValue* ui_data = network->ui_data();
+  if (!ui_data)
+    return;
+
+  base::DictionaryValue* property_map = NULL;
+  if (!ui_data->GetDictionary(kUIDataKeyProperties, &property_map))
+    return;
+
+  base::DictionaryValue* property = NULL;
+  if (!property_map->GetDictionary(property_key, &property))
+    return;
+
+  std::string controller;
+  if (property->GetString(kUIDataKeyPropertiesController, &controller)) {
+    if (controller == kUIDataKeyPropertiesControllerPolicy)
+      controller_ = CONTROLLER_POLICY;
+    else if (controller == kUIDataKeyPropertiesControllerUser)
+      controller_ = CONTROLLER_USER;
+  }
+
+  base::Value* default_value = NULL;
+  property->Get(kUIDataKeyPropertiesDefaultValue, &default_value);
+  default_value_.reset(default_value);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // FoundCellularNetwork
 
 FoundCellularNetwork::FoundCellularNetwork() {}
 
 FoundCellularNetwork::~FoundCellularNetwork() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkDevice
@@ skipping 102 matching lines @@
   unique_id_ = name_;
 }
 
 bool Network::RequiresUserProfile() const {
   return false;
 }
 
 void Network::CopyCredentialsFromRemembered(Network* remembered) {
 }
 
+bool Network::IsManagedByPolicy() const {
+  int source_value = 0;
+  if (ui_data()->GetInteger(chromeos::kUIDataKeyONCSource, &source_value)) {
+    chromeos::ONCSource source = static_cast<chromeos::ONCSource>(source_value);
+    return source == chromeos::ONC_SOURCE_DEVICE_POLICY ||
+           source == chromeos::ONC_SOURCE_USER_POLICY;
+  }
+
+  return false;
+}
+
+void Network::GetUIDataForPreferred(NetworkPropertyUIData* ui_data) const {
+  ui_data->UpdateFromNetwork(this, kUIDataPropertyPreferred);
+}
+
+void Network::GetUIDataForAutoConnect(NetworkPropertyUIData* ui_data) const {
+  ui_data->UpdateFromNetwork(this, kUIDataPropertyAutoConnect);
+}
+
+void Network::GetUIDataForIPConfig(NetworkPropertyUIData* ui_data) const {
+  ui_data->UpdateFromNetwork(this, NULL);
+}
+
 void Network::SetValueProperty(const char* prop, Value* value) {
   DCHECK(prop);
   DCHECK(value);
   if (!EnsureCrosLoaded())
     return;
   scoped_ptr<GValue> gvalue(ConvertValueToGValue(value));
   chromeos::SetNetworkServicePropertyGValue(
       service_path_.c_str(), prop, gvalue.get());
 }
 
@@ skipping 4395 matching lines @@
       (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) | (1 << TYPE_CELLULAR);
   available_devices_ = devices;
   enabled_devices_ = devices;
   connected_devices_ = devices;
 
   NetworkDevice* cellular = new NetworkDevice("cellular");
   cellular->type_ = TYPE_CELLULAR;
   cellular->imsi_ = "123456789012345";
   device_map_["cellular"] = cellular;
 
+  CellularApn apn;
+  apn.apn = "apn";
+  apn.network_id = "network_id";
+  apn.username = "username";
+  apn.password = "password";
+  apn.name = "name";
+  apn.localized_name = "localized_name";
+  apn.language = "language";
+
+  CellularApnList apn_list;
+  apn_list.push_back(apn);
+
+  NetworkDevice* cellular_gsm = new NetworkDevice("cellular_gsm");
+  cellular_gsm->type_ = TYPE_CELLULAR;
+  cellular_gsm->set_technology_family(TECHNOLOGY_FAMILY_GSM);
+  cellular_gsm->imsi_ = "123456789012345";
+  cellular_gsm->set_sim_pin_required(SIM_PIN_REQUIRED);
+  cellular_gsm->set_provider_apn_list(apn_list);
+  device_map_["cellular_gsm"] = cellular_gsm;
+
   // Profiles
   AddProfile("default", PROFILE_SHARED);
   AddProfile("user", PROFILE_USER);
 
   // Networks
   // If these change, the expectations in network_library_unittest and
   // network_menu_icon_unittest need to be changed also.
 
   // Networks are added in priority order.
   network_priority_order_ = 0;
@@ skipping 39 matching lines @@
   wifi5->SetSsid("Fake WiFi5 UTF-8 SSID \u3042\u3044\u3046");
   wifi5->set_strength(25);
   AddStubNetwork(wifi5, PROFILE_NONE);
 
   WifiNetwork* wifi6 = new WifiNetwork("wifi6");
   wifi6->set_name("Fake WiFi6 latin-1 SSID ");
   wifi6->SetSsid("Fake WiFi6 latin-1 SSID \xc0\xcb\xcc\xd6\xfb");
   wifi6->set_strength(20);
   AddStubNetwork(wifi6, PROFILE_NONE);
 
+  WifiNetwork* wifi7 = new WifiNetwork("wifi7");
+  wifi7->set_name("Fake Wifi7 (policy-managed)");
+  wifi7->ui_data()->SetInteger("onc_source", ONC_SOURCE_DEVICE_POLICY);
+  AddStubNetwork(wifi7, PROFILE_USER);
+
   CellularNetwork* cellular1 = new CellularNetwork("cellular1");
-  cellular1->set_name("Fake Cellular1");
+  cellular1->set_name("Fake Cellular 1");
   cellular1->set_strength(100);
   cellular1->set_connected(true);
   cellular1->set_activation_state(ACTIVATION_STATE_ACTIVATED);
   cellular1->set_payment_url(std::string("http://www.google.com"));
   cellular1->set_usage_url(std::string("http://www.google.com"));
   cellular1->set_network_technology(NETWORK_TECHNOLOGY_EVDO);
   AddStubNetwork(cellular1, PROFILE_NONE);
 
   CellularNetwork* cellular2 = new CellularNetwork("cellular2");
-  cellular2->set_name("Fake Cellular2");
+  cellular2->set_name("Fake Cellular 2");
   cellular2->set_strength(50);
   cellular2->set_activation_state(ACTIVATION_STATE_NOT_ACTIVATED);
   cellular2->set_network_technology(NETWORK_TECHNOLOGY_UMTS);
   cellular2->set_roaming_state(ROAMING_STATE_ROAMING);
   AddStubNetwork(cellular2, PROFILE_NONE);
 
+  CellularNetwork* cellular3 = new CellularNetwork("cellular3");
+  cellular3->set_name("Fake Cellular 3 (policy-managed)");
+  cellular3->set_device_path(cellular->device_path());
+  cellular3->set_activation_state(ACTIVATION_STATE_ACTIVATED);
+  cellular3->set_network_technology(NETWORK_TECHNOLOGY_EVDO);
+  cellular3->ui_data()->SetInteger("onc_source", ONC_SOURCE_USER_POLICY);
+  AddStubNetwork(cellular3, PROFILE_NONE);
+
+  CellularNetwork* cellular4 = new CellularNetwork("cellular4");
+  cellular4->set_name("Fake Cellular 4 (policy-managed)");
+  cellular4->set_device_path(cellular_gsm->device_path());
+  cellular4->set_activation_state(ACTIVATION_STATE_ACTIVATED);
+  cellular4->set_network_technology(NETWORK_TECHNOLOGY_GSM);
+  cellular4->ui_data()->SetInteger("onc_source", ONC_SOURCE_USER_POLICY);
+  AddStubNetwork(cellular4, PROFILE_NONE);
+
   CellularDataPlan* base_plan = new CellularDataPlan();
   base_plan->plan_name = "Base plan";
   base_plan->plan_type = CELLULAR_DATA_PLAN_METERED_BASE;
   base_plan->plan_data_bytes = 100ll * 1024 * 1024;
   base_plan->data_bytes_used = base_plan->plan_data_bytes / 4;
 
   CellularDataPlan* paid_plan = new CellularDataPlan();
   paid_plan->plan_name = "Paid plan";
   paid_plan->plan_type = CELLULAR_DATA_PLAN_METERED_PAID;
   paid_plan->plan_data_bytes = 5ll * 1024 * 1024 * 1024;
@@ skipping 17 matching lines @@
   vpn2->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
   vpn2->set_username("VPN User 2");
   AddStubNetwork(vpn2, PROFILE_USER);
 
   VirtualNetwork* vpn3 = new VirtualNetwork("vpn3");
   vpn3->set_name("Fake VPN3");
   vpn3->set_server_hostname("vpn3server.fake.com");
   vpn3->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
   AddStubNetwork(vpn3, PROFILE_USER);
 
+  VirtualNetwork* vpn4 = new VirtualNetwork("vpn4");
+  vpn4->set_name("Fake VPN4 (policy-managed)");
+  vpn4->set_server_hostname("vpn4server.fake.com");
+  vpn4->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
+  vpn4->ui_data()->SetInteger("onc_source", ONC_SOURCE_DEVICE_POLICY);
+  AddStubNetwork(vpn4, PROFILE_USER);

[stevenjb, 2011/11/29 07:23:19]

Make sure that these changes don't break the unit tests. You might want to put
them in a separate CL.

[Mattias Nissler (ping if slow), 2011/11/29 14:48:50]

Done.

+
   wifi_scanning_ = false;
   offline_mode_ = false;
 
   // Ensure our active network is connected and vice versa, otherwise our
   // autotest browser_tests sometimes conclude the device is offline.
   CHECK(active_network()->connected());
   CHECK(connected_network()->is_active());
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ skipping 234 matching lines @@
   return impl;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until its last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);