Surface error messages from ONC parsing in about:policy.

chrome/browser/policy/configuration_policy_handler.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/policy/configuration_policy_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "grit/generated_resources.h"
 #include "policy/configuration_policy_type.h"
 #include "policy/policy_constants.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/policy/configuration_policy_handler_chromeos.h"
+#endif
+
 namespace policy {
 
 namespace {
 
 // Implementations of ConfigurationPolicyHandler -------------------------------
 
-// Abstract class derived from ConfigurationPolicyHandler that should be
-// subclassed to handle a single policy (not a combination of policies).
-class TypeCheckingPolicyHandler : public ConfigurationPolicyHandler {
- public:
-  TypeCheckingPolicyHandler(ConfigurationPolicyType policy_type,
-                            base::Value::Type value_type);
-
-  // ConfigurationPolicyHandler methods:
-  virtual bool CheckPolicySettings(const PolicyMap* policies,
-                                   PolicyErrorMap* errors) OVERRIDE;
-
- protected:
-  virtual ~TypeCheckingPolicyHandler();
-
-  ConfigurationPolicyType policy_type() const;
-
- private:
-  // The ConfigurationPolicyType of the policy.
-  ConfigurationPolicyType policy_type_;
-
-  // The type the value of the policy should have.
-  base::Value::Type value_type_;
-
-  DISALLOW_COPY_AND_ASSIGN(TypeCheckingPolicyHandler);
-};
-
 // ConfigurationPolicyHandler for policies that map directly to a preference.
 class SimplePolicyHandler : public TypeCheckingPolicyHandler {
  public:
   SimplePolicyHandler(ConfigurationPolicyType policy_type,
                       base::Value::Type value_type,
                       const char* pref_path);
   virtual ~SimplePolicyHandler();
 
   // ConfigurationPolicyHandler methods:
   virtual void ApplyPolicySettings(const PolicyMap* policies,
@@ skipping 173 matching lines @@
   // Converts the deprecated ProxyServerMode policy value to a ProxyMode value
   // and places the result in |mode_value|. Returns true if the conversion
   // succeeded and false otherwise.
   bool CheckProxyModeAndServerMode(const PolicyMap* policies,
                                    PolicyErrorMap* errors,
                                    std::string* mode_value);
 
   DISALLOW_COPY_AND_ASSIGN(ProxyPolicyHandler);
 };
 
-//
+// ConfigurationPolicyHandler for policies that enable/disable Javascript.
 class JavascriptPolicyHandler : public ConfigurationPolicyHandler {
  public:
   JavascriptPolicyHandler();
   virtual ~JavascriptPolicyHandler();
 
   // ConfigurationPolicyHandler methods:
   virtual bool CheckPolicySettings(const PolicyMap* policies,
                                    PolicyErrorMap* errors) OVERRIDE;
   virtual void ApplyPolicySettings(const PolicyMap* policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(JavascriptPolicyHandler);
 };
 
-
 // Helper classes --------------------------------------------------------------
 
 // Implementation of SearchTermsData just for validation.
 class SearchTermsDataForValidation : public SearchTermsData {
  public:
   SearchTermsDataForValidation() {}
 
   // Implementation of SearchTermsData.
   virtual std::string GoogleBaseURLValue() const {
     return "http://www.google.com/";
@@ skipping 245 matching lines @@
     "string",
     "binary",
     "dictionary",
     "list"
   };
   DCHECK(static_cast<size_t>(type) < arraysize(strings));
   return std::string(strings[type]);
 }
 
 
-// TypeCheckingPolicyHandler implementation ------------------------------------
-
-TypeCheckingPolicyHandler::TypeCheckingPolicyHandler(
-    ConfigurationPolicyType policy_type,
-    Value::Type value_type)
-    : policy_type_(policy_type),
-      value_type_(value_type) {
-}
-
-TypeCheckingPolicyHandler::~TypeCheckingPolicyHandler() {
-}
-
-ConfigurationPolicyType TypeCheckingPolicyHandler::policy_type() const {
-  return policy_type_;
-}
-
-bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap* policies,
-                                                    PolicyErrorMap* errors) {
-  const Value* value = policies->Get(policy_type_);
-  if (value && value_type_ != value->GetType()) {
-    errors->AddError(policy_type_,
-                     IDS_POLICY_TYPE_ERROR,
-                     ValueTypeToString(value_type_));
-    return false;
-  }
-  return true;
-}
-
-
 // SimplePolicyHandler implementation ------------------------------------------
 
 SimplePolicyHandler::SimplePolicyHandler(
     ConfigurationPolicyType policy_type,
     Value::Type value_type,
     const char* pref_path)
     : TypeCheckingPolicyHandler(policy_type, value_type),
       pref_path_(pref_path) {
 }
 
@@ skipping 706 matching lines @@
     // javascript globally.
     if (!enabled)
       setting = CONTENT_SETTING_BLOCK;
   }
 
   if (setting != CONTENT_SETTING_DEFAULT)
     prefs->SetValue(prefs::kManagedDefaultJavaScriptSetting,
                     Value::CreateIntegerValue(setting));
 }
 
-
 }  // namespace
 
 
 // ConfigurationPolicyHandler implementation -----------------------------------
 
 // static
 ConfigurationPolicyHandler::HandlerList*
     ConfigurationPolicyHandler::CreateHandlerList() {
   HandlerList* list = new HandlerList;
 
@@ skipping 10 matching lines @@
   list->push_back(new FileSelectionDialogsHandler());
   list->push_back(new IncognitoModePolicyHandler());
   list->push_back(new JavascriptPolicyHandler());
   list->push_back(new ProxyPolicyHandler());
   list->push_back(new SyncPolicyHandler());
 
 #if !defined(OS_CHROMEOS)
   list->push_back(new DownloadDirPolicyHandler());
 #endif  // !defined(OS_CHROME0S)
 
+#if defined(OS_CHROMEOS)
+  list->push_back(
+      new NetworkConfigurationPolicyHandler(
+          kPolicyDeviceOpenNetworkConfiguration));
+  list->push_back(
+      new NetworkConfigurationPolicyHandler(
+          kPolicyOpenNetworkConfiguration));
+#endif
+
   return list;
 }
 
+// TypeCheckingPolicyHandler implementation ------------------------------------
+
+TypeCheckingPolicyHandler::TypeCheckingPolicyHandler(
+    ConfigurationPolicyType policy_type,
+    Value::Type value_type)
+    : policy_type_(policy_type),
+      value_type_(value_type) {
+}
+
+TypeCheckingPolicyHandler::~TypeCheckingPolicyHandler() {
+}
+
+ConfigurationPolicyType TypeCheckingPolicyHandler::policy_type() const {
+  return policy_type_;
+}
+
+bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap* policies,
+                                                    PolicyErrorMap* errors) {
+  const Value* value = NULL;
+  return CheckAndGetValue(policies, errors, &value);
+}
+
+bool TypeCheckingPolicyHandler::CheckAndGetValue(const PolicyMap* policies,
+                                                 PolicyErrorMap* errors,
+                                                 const Value** value) {
+  *value = policies->Get(policy_type_);
+  if (*value && !(*value)->IsType(value_type_)) {
+    errors->AddError(policy_type_,
+                     IDS_POLICY_TYPE_ERROR,
+                     ValueTypeToString(value_type_));
+    return false;
+  }
+  return true;
+}
+
 }  // namespace policy