Enable policy support for registering protocol handler.

components/policy/core/browser/configuration_policy_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 "components/policy/core/browser/configuration_policy_handler.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ skipping 350 matching lines @@
 
   if (errors && !error.empty()) {
     if (error_path.empty())
       error_path = "(ROOT)";
     errors->AddError(policy_name_, error_path, error);
   }
 
   return result;
 }
 
+// SimpleSchemaValidatingPolicyHandler implementation --------------------------
+
+SimpleSchemaValidatingPolicyHandler::SimpleSchemaValidatingPolicyHandler(
+    const char* policy_name,
+    const char* pref_path,
+    Schema schema,
+    SchemaOnErrorStrategy strategy,
+    bool recommended,
+    bool mandatory)
+    : SchemaValidatingPolicyHandler(policy_name,
+                                    schema.GetKnownProperty(policy_name),
+                                    strategy),
+      pref_path_(pref_path),
+      recommended_(recommended),
+      mandatory_(mandatory) {
+}
+
+SimpleSchemaValidatingPolicyHandler::SimpleSchemaValidatingPolicyHandler(

[bartfab (slow), 2014/06/03 11:58:21]

Nit: Reorder these constructors so that the implementation order matches the
declaration order.

[kaliamoorthi, 2014/06/04 18:01:58]

Done.

+    const char* policy_name,
+    const char* pref_path,
+    Schema schema,
+    SchemaOnErrorStrategy strategy)
+    : SchemaValidatingPolicyHandler(policy_name,
+                                    schema.GetKnownProperty(policy_name),
+                                    strategy),
+      pref_path_(pref_path),
+      recommended_(true),
+      mandatory_(true) {
+}
+
+SimpleSchemaValidatingPolicyHandler::~SimpleSchemaValidatingPolicyHandler() {
+}
+
+bool SimpleSchemaValidatingPolicyHandler::CheckPolicySettings(
+    const PolicyMap& policies,
+    PolicyErrorMap* errors) {
+  const PolicyMap::Entry* policy_entry =
+      policies.Get(SchemaValidatingPolicyHandler::policy_name());

[bartfab (slow), 2014/06/03 11:58:21]

Nit: No need for the SchemaValidatingPolicyHandler:: here.

[kaliamoorthi, 2014/06/04 18:01:58]

Done.

+  if (!policy_entry)
+    return false;

[bartfab (slow), 2014/06/03 11:58:21]

SchemaValidatingPolicyHandler returns |true| if there is no setting for the
current policy. Are you sure that returning |false| instead is the right thing
to do?

[kaliamoorthi, 2014/06/04 18:01:58]

Done.

+  if ((policy_entry->level == policy::POLICY_LEVEL_MANDATORY && !mandatory_) ||
+      (policy_entry->level == policy::POLICY_LEVEL_RECOMMENDED &&
+       !recommended_)) {
+    if (errors != NULL)

[bartfab (slow), 2014/06/03 11:58:21]

Nit: "if (errors)" is sufficient

[kaliamoorthi, 2014/06/04 18:01:58]

Done.

+      errors->AddError(policy_name(), IDS_POLICY_LEVEL_ERROR);
+    return false;
+  }
+
+  return SchemaValidatingPolicyHandler::CheckPolicySettings(policies, errors);
+}
+
+void SimpleSchemaValidatingPolicyHandler::ApplyPolicySettings(
+    const PolicyMap& policies,
+    PrefValueMap* prefs) {
+  if (!pref_path_)
+    return;
+  const base::Value* value = policies.GetValue(policy_name());
+  if (value)
+    prefs->SetValue(pref_path_, value->DeepCopy());
+}
+
 // LegacyPoliciesDeprecatingPolicyHandler implementation -----------------------
 
 // TODO(binjin): Add a new common base class for SchemaValidatingPolicyHandler
 // and TypeCheckingPolicyHandler representing policy handlers for a single
 // policy, and use it as the type of |new_policy_handler|.
 // http://crbug.com/345299
 LegacyPoliciesDeprecatingPolicyHandler::LegacyPoliciesDeprecatingPolicyHandler(
     ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers,
     scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler)
     : legacy_policy_handlers_(legacy_policy_handlers.Pass()),
@@ skipping 35 matching lines @@
     for (handler = legacy_policy_handlers_.begin();
          handler != legacy_policy_handlers_.end();
          ++handler) {
       if ((*handler)->CheckPolicySettings(policies, &scoped_errors))
         (*handler)->ApplyPolicySettings(policies, prefs);
     }
   }
 }
 
 }  // namespace policy