Drop non-user policy in ConfigDirPolicyLoader on Chrome OS.

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 <stddef.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/macros.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"
+#include "policy/policy_constants.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 16 matching lines @@
     case base::JSONReader::JSON_UNQUOTED_DICTIONARY_KEY:
       return POLICY_LOAD_STATUS_PARSE_ERROR;
     case base::JSONReader::JSON_NO_ERROR:
       NOTREACHED();
       return POLICY_LOAD_STATUS_STARTED;
   }
   NOTREACHED() << "Invalid status " << status;
   return POLICY_LOAD_STATUS_PARSE_ERROR;
 }
 
+bool IsUserPolicy(const PolicyMap::const_iterator iter) {
+  const PolicyDetails* policy_details = GetChromePolicyDetails(iter->first);
+  if (!policy_details) {
+    LOG(ERROR) << "Ignoring unknown platform policy: " << iter->first;
+    return false;
+  }
+  if (policy_details->is_device_policy) {
+    // Device Policy is only implemented as Cloud Policy (not Platform Policy).
+    LOG(ERROR) << "Ignoring device platform policy: " << iter->first;
+    return false;
+  }
+  return true;
+}
+
 }  // namespace
 
 ConfigDirPolicyLoader::ConfigDirPolicyLoader(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const base::FilePath& config_dir,
     PolicyScope scope)
     : AsyncPolicyLoader(task_runner), config_dir_(config_dir), scope_(scope) {}
 
 ConfigDirPolicyLoader::~ConfigDirPolicyLoader() {}
 
@@ skipping 93 matching lines @@
 
     // Detach the "3rdparty" node.
     std::unique_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_SOURCE_PLATFORM);
+    policy_map.EraseNonmatching(base::Bind(&IsUserPolicy));
     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 43 matching lines @@
   }
 }
 
 void ConfigDirPolicyLoader::OnFileUpdated(const base::FilePath& path,
                                           bool error) {
   if (!error)
     Reload(false);
 }
 
 }  // namespace policy