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

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "third_party/cros/chromeos_network.h"
 
 namespace base {
 class DictionaryValue;
 class Value;
 }
 
 namespace chromeos {
 
+class Network;
 class NetworkDeviceParser;
 class NetworkParser;
 
 // This is the list of all implementation classes that are allowed
 // access to the internals of the network library classes.
 #define NETWORK_LIBRARY_IMPL_FRIENDS            \
   friend class NetworkLibraryImplBase;          \
   friend class NetworkLibraryImplCros;          \
   friend class NetworkLibraryImplStub;
 
@@ skipping 317 matching lines @@
   std::string language;
 
   CellularApn();
   CellularApn(const std::string& apn, const std::string& network_id,
       const std::string& username, const std::string& password);
   ~CellularApn();
   void Set(const base::DictionaryValue& dict);
 };
 typedef std::vector<CellularApn> CellularApnList;
 
+// Holds meta information for a network property: Whether the property is under
+// policy control, if it is user-editable, and whether the policy-provided
+// default value, if applicable.
+class NetworkPropertyUIData {
+ public:
+  // Enum values indicating the entity controlling the property.
+  enum Controller {
+    // Property is managed by policy.
+    CONTROLLER_POLICY,
+    // The user controls the policy.
+    CONTROLLER_USER,
+  };
+
+  // Initializes an empty object.
+  NetworkPropertyUIData();
+
+  // Updates the object from the network-level UI data. |property_key| may be
+  // null, in which case the there'll be no default value and |controller| will
+  // be set to CONTROLLER_POLICY iff the network is managed.
+  void UpdateFromNetwork(const Network* network, const char* property_key);
+
+  Controller controller() const { return controller_; }
+  const base::Value* default_value() const { return default_value_.get(); }
+  bool editable() const { return controller() != CONTROLLER_POLICY; }
+
+ private:
+  Controller controller_;
+  scoped_ptr<base::Value> default_value_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkPropertyUIData);
+};

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

I think this would be better in its own file. network_library is already too
large, and I think that separating this would make it more clear that this is a
separate class, not really tied directly to NetworkLibrary.

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

Done.

+
 // Cellular network is considered low data when less than 60 minues.
 static const int kCellularDataLowSecs = 60 * 60;
 
 // Cellular network is considered low data when less than 30 minues.
 static const int kCellularDataVeryLowSecs = 30 * 60;
 
 // Cellular network is considered low data when less than 100MB.
 static const int kCellularDataLowBytes = 100 * 1024 * 1024;
 
 // Cellular network is considered very low data when less than 50MB.
 static const int kCellularDataVeryLowBytes = 50 * 1024 * 1024;
 
 // The value of priority if it is not set.
 const int kPriorityNotSet = 0;
 // The value of priority if network is preferred.
 const int kPriorityPreferred = 1;
 
 // Keys used in the UI data dictionary.
 
 // Source of the ONC network. This is an integer according to enum ONCSource.
 extern const char kUIDataKeyONCSource[];
+extern const char kUIDataKeyProperties[];
+extern const char kUIDataKeyPropertiesController[];
+extern const char kUIDataKeyPropertiesControllerPolicy[];
+extern const char kUIDataKeyPropertiesControllerUser[];
+extern const char kUIDataKeyPropertiesDefaultValue[];
+
+// Names of the properties stored in the dictionary under
+// kUIDataKeyPropertiesController.
+extern const char kUIDataPropertyAutoConnect[];
+extern const char kUIDataPropertyPreferred[];
 
 // Contains data related to the flimflam.Device interface,
 // e.g. ethernet, wifi, cellular.
 // TODO(dpolukhin): refactor to make base class and device specific derivatives.
 class NetworkDevice {
  public:
   explicit NetworkDevice(const std::string& device_path);
   ~NetworkDevice();
 
   NetworkDeviceParser* device_parser() { return device_parser_.get(); }
@@ skipping 230 matching lines @@
 
   bool added() const { return added_; }
   bool notify_failure() const { return notify_failure_; }
   const std::string& profile_path() const { return profile_path_; }
   NetworkProfileType profile_type() const { return profile_type_; }
 
   const std::string& unique_id() const { return unique_id_; }
   int priority_order() const { return priority_order_; }
 
   const std::string& proxy_config() const { return proxy_config_; }
+
   const DictionaryValue* ui_data() const { return &ui_data_; }
   DictionaryValue* ui_data() { return &ui_data_; }
 
   void set_notify_failure(bool state) { notify_failure_ = state; }
 
   void SetPreferred(bool preferred);
 
   void SetAutoConnect(bool auto_connect);
 
   void SetName(const std::string& name);
 
   void SetSaveCredentials(bool save_credentials);
 
   // Return a string representation of the state code.
   std::string GetStateString() const;
 
   // Return a string representation of the error code.
   std::string GetErrorString() const;
 
   void SetProxyConfig(const std::string& proxy_config);
 
   // Return true if the network must be in the user profile (e.g. has certs).
   virtual bool RequiresUserProfile() const;
 
   // Copy any credentials from a remembered network that are unset in |this|.
   virtual void CopyCredentialsFromRemembered(Network* remembered);
 
+  // Accessors returning policy management state information.
+  bool IsManagedByPolicy() const;
+  void GetUIDataForPreferred(NetworkPropertyUIData* ui_data) const;
+  void GetUIDataForAutoConnect(NetworkPropertyUIData* ui_data) const;
+  void GetUIDataForIPConfig(NetworkPropertyUIData* ui_data) const;

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

These last three seem unnecessary. Why not just call
ui_data->UpdateFromNetwork(network)?

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

Obsolete in the new version.

+
   // Static helper functions.
   static bool IsConnectedState(ConnectionState state) {
     return (state == STATE_READY ||
             state == STATE_ONLINE ||
             state == STATE_PORTAL);
   }
   static bool IsConnectingState(ConnectionState state) {
     return (state == STATE_ASSOCIATION ||
             state == STATE_CONFIGURATION ||
             state == STATE_CARRIER);
@@ skipping 35 matching lines @@
   virtual void SetBooleanProperty(const char* prop, bool b, bool* dest);
   virtual void SetIntegerProperty(const char* prop, int i, int* dest);
   virtual void SetValueProperty(const char* prop, base::Value* val);
   virtual void ClearProperty(const char* prop);
 
   // This will clear the property if string is empty. Otherwise, it will set it.
   virtual void SetOrClearStringProperty(const char* prop,
                                         const std::string& str,
                                         std::string* dest);
 
+  // Check whether a property is configured by policy and should thus not be
+  // editable by the user.
+  bool IsManaged(const char* prop);

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

This appears to be unimplemented?

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

Good catch, this is a leftover. Removed.

+
   void set_unique_id(const std::string& unique_id) { unique_id_ = unique_id; }
 
  private:
   // This allows NetworkParser and its subclasses access to device
   // privates so that they can be reconstituted during parsing.  The
   // parsers only access things through the private set_ functions so
   // that this class can evolve without having to change all the
   // parsers.
   friend class NetworkParser;
   friend class NativeNetworkParser;
@@ skipping 1030 matching lines @@
                                 const std::string& service_path) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_