configuration_policy_provider.h revision dc0f95d653279beabeb9817299e2902918ba123e 
1// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_PROVIDER_H_
6#define CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_PROVIDER_H_
7#pragma once
8
9#include <map>
10#include <string>
11
12#include "base/basictypes.h"
13#include "base/scoped_ptr.h"
14#include "base/values.h"
15#include "chrome/browser/policy/configuration_policy_store_interface.h"
16#include "policy/configuration_policy_type.h"
17
18namespace policy {
19
20class PolicyMap;
21
22// A mostly-abstract super class for platform-specific policy providers.
23// Platform-specific policy providers (Windows Group Policy, gconf,
24// etc.) should implement a subclass of this class.
25class ConfigurationPolicyProvider {
26 public:
27  class Observer {
28   public:
29    virtual ~Observer() {}
30    virtual void OnUpdatePolicy() = 0;
31    virtual void OnProviderGoingAway() = 0;
32  };
33
34  // Used for static arrays of policy values that is used to initialize an
35  // instance of the ConfigurationPolicyProvider.
36  struct PolicyDefinitionList {
37    struct Entry {
38      ConfigurationPolicyType policy_type;
39      Value::ValueType value_type;
40      const char* name;
41    };
42
43    const Entry* begin;
44    const Entry* end;
45  };
46
47  explicit ConfigurationPolicyProvider(const PolicyDefinitionList* policy_list);
48
49  virtual ~ConfigurationPolicyProvider();
50
51  // Must be implemented by provider subclasses to specify the provider-specific
52  // policy decisions. The preference service invokes this |Provide| method when
53  // it needs a policy provider to specify its policy choices. In |Provide|, the
54  // |ConfigurationPolicyProvider| must make calls to the |Apply| method of
55  // |store| to apply specific policies. Returns true if the policy could be
56  // provided, otherwise false.
57  virtual bool Provide(ConfigurationPolicyStoreInterface* store) = 0;
58
59  // Check whether this provider has completed initialization. This is used to
60  // detect whether initialization is done in case providers implementations
61  // need to do asynchronous operations for initialization.
62  virtual bool IsInitializationComplete() const;
63
64 protected:
65  // Decodes the value tree and writes the configuration to the given |store|.
66  void ApplyPolicyValueTree(const DictionaryValue* policies,
67                             ConfigurationPolicyStoreInterface* store);
68
69  // Writes the configuration found in the already-decoded map |policies| to
70  // the given |store|.
71  void ApplyPolicyMap(const PolicyMap* policies,
72                      ConfigurationPolicyStoreInterface* store);
73
74  const PolicyDefinitionList* policy_definition_list() const {
75    return policy_definition_list_;
76  }
77
78 private:
79  friend class ConfigurationPolicyObserverRegistrar;
80
81  virtual void AddObserver(ConfigurationPolicyProvider::Observer* observer) = 0;
82  virtual void RemoveObserver(
83      ConfigurationPolicyProvider::Observer* observer) = 0;
84
85  // Contains the default mapping from policy values to the actual names.
86  const ConfigurationPolicyProvider::PolicyDefinitionList*
87      policy_definition_list_;
88
89 private:
90  DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProvider);
91};
92
93// Manages observers for a ConfigurationPolicyProvider. Is used to register
94// observers, and automatically removes them upon destruction.
95// Implementation detail: to avoid duplicate bookkeeping of registered
96// observers, this registrar class acts as a proxy for notifications (since it
97// needs to register itself anyway to get OnProviderGoingAway notifications).
98class ConfigurationPolicyObserverRegistrar
99    : ConfigurationPolicyProvider::Observer {
100 public:
101  ConfigurationPolicyObserverRegistrar();
102  ~ConfigurationPolicyObserverRegistrar();
103  void Init(ConfigurationPolicyProvider* provider,
104            ConfigurationPolicyProvider::Observer* observer);
105
106  // ConfigurationPolicyProvider::Observer implementation:
107  virtual void OnUpdatePolicy();
108  virtual void OnProviderGoingAway();
109
110 private:
111  ConfigurationPolicyProvider* provider_;
112  ConfigurationPolicyProvider::Observer* observer_;
113
114  DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyObserverRegistrar);
115};
116
117}  // namespace policy
118
119#endif  // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_PROVIDER_H_
120