policy: use JSON schema to deserialize entries from Windows registry.

chrome/browser/policy/async_policy_loader.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 CHROME_BROWSER_POLICY_ASYNC_POLICY_LOADER_H_
 #define CHROME_BROWSER_POLICY_ASYNC_POLICY_LOADER_H_
 
 #include <map>
 
 #include "base/callback.h"
@@ skipping 17 matching lines @@
 // periodic reloads, watching file changes, refreshing policies and object
 // lifetime.
 //
 // All methods are invoked on the background |task_runner_|, including the
 // destructor. The only exceptions are the constructor (which may be called on
 // any thread), and the initial Load() which is called on the thread that owns
 // the provider.
 // LastModificationTime() is also invoked once on that thread at startup.
 class AsyncPolicyLoader {
  public:
+  typedef base::Callback<void(scoped_ptr<PolicyBundle>)> UpdateCallback;
+
   explicit AsyncPolicyLoader(
       scoped_refptr<base::SequencedTaskRunner> task_runner);
   virtual ~AsyncPolicyLoader();
 
   // Gets a SequencedTaskRunner backed by the background thread.
   base::SequencedTaskRunner* task_runner() const { return task_runner_.get(); }
 
   // Returns the currently configured policies. Load() is always invoked on
   // the background thread, except for the initial Load() at startup which is
   // invoked from the thread that owns the provider.
   virtual scoped_ptr<PolicyBundle> Load() = 0;
 
+  // Used by the AsyncPolicyProvider to install the |update_callback_|.
+  // Invoked on the background thread.
+  void Init(const UpdateCallback& update_callback);
+
   // Allows implementations to finalize their initialization on the background
   // thread (e.g. setup file watchers).
   virtual void InitOnBackgroundThread() = 0;
 
   // Implementations should return the time of the last modification detected,
   // or base::Time() if it doesn't apply, which is the default.
   virtual base::Time LastModificationTime();
 
   // Implementations should invoke Reload() when a change is detected. This
   // must be invoked from the background thread and will trigger a Load(),
   // and pass the returned bundle to the provider.
   // The load is immediate when |force| is true. Otherwise, the loader
   // reschedules the reload until the LastModificationTime() is a couple of
   // seconds in the past. This mitigates the problem of reading files that are
   // currently being written to, and whose contents are incomplete.
   // A reload is posted periodically, if it hasn't been triggered recently. This
   // makes sure the policies are reloaded if the update events aren't triggered.
   void Reload(bool force);
 
   // Passes the current |descriptor| for a domain, which is used to determine
   // which policy names are supported for each component.
   void RegisterPolicyDomain(
       scoped_refptr<const PolicyDomainDescriptor> descriptor);
 
+  // Registers a policy domain without triggering a policy load.
+  void InitialRegisterPolicyDomain(
+      scoped_refptr<const PolicyDomainDescriptor> descriptor);
+
  protected:
   typedef std::map<PolicyDomain, scoped_refptr<const PolicyDomainDescriptor> >
       DescriptorMap;
 
   // Returns the current DescriptorMap. This can be used by implementations to
   // determine the components registered for each domain, and to filter out
   // unknonwn policies.
   const DescriptorMap& descriptor_map() const { return descriptor_map_; }
 
+  // Returns the desired descriptor if it exists, otherwise NULL.
+  scoped_refptr<const PolicyDomainDescriptor> get_descriptor(
+      PolicyDomain domain) const;
+
  private:
   // Allow AsyncPolicyProvider to call Init().
   friend class AsyncPolicyProvider;
 
-  typedef base::Callback<void(scoped_ptr<PolicyBundle>)> UpdateCallback;
-
   // Used by the AsyncPolicyProvider to do the initial Load(). The first load
   // is also used to initialize |last_modification_time_|.
   scoped_ptr<PolicyBundle> InitialLoad();
 
-  // Registers a policy domain without triggering a policy load.
-  void InitialRegisterPolicyDomain(
-      scoped_refptr<const PolicyDomainDescriptor> descriptor);
-
-  // Used by the AsyncPolicyProvider to install the |update_callback_|.
-  // Invoked on the background thread.
-  void Init(const UpdateCallback& update_callback);
-
   // Cancels any pending periodic reload and posts one |delay| time units from
   // now.
   void ScheduleNextReload(base::TimeDelta delay);
 
   // Checks if the underlying files haven't changed recently, by checking the
   // LastModificationTime(). |delay| is updated with a suggested time to wait
   // before retrying when this returns false.
   bool IsSafeToReload(const base::Time& now, base::TimeDelta* delay);
 
   // Task runner to run background threads.
@@ skipping 16 matching lines @@
 
   // A map of the currently registered domains and their descriptors.
   DescriptorMap descriptor_map_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPolicyLoader);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_ASYNC_POLICY_LOADER_H_