Plumbing for login apps device policy to extensions.

chrome/browser/extensions/policy_handlers.cc

 // Copyright 2013 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/extensions/policy_handlers.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 81 matching lines @@
     }
     filtered_list->AppendString(id);
   }
 
   if (extension_ids)
     *extension_ids = std::move(filtered_list);
 
   return true;
 }
 
-// ExtensionInstallForcelistPolicyHandler implementation -----------------------
+// ExtensionInstallListPolicyHandler implementation ----------------------------
 
-ExtensionInstallForcelistPolicyHandler::ExtensionInstallForcelistPolicyHandler()
-    : policy::TypeCheckingPolicyHandler(policy::key::kExtensionInstallForcelist,
-                                        base::Value::TYPE_LIST) {}
+ExtensionInstallListPolicyHandler::ExtensionInstallListPolicyHandler(
+    const char* policy_name,
+    const char* pref_name)
+    : policy::TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
+      pref_name_(pref_name) {}
 
-ExtensionInstallForcelistPolicyHandler::
-    ~ExtensionInstallForcelistPolicyHandler() {}
+ExtensionInstallListPolicyHandler::~ExtensionInstallListPolicyHandler() {}
 
-bool ExtensionInstallForcelistPolicyHandler::CheckPolicySettings(
+bool ExtensionInstallListPolicyHandler::CheckPolicySettings(
     const policy::PolicyMap& policies,
     policy::PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
-      ParseList(value, NULL, errors);
+         ParseList(value, nullptr, errors);
 }
 
-void ExtensionInstallForcelistPolicyHandler::ApplyPolicySettings(
+void ExtensionInstallListPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& policies,
     PrefValueMap* prefs) {
-  const base::Value* value = NULL;
+  const base::Value* value = nullptr;
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  if (CheckAndGetValue(policies, NULL, &value) &&
-      value &&
-      ParseList(value, dict.get(), NULL)) {
-    prefs->SetValue(pref_names::kInstallForceList, std::move(dict));
+  if (CheckAndGetValue(policies, nullptr, &value) && value &&
+      ParseList(value, dict.get(), nullptr)) {
+    prefs->SetValue(pref_name(), std::move(dict));
   }
 }
 
-bool ExtensionInstallForcelistPolicyHandler::ParseList(
+bool ExtensionInstallListPolicyHandler::ParseList(
     const base::Value* policy_value,
     base::DictionaryValue* extension_dict,
     policy::PolicyErrorMap* errors) {
   if (!policy_value)
     return true;
 
-  const base::ListValue* policy_list_value = NULL;
+  const base::ListValue* policy_list_value = nullptr;
   if (!policy_value->GetAsList(&policy_list_value)) {
     // This should have been caught in CheckPolicySettings.
     NOTREACHED();
     return false;
   }
 
   for (base::ListValue::const_iterator entry(policy_list_value->begin());
        entry != policy_list_value->end(); ++entry) {
     std::string entry_string;
     if (!(*entry)->GetAsString(&entry_string)) {
@@ skipping 11 matching lines @@
     size_t pos = entry_string.find(';');
     if (pos == std::string::npos) {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - policy_list_value->begin(),
                          IDS_POLICY_VALUE_FORMAT_ERROR);
       }
       continue;
     }
 
-    std::string extension_id = entry_string.substr(0, pos);
-    std::string update_url = entry_string.substr(pos+1);
+    const std::string extension_id = entry_string.substr(0, pos);
+    const std::string update_url = entry_string.substr(pos + 1);
     if (!crx_file::id_util::IdIsValid(extension_id) ||
         !GURL(update_url).is_valid()) {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - policy_list_value->begin(),
                          IDS_POLICY_VALUE_FORMAT_ERROR);
       }
       continue;
     }
 
     if (extension_dict) {
-      extensions::ExternalPolicyLoader::AddExtension(
-          extension_dict, extension_id, update_url);
+      ExternalPolicyLoader::AddExtension(extension_dict, extension_id,
+                                         update_url);
     }
   }
 
   return true;
 }
 
+// ExtensionInstallForcelistPolicyHandler implementation -----------------------
+
+ExtensionInstallForcelistPolicyHandler::ExtensionInstallForcelistPolicyHandler()
+    : ExtensionInstallListPolicyHandler(policy::key::kExtensionInstallForcelist,
+                                        pref_names::kInstallForceList) {}
+
+ExtensionInstallForcelistPolicyHandler::
+    ~ExtensionInstallForcelistPolicyHandler() {}
+
+// ExtensionInstallSigninlistPolicyHandler implementation
+// -----------------------

[Devlin, 2017/03/01 16:15:00]

nit: no need for a new line with this.

+
+ExtensionInstallSigninListPolicyHandler::
+    ExtensionInstallSigninListPolicyHandler()
+    : ExtensionInstallListPolicyHandler(policy::key::kLoginApps,
+                                        pref_names::kInstallSigninList) {}
+
+ExtensionInstallSigninListPolicyHandler::
+    ~ExtensionInstallSigninListPolicyHandler() {}
+
 // ExtensionURLPatternListPolicyHandler implementation -------------------------
 
 ExtensionURLPatternListPolicyHandler::ExtensionURLPatternListPolicyHandler(
     const char* policy_name,
     const char* pref_path)
     : policy::TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
       pref_path_(pref_path) {}
 
 ExtensionURLPatternListPolicyHandler::~ExtensionURLPatternListPolicyHandler() {}
 
@@ skipping 116 matching lines @@
 void ExtensionSettingsPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& policies,
     PrefValueMap* prefs) {
   std::unique_ptr<base::Value> policy_value;
   if (!CheckAndGetValue(policies, NULL, &policy_value) || !policy_value)
     return;
   prefs->SetValue(pref_names::kExtensionManagement, std::move(policy_value));
 }
 
 }  // namespace extensions