Add source column to chrome://policy showing the origins of policies.

components/policy/core/common/config_dir_policy_loader.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/common/config_dir_policy_loader.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_load_status.h"
+#include "components/policy/core/common/policy_types.h"
 
 namespace policy {
 
 namespace {
 
 // Subdirectories that contain the mandatory and recommended policies.
 const base::FilePath::CharType kMandatoryConfigDir[] =
     FILE_PATH_LITERAL("managed");
 const base::FilePath::CharType kRecommendedConfigDir[] =
     FILE_PATH_LITERAL("recommended");
@@ skipping 127 matching lines @@
       continue;
     }
 
     // Detach the "3rdparty" node.
     scoped_ptr<base::Value> third_party;
     if (dictionary_value->Remove("3rdparty", &third_party))
       Merge3rdPartyPolicy(third_party.get(), level, bundle);
 
     // Add chrome policy.
     PolicyMap policy_map;
-    policy_map.LoadFrom(dictionary_value, level, scope_);
+    policy_map.LoadFrom(dictionary_value, level, scope_,
+                        POLICY_SOURCE_PLATFORM);
     bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .MergeFrom(policy_map);
   }
 }
 
 void ConfigDirPolicyLoader::Merge3rdPartyPolicy(
     const base::Value* policies,
     PolicyLevel level,
     PolicyBundle* bundle) {
   // The first-level entries in |policies| are PolicyDomains. The second-level
@@ skipping 29 matching lines @@
     for (base::DictionaryValue::Iterator components_it(*components_dictionary);
          !components_it.IsAtEnd(); 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_, POLICY_SOURCE_PLATFORM);
       bundle->Get(PolicyNamespace(domain, components_it.key()))
           .MergeFrom(policy);
     }
   }
 }
 
 void ConfigDirPolicyLoader::OnFileUpdated(const base::FilePath& path,
                                           bool error) {
   if (!error)
     Reload(false);
 }
 
 }  // namespace policy