Implement the ConfigDirPolicyProvider based on the AsyncPolicyLoader

chrome/browser/policy/config_dir_policy_provider.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 "chrome/browser/policy/config_dir_policy_provider.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "chrome/browser/policy/policy_bundle.h"
 
 namespace policy {
 
+namespace {
+
+// Subdirectories of the ConfigDirPolicyProvider config dir that contain
+// managed and recommended policies.
+const char kManagedPath[] = "managed";
+const char kRecommendedPath[] = "recommended";
+
+}  // namespace
+
 ConfigDirPolicyProviderDelegate::ConfigDirPolicyProviderDelegate(
     const FilePath& config_dir,
-    PolicyLevel level,
     PolicyScope scope)
     : FileBasedPolicyProvider::ProviderDelegate(config_dir),
-      level_(level),
       scope_(scope) {}
 
 scoped_ptr<PolicyBundle> ConfigDirPolicyProviderDelegate::Load() {
+  scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
+  LoadFromPath(config_file_path().Append(FILE_PATH_LITERAL(kManagedPath)),
+               POLICY_LEVEL_MANDATORY,
+               bundle.get());
+  LoadFromPath(config_file_path().Append(FILE_PATH_LITERAL(kRecommendedPath)),
+               POLICY_LEVEL_RECOMMENDED,
+               bundle.get());
+  return bundle.Pass();
+}
+
+base::Time ConfigDirPolicyProviderDelegate::GetLastModification() {
+  base::Time last_modification = base::Time();
+  base::PlatformFileInfo file_info;
+
+  // If the path does not exist or points to a directory, it's safe to load.

[Mattias Nissler (ping if slow), 2012/05/31 13:58:09]

should be "doesn't point to a directory", no?

[Joao da Silva, 2012/06/03 15:02:01]

I didn't even see this; this diff is smaller, but the change was to split Load()
into LoadFromPath(), which was moved to after this function to keep the
declaration order.

I've fixed this comment anyway :-)

+  if (!file_util::GetFileInfo(config_file_path(), &file_info) ||

[Mattias Nissler (ping if slow), 2012/05/31 13:58:09]

You need to do that on both of the directories. Have you tested this?
Continuously writing the policy file should stop Chrome from reloading. Until
you don't touch the file for 5 seconds.

[Joao da Silva, 2012/06/03 15:02:01]

Watching both paths after rebasing on AsyncPolicyLoader.

+      !file_info.is_directory) {
+    return last_modification;
+  }
+
+  // Enumerate the files and find the most recent modification timestamp.
+  file_util::FileEnumerator file_enumerator(config_file_path(),
+                                            false,
+                                            file_util::FileEnumerator::FILES);
+  for (FilePath config_file = file_enumerator.Next();
+       !config_file.empty();
+       config_file = file_enumerator.Next()) {
+    if (file_util::GetFileInfo(config_file, &file_info) &&
+        !file_info.is_directory) {
+      last_modification = std::max(last_modification, file_info.last_modified);
+    }
+  }
+
+  return last_modification;
+}
+
+void ConfigDirPolicyProviderDelegate::LoadFromPath(const FilePath& path,
+                                                   PolicyLevel level,
+                                                   PolicyBundle* bundle) {
   // Enumerate the files and sort them lexicographically.
   std::set<FilePath> files;
-  file_util::FileEnumerator file_enumerator(config_file_path(), false,
+  file_util::FileEnumerator file_enumerator(path, false,
                                             file_util::FileEnumerator::FILES);
   for (FilePath config_file_path = file_enumerator.Next();
        !config_file_path.empty(); config_file_path = file_enumerator.Next())
     files.insert(config_file_path);
 
   // Start with an empty dictionary and merge the files' contents.
   // The files are processed in reverse order because |MergeFrom| gives priority
   // to existing keys, but the ConfigDirPolicyProvider gives priority to the
   // last file in lexicographic order.
-  scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
   for (std::set<FilePath>::reverse_iterator config_file_iter = files.rbegin();
        config_file_iter != files.rend(); ++config_file_iter) {
     JSONFileValueSerializer deserializer(*config_file_iter);
     deserializer.set_allow_trailing_comma(true);
     int error_code = 0;
     std::string error_msg;
     scoped_ptr<base::Value> value(
         deserializer.Deserialize(&error_code, &error_msg));
     if (!value.get()) {
       LOG(WARNING) << "Failed to read configuration file "
                    << config_file_iter->value() << ": " << error_msg;
       continue;
     }
     base::DictionaryValue* dictionary_value = NULL;
     if (!value->GetAsDictionary(&dictionary_value)) {
       LOG(WARNING) << "Expected JSON dictionary in configuration file "
                    << config_file_iter->value();
       continue;
     }
 
     // Detach the "3rdparty" node.
     base::Value* third_party = NULL;
     if (dictionary_value->Remove("3rdparty", &third_party)) {
-      Merge3rdPartyPolicy(bundle.get(), third_party);
+      Merge3rdPartyPolicy(third_party, level, bundle);
       delete third_party;
     }
 
     // Add chrome policy.
     PolicyMap policy_map;
-    policy_map.LoadFrom(dictionary_value, level_, scope_);
+    policy_map.LoadFrom(dictionary_value, level, scope_);
     bundle->Get(POLICY_DOMAIN_CHROME, "").MergeFrom(policy_map);
   }
-
-  return bundle.Pass();
-}
-
-base::Time ConfigDirPolicyProviderDelegate::GetLastModification() {
-  base::Time last_modification = base::Time();
-  base::PlatformFileInfo file_info;
-
-  // If the path does not exist or points to a directory, it's safe to load.
-  if (!file_util::GetFileInfo(config_file_path(), &file_info) ||
-      !file_info.is_directory) {
-    return last_modification;
-  }
-
-  // Enumerate the files and find the most recent modification timestamp.
-  file_util::FileEnumerator file_enumerator(config_file_path(),
-                                            false,
-                                            file_util::FileEnumerator::FILES);
-  for (FilePath config_file = file_enumerator.Next();
-       !config_file.empty();
-       config_file = file_enumerator.Next()) {
-    if (file_util::GetFileInfo(config_file, &file_info) &&
-        !file_info.is_directory) {
-      last_modification = std::max(last_modification, file_info.last_modified);
-    }
-  }
-
-  return last_modification;
 }
 
 void ConfigDirPolicyProviderDelegate::Merge3rdPartyPolicy(
-    PolicyBundle* bundle,
-    const base::Value* value) {
+    const base::Value* value,
+    PolicyLevel level,
+    PolicyBundle* bundle) {
   // The first-level entries in |value| are PolicyDomains. The second-level
   // entries are component IDs, and the third-level entries are the policies
   // for that domain/component namespace.
 
   const base::DictionaryValue* domains_dictionary;
   if (!value->GetAsDictionary(&domains_dictionary)) {
     LOG(WARNING) << "3rdparty value is not a dictionary!";
     return;
   }
 
@@ skipping 20 matching lines @@
     for (base::DictionaryValue::Iterator components_it(*components_dictionary);
          components_it.HasNext(); components_it.Advance()) {
       const base::DictionaryValue* policy_dictionary;
       if (!components_it.value().GetAsDictionary(&policy_dictionary)) {
         LOG(WARNING) << "3rdparty/" << domains_it.key() << "/"
                      << components_it.key() << " value is not a dictionary!";
         continue;
       }
 
       PolicyMap policy;
-      policy.LoadFrom(policy_dictionary, level_, scope_);
+      policy.LoadFrom(policy_dictionary, level, scope_);
       bundle->Get(domain, components_it.key()).MergeFrom(policy);
     }
   }
 }
 
 ConfigDirPolicyProvider::ConfigDirPolicyProvider(
     const PolicyDefinitionList* policy_list,
-    PolicyLevel level,
     PolicyScope scope,
     const FilePath& config_dir)
     : FileBasedPolicyProvider(
         policy_list,
-        new ConfigDirPolicyProviderDelegate(config_dir, level, scope)) {}
+        new ConfigDirPolicyProviderDelegate(config_dir, scope)) {}
 
 }  // namespace policy