src/chrome/browser/policy/cloud/cloud_policy_invalidator.h

   1 // Copyright 2013 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_CLOUD_CLOUD_POLICY_INVALIDATOR_H_
   6 #define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_INVALIDATOR_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/threading/thread_checker.h"
  17 #include "components/invalidation/invalidation.h"
  18 #include "components/invalidation/invalidation_handler.h"
  19 #include "components/policy/core/common/cloud/cloud_policy_core.h"
  20 #include "components/policy/core/common/cloud/cloud_policy_store.h"
  21 #include "google/cacheinvalidation/include/types.h"
  22 #include "policy/proto/device_management_backend.pb.h"
  23
  24 namespace base {
  25 class Clock;
  26 class SequencedTaskRunner;
  27 }
  28
  29 namespace invalidation {
  30 class InvalidationService;
  31 }
  32
  33 namespace policy {
  34
  35 // Listens for and provides policy invalidations.
  36 class CloudPolicyInvalidator : public syncer::InvalidationHandler,
  37                                public CloudPolicyCore::Observer,
  38                                public CloudPolicyStore::Observer {
  39  public:
  40   // The number of minutes to delay a policy refresh after receiving an
  41   // invalidation with no payload.
  42   static const int kMissingPayloadDelay;
  43
  44   // The default, min and max values for max_fetch_delay_.
  45   static const int kMaxFetchDelayDefault;
  46   static const int kMaxFetchDelayMin;
  47   static const int kMaxFetchDelayMax;
  48
  49   // The grace period, in seconds, to allow for invalidations to be received
  50   // once the invalidation service starts up.
  51   static const int kInvalidationGracePeriod;
  52
  53   // Time, in seconds, for which unknown version invalidations are ignored after
  54   // fetching a policy.
  55   static const int kUnknownVersionIgnorePeriod;
  56
  57   // The max tolerated discrepancy, in seconds, between policy timestamps and
  58   // invalidation timestamps when determining if an invalidation is expired.
  59   static const int kMaxInvalidationTimeDelta;
  60
  61   // |type| indicates the policy type that this invalidator is responsible for.
  62   // |core| is the cloud policy core which connects the various policy objects.
  63   // It must remain valid until Shutdown is called.
  64   // |task_runner| is used for scheduling delayed tasks. It must post tasks to
  65   // the main policy thread.
  66   // |clock| is used to get the current time.
  67   // |highest_handled_invalidation_version| is the highest invalidation version
  68   // that was handled already before this invalidator was created.
  69   CloudPolicyInvalidator(
  70       enterprise_management::DeviceRegisterRequest::Type type,
  71       CloudPolicyCore* core,
  72       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
  73       scoped_ptr<base::Clock> clock,
  74       int64 highest_handled_invalidation_version);
  75   virtual ~CloudPolicyInvalidator();
  76
  77   // Initializes the invalidator. No invalidations will be generated before this
  78   // method is called. This method must only be called once.
  79   // |invalidation_service| is the invalidation service to use and must remain
  80   // valid until Shutdown is called.
  81   void Initialize(invalidation::InvalidationService* invalidation_service);
  82
  83   // Shuts down and disables invalidations. It must be called before the object
  84   // is destroyed.
  85   void Shutdown();
  86
  87   // Whether the invalidator currently has the ability to receive invalidations.
  88   bool invalidations_enabled() {
  89     return invalidations_enabled_;
  90   }
  91
  92   // The highest invalidation version that was handled already.
  93   int64 highest_handled_invalidation_version() const {
  94     return highest_handled_invalidation_version_;
  95   }
  96
  97   // syncer::InvalidationHandler:
  98   virtual void OnInvalidatorStateChange(
  99       syncer::InvalidatorState state) OVERRIDE;
 100   virtual void OnIncomingInvalidation(
 101       const syncer::ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 102   virtual std::string GetOwnerName() const OVERRIDE;
 103
 104   // CloudPolicyCore::Observer:
 105   virtual void OnCoreConnected(CloudPolicyCore* core) OVERRIDE;
 106   virtual void OnRefreshSchedulerStarted(CloudPolicyCore* core) OVERRIDE;
 107   virtual void OnCoreDisconnecting(CloudPolicyCore* core) OVERRIDE;
 108
 109   // CloudPolicyStore::Observer:
 110   virtual void OnStoreLoaded(CloudPolicyStore* store) OVERRIDE;
 111   virtual void OnStoreError(CloudPolicyStore* store) OVERRIDE;
 112
 113  private:
 114   // Handle an invalidation to the policy.
 115   void HandleInvalidation(const syncer::Invalidation& invalidation);
 116
 117   // Update object registration with the invalidation service based on the
 118   // given policy data.
 119   void UpdateRegistration(const enterprise_management::PolicyData* policy);
 120
 121   // Registers the given object with the invalidation service.
 122   void Register(const invalidation::ObjectId& object_id);
 123
 124   // Unregisters the current object with the invalidation service.
 125   void Unregister();
 126
 127   // Update |max_fetch_delay_| based on the given policy map.
 128   void UpdateMaxFetchDelay(const PolicyMap& policy_map);
 129   void set_max_fetch_delay(int delay);
 130
 131   // Updates invalidations_enabled_ and calls the invalidation handler if the
 132   // value changed.
 133   void UpdateInvalidationsEnabled();
 134
 135   // Refresh the policy.
 136   // |is_missing_payload| is set to true if the callback is being invoked in
 137   // response to an invalidation with a missing payload.
 138   void RefreshPolicy(bool is_missing_payload);
 139
 140   // Acknowledge the latest invalidation.
 141   void AcknowledgeInvalidation();
 142
 143   // Determines if the given policy is different from the policy passed in the
 144   // previous call.
 145   bool IsPolicyChanged(const enterprise_management::PolicyData* policy);
 146
 147   // Determine if an invalidation has expired.
 148   // |version| is the version of the invalidation, or zero for unknown.
 149   bool IsInvalidationExpired(int64 version);
 150
 151   // Get the kMetricPolicyRefresh histogram metric which should be incremented
 152   // when a policy is stored.
 153   int GetPolicyRefreshMetric(bool policy_changed);
 154
 155   // Get the kMetricPolicyInvalidations histogram metric which should be
 156   // incremented when an invalidation is received.
 157   int GetInvalidationMetric(bool is_missing_payload, bool is_expired);
 158
 159   // Determine if invalidations have been enabled longer than the grace period.
 160   bool GetInvalidationsEnabled();
 161
 162   // The state of the object.
 163   enum State {
 164     UNINITIALIZED,
 165     STOPPED,
 166     STARTED,
 167     SHUT_DOWN
 168   };
 169   State state_;
 170
 171   // The policy type this invalidator is responsible for.
 172   const enterprise_management::DeviceRegisterRequest::Type type_;
 173
 174   // The cloud policy core.
 175   CloudPolicyCore* core_;
 176
 177   // Schedules delayed tasks.
 178   const scoped_refptr<base::SequencedTaskRunner> task_runner_;
 179
 180   // The clock.
 181   scoped_ptr<base::Clock> clock_;
 182
 183   // The invalidation service.
 184   invalidation::InvalidationService* invalidation_service_;
 185
 186   // Whether the invalidator currently has the ability to receive invalidations.
 187   // This is true if the invalidation service is enabled and the invalidator
 188   // has registered for a policy object.
 189   bool invalidations_enabled_;
 190
 191   // The time that invalidations became enabled.
 192   base::Time invalidations_enabled_time_;
 193
 194   // Whether the invalidation service is currently enabled.
 195   bool invalidation_service_enabled_;
 196
 197   // Whether this object has registered for policy invalidations.
 198   bool is_registered_;
 199
 200   // The object id representing the policy in the invalidation service.
 201   invalidation::ObjectId object_id_;
 202
 203   // Whether the policy is current invalid. This is set to true when an
 204   // invalidation is received and reset when the policy fetched due to the
 205   // invalidation is stored.
 206   bool invalid_;
 207
 208   // The version of the latest invalidation received. This is compared to
 209   // the invalidation version of policy stored to determine when the
 210   // invalidated policy is up-to-date.
 211   int64 invalidation_version_;
 212
 213   // The number of invalidations with unknown version received. Since such
 214   // invalidations do not provide a version number, this count is used to set
 215   // invalidation_version_ when such invalidations occur.
 216   int unknown_version_invalidation_count_;
 217
 218   // The highest invalidation version that was handled already.
 219   int64 highest_handled_invalidation_version_;
 220
 221   // The most up to date invalidation.
 222   scoped_ptr<syncer::Invalidation> invalidation_;
 223
 224   // The maximum random delay, in ms, between receiving an invalidation and
 225   // fetching the new policy.
 226   int max_fetch_delay_;
 227
 228   // The hash value of the current policy. This is used to determine if a new
 229   // policy is different from the current one.
 230   uint32 policy_hash_value_;
 231
 232   // A thread checker to make sure that callbacks are invoked on the correct
 233   // thread.
 234   base::ThreadChecker thread_checker_;
 235
 236   // WeakPtrFactory used to create callbacks to this object.
 237   base::WeakPtrFactory<CloudPolicyInvalidator> weak_factory_;
 238
 239   DISALLOW_COPY_AND_ASSIGN(CloudPolicyInvalidator);
 240 };
 241
 242 }  // namespace policy
 243
 244 #endif  // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_INVALIDATOR_H_