Added support for signed policy blobs on desktop.

components/policy/core/common/cloud/cloud_policy_manager.h

 // 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.
 
 #ifndef COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_MANAGER_H_
 #define COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_MANAGER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 31 matching lines @@
       public CloudPolicyStore::Observer,
       public ComponentCloudPolicyService::Delegate {
  public:
   // |task_runner| is the runner for policy refresh tasks.
   // |file_task_runner| is used for file operations. Currently this must be the
   // FILE BrowserThread.
   // |io_task_runner| is used for network IO. Currently this must be the IO
   // BrowserThread.
   CloudPolicyManager(
       const PolicyNamespaceKey& policy_ns_key,
+      const std::string& verification_key_hash,

[Mattias Nissler (ping if slow), 2014/01/27 13:52:13]

Does this make sense here? The class itself doesn't use the value at all.

[Andrew T Wilson (Slow), 2014/01/30 17:10:31]

Yeah, I had this idea that CPM would be the holder for the verification key hash
(so you could inject it into classes and classes could fetch it directly from
CPM). I think now that it's in CloudPolicyConstants this doesn't make much
sense, so I'll remove this and change the callers to fetch it from
CloudPolicyConstants.

       CloudPolicyStore* cloud_policy_store,
       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
       const scoped_refptr<base::SequencedTaskRunner>& file_task_runner,
       const scoped_refptr<base::SequencedTaskRunner>& io_task_runner);
   virtual ~CloudPolicyManager();
 
   CloudPolicyCore* core() { return &core_; }
   const CloudPolicyCore* core() const { return &core_; }
 
   // ConfigurationPolicyProvider:
   virtual void Shutdown() OVERRIDE;
   virtual bool IsInitializationComplete(PolicyDomain domain) const OVERRIDE;
   virtual void RefreshPolicies() OVERRIDE;
 
   // CloudPolicyStore::Observer:
   virtual void OnStoreLoaded(CloudPolicyStore* cloud_policy_store) OVERRIDE;
   virtual void OnStoreError(CloudPolicyStore* cloud_policy_store) OVERRIDE;
 
   // ComponentCloudPolicyService::Delegate:
   virtual void OnComponentCloudPolicyUpdated() OVERRIDE;
 
+  // Identifier for which verification key this chrome instance uses.
+  const std::string& verification_key_hash() { return verification_key_hash_; }
+
  protected:
   // Check whether fully initialized and if so, publish policy by calling
   // ConfigurationPolicyStore::UpdatePolicy().
   void CheckAndPublishPolicy();
 
   void CreateComponentCloudPolicyService(
       const base::FilePath& policy_cache_path,
       const scoped_refptr<net::URLRequestContextGetter>& request_context);
 
   void ClearAndDestroyComponentCloudPolicyService();
@@ skipping 13 matching lines @@
   // Completion handler for policy refresh operations.
   void OnRefreshComplete(bool success);
 
   CloudPolicyCore core_;
   scoped_ptr<ComponentCloudPolicyService> component_policy_service_;
 
   // Whether there's a policy refresh operation pending, in which case all
   // policy update notifications are deferred until after it completes.
   bool waiting_for_policy_refresh_;
 
+  // Identifier for which signing key is supported by this instance of Chrome.
+  std::string verification_key_hash_;
+
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyManager);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_MANAGER_H_