Dynamic policy refresh support for the Mac.

chrome/browser/policy/configuration_policy_pref_store.cc

 // Copyright (c) 2010 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_pref_store.h"
 
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "base/string16.h"
@@ skipping 34 matching lines @@
 
   ConfigurationPolicyProvider* recommended_provider() const {
     return recommended_provider_.get();
   }
 
  private:
   scoped_ptr<ConfigurationPolicyProvider> managed_provider_;
   scoped_ptr<ConfigurationPolicyProvider> recommended_provider_;
 
   static ConfigurationPolicyProvider* CreateManagedProvider() {
-    const ConfigurationPolicyProvider::StaticPolicyValueMap& policy_map =
-        ConfigurationPolicyPrefStore::GetChromePolicyValueMap();
+    const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
+        ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 #if defined(OS_WIN)
-    return new ConfigurationPolicyProviderWin(policy_map);
+    return new ConfigurationPolicyProviderWin(policy_list);
 #elif defined(OS_MACOSX)
-    return new ConfigurationPolicyProviderMac(policy_map);
+    return new ConfigurationPolicyProviderMac(policy_list);
 #elif defined(OS_POSIX)
     FilePath config_dir_path;
     if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
-      return new ConfigDirPolicyProvider(policy_map,
+      return new ConfigDirPolicyProvider(policy_list,
           config_dir_path.Append(FILE_PATH_LITERAL("managed")));
     } else {
-      return new DummyConfigurationPolicyProvider(policy_map);
+      return new DummyConfigurationPolicyProvider(policy_list);
     }
 #else
-    return new DummyConfigurationPolicyProvider(policy_map);
+    return new DummyConfigurationPolicyProvider(policy_list);
 #endif
   }
 
   static ConfigurationPolicyProvider* CreateRecommendedProvider() {
-    const ConfigurationPolicyProvider::StaticPolicyValueMap& policy_map =
-        ConfigurationPolicyPrefStore::GetChromePolicyValueMap();
+    const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
+        ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     FilePath config_dir_path;
     if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
-      return new ConfigDirPolicyProvider(policy_map,
+      return new ConfigDirPolicyProvider(policy_list,
           config_dir_path.Append(FILE_PATH_LITERAL("recommended")));
     } else {
-      return new DummyConfigurationPolicyProvider(policy_map);
+      return new DummyConfigurationPolicyProvider(policy_list);
     }
 #else
-    return new DummyConfigurationPolicyProvider(policy_map);
+    return new DummyConfigurationPolicyProvider(policy_list);
 #endif
   }
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderKeeper);
 };
 
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry
     ConfigurationPolicyPrefStore::simple_policy_map_[] = {
   { Value::TYPE_STRING, kPolicyHomePage,  prefs::kHomePage },
   { Value::TYPE_BOOLEAN, kPolicyHomepageIsNewTabPage,
@@ skipping 64 matching lines @@
 };
 
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry
     ConfigurationPolicyPrefStore::proxy_policy_map_[] = {
   { Value::TYPE_STRING, kPolicyProxyServer, prefs::kProxyServer },
   { Value::TYPE_STRING, kPolicyProxyPacUrl, prefs::kProxyPacUrl },
   { Value::TYPE_STRING, kPolicyProxyBypassList, prefs::kProxyBypassList }
 };
 
 /* static */
-ConfigurationPolicyProvider::StaticPolicyValueMap
-ConfigurationPolicyPrefStore::GetChromePolicyValueMap() {
-  static ConfigurationPolicyProvider::StaticPolicyValueMap::Entry entries[] = {
+ConfigurationPolicyProvider::PolicyDefinitionList*
+ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList() {
+  static ConfigurationPolicyProvider::PolicyDefinitionList::Entry entries[] = {
     { ConfigurationPolicyStore::kPolicyHomePage,
         Value::TYPE_STRING, key::kHomepageLocation },
     { ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
         Value::TYPE_BOOLEAN, key::kHomepageIsNewTabPage },
     { ConfigurationPolicyStore::kPolicyRestoreOnStartup,
         Value::TYPE_INTEGER, key::kRestoreOnStartup },
     { ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
         Value::TYPE_LIST, key::kURLsToRestoreOnStartup },
     { ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
         Value::TYPE_BOOLEAN, key::kDefaultSearchProviderEnabled },
@@ skipping 59 matching lines @@
         Value::TYPE_BOOLEAN, key::kDeveloperToolsDisabled },
     { ConfigurationPolicyStore::kPolicyBlockThirdPartyCookies,
         Value::TYPE_BOOLEAN, key::kBlockThirdPartyCookies },
 
 #if defined(OS_CHROMEOS)
     { ConfigurationPolicyStore::kPolicyChromeOsLockOnIdleSuspend,
         Value::TYPE_BOOLEAN, key::kChromeOsLockOnIdleSuspend },
 #endif
   };
 
-  ConfigurationPolicyProvider::StaticPolicyValueMap map = {
-    arraysize(entries),
-    entries
+  static ConfigurationPolicyProvider::PolicyDefinitionList policy_list = {
+    entries,
+    entries + arraysize(entries),
   };
-  return map;
-}
-
-void ConfigurationPolicyPrefStore::GetProxyPreferenceSet(
-    ProxyPreferenceSet* proxy_pref_set) {
-  proxy_pref_set->clear();
-  for (size_t current = 0; current < arraysize(proxy_policy_map_); ++current) {
-    proxy_pref_set->insert(proxy_policy_map_[current].preference_path);
-  }
-  proxy_pref_set->insert(prefs::kNoProxyServer);
-  proxy_pref_set->insert(prefs::kProxyAutoDetect);
+  return &policy_list;
 }
 
 ConfigurationPolicyPrefStore::ConfigurationPolicyPrefStore(
     ConfigurationPolicyProvider* provider)
     : provider_(provider),
       prefs_(new DictionaryValue()),
       lower_priority_proxy_settings_overridden_(false),
       proxy_disabled_(false),
       proxy_configuration_specified_(false),
       use_system_proxy_(false) {
 }
 
-ConfigurationPolicyPrefStore::~ConfigurationPolicyPrefStore() {}
+ConfigurationPolicyPrefStore::~ConfigurationPolicyPrefStore() {
+}
 
 PrefStore::PrefReadError ConfigurationPolicyPrefStore::ReadPrefs() {
   proxy_disabled_ = false;
   proxy_configuration_specified_ = false;
   lower_priority_proxy_settings_overridden_ = false;
 
   bool success = (provider_ == NULL || provider_->Provide(this));
   FinalizeDefaultSearchPolicySettings();
   return success ? PrefStore::PREF_READ_ERROR_NONE :
                    PrefStore::PREF_READ_ERROR_OTHER;
@@ skipping 31 matching lines @@
 }
 
 // static
 ConfigurationPolicyPrefStore*
 ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore() {
   ConfigurationPolicyProviderKeeper* keeper =
       Singleton<ConfigurationPolicyProviderKeeper>::get();
   return new ConfigurationPolicyPrefStore(keeper->recommended_provider());
 }
 
+// static
+void ConfigurationPolicyPrefStore::GetProxyPreferenceSet(
+    ProxyPreferenceSet* proxy_pref_set) {
+  proxy_pref_set->clear();
+  for (size_t current = 0; current < arraysize(proxy_policy_map_); ++current) {
+    proxy_pref_set->insert(proxy_policy_map_[current].preference_path);
+  }
+  proxy_pref_set->insert(prefs::kNoProxyServer);
+  proxy_pref_set->insert(prefs::kProxyAutoDetect);
+}
+
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry*
 ConfigurationPolicyPrefStore::FindPolicyInMap(PolicyType policy,
     const PolicyToPreferenceMapEntry* map, int table_size) {
   for (int i = 0; i < table_size; ++i) {
     if (map[i].policy_type == policy)
       return map + i;
   }
   return NULL;
 }
 
@@ skipping 219 matching lines @@
       prefs_->SetString(prefs::kDefaultSearchProviderPrepopulateID, "");
       return;
     }
   }
   // Required entries are not there.  Remove any related entries.
   RemovePreferencesOfMap(default_search_policy_map_,
                          arraysize(default_search_policy_map_));
 }
 
 }  // namespace policy