Pass highest handled invalidation version between invalidators

chrome/browser/policy/cloud/cloud_policy_invalidator.cc

 // Copyright 2013 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 "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
@@ skipping 16 matching lines @@
 const int CloudPolicyInvalidator::kMaxFetchDelayMin = 1000;
 const int CloudPolicyInvalidator::kMaxFetchDelayMax = 300000;
 const int CloudPolicyInvalidator::kInvalidationGracePeriod = 10;
 const int CloudPolicyInvalidator::kUnknownVersionIgnorePeriod = 30;
 const int CloudPolicyInvalidator::kMaxInvalidationTimeDelta = 300;
 
 CloudPolicyInvalidator::CloudPolicyInvalidator(
     enterprise_management::DeviceRegisterRequest::Type type,
     CloudPolicyCore* core,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    scoped_ptr<base::Clock> clock)
+    scoped_ptr<base::Clock> clock,
+    int64 highest_handled_invalidation_version)
     : state_(UNINITIALIZED),
       type_(type),
       core_(core),
       task_runner_(task_runner),
       clock_(clock.Pass()),
       invalidation_service_(NULL),
       invalidations_enabled_(false),
       invalidation_service_enabled_(false),
       is_registered_(false),
       invalid_(false),
       invalidation_version_(0),
       unknown_version_invalidation_count_(0),
+      highest_handled_invalidation_version_(
+          highest_handled_invalidation_version),
       weak_factory_(this),
       max_fetch_delay_(kMaxFetchDelayDefault),
       policy_hash_value_(0) {
   DCHECK(core);
   DCHECK(task_runner.get());
+  // |highest_handled_invalidation_version_| indicates the highest actual
+  // invalidation version handled. Since actual invalidations can have only
+  // positive versions, this member may be zero (no versioned invalidation
+  // handled yet) or positive. Negative values are not allowed:
+  //
+  // Negative version numbers are used internally by CloudPolicyInvalidator to
+  // keep track of unversioned invalidations. When such an invalidation is
+  // handled, |highest_handled_invalidation_version_| remains unchanged and does
+  // not become negative.
+  DCHECK_LE(0, highest_handled_invalidation_version_);
 }
 
 CloudPolicyInvalidator::~CloudPolicyInvalidator() {
   DCHECK(state_ == SHUT_DOWN);
 }
 
 void CloudPolicyInvalidator::Initialize(
     invalidation::InvalidationService* invalidation_service) {
   DCHECK(state_ == UNINITIALIZED);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 82 matching lines @@
     if (type_ == enterprise_management::DeviceRegisterRequest::DEVICE) {
       UMA_HISTOGRAM_ENUMERATION(kMetricDevicePolicyRefresh,
                                 GetPolicyRefreshMetric(policy_changed),
                                 METRIC_POLICY_REFRESH_SIZE);
     } else {
       UMA_HISTOGRAM_ENUMERATION(kMetricUserPolicyRefresh,
                                 GetPolicyRefreshMetric(policy_changed),
                                 METRIC_POLICY_REFRESH_SIZE);
     }
 
+    const int64 store_invalidation_version = store->invalidation_version();
+
     // If the policy was invalid and the version stored matches the latest
     // invalidation version, acknowledge the latest invalidation.
-    if (invalid_ && store->invalidation_version() == invalidation_version_)
+    if (invalid_ && store_invalidation_version == invalidation_version_)
       AcknowledgeInvalidation();
+
+    // Update the highest invalidation version that was handled already.
+    if (store_invalidation_version > highest_handled_invalidation_version_)
+      highest_handled_invalidation_version_ = store_invalidation_version;
   }
 
   UpdateRegistration(store->policy());
   UpdateMaxFetchDelay(store->policy_map());
 }
 
 void CloudPolicyInvalidator::OnStoreError(CloudPolicyStore* store) {}
 
 void CloudPolicyInvalidator::HandleInvalidation(
     const syncer::Invalidation& invalidation) {
   // Ignore old invalidations.
   if (invalid_ &&
       !invalidation.is_unknown_version() &&
       invalidation.version() <= invalidation_version_) {
     return;
   }
 
+  if (!invalidation.is_unknown_version() &&
+      invalidation.version() <= highest_handled_invalidation_version_) {
+    // If this invalidation version was handled already, acknowledge the
+    // invalidation but ignore it otherwise.
+    invalidation.Acknowledge();
+    return;
+  }
+
   // If there is still a pending invalidation, acknowledge it, since we only
   // care about the latest invalidation.
   if (invalid_)
     AcknowledgeInvalidation();
 
   // Get the version and payload from the invalidation.
   // When an invalidation with unknown version is received, use negative
   // numbers based on the number of such invalidations received. This
   // ensures that the version numbers do not collide with "real" versions
   // (which are positive) or previous invalidations with unknown version.
@@ skipping 223 matching lines @@
 bool CloudPolicyInvalidator::GetInvalidationsEnabled() {
   if (!invalidations_enabled_)
     return false;
   // If invalidations have been enabled for less than the grace period, then
   // consider invalidations to be disabled for metrics reporting.
   base::TimeDelta elapsed = clock_->Now() - invalidations_enabled_time_;
   return elapsed.InSeconds() >= kInvalidationGracePeriod;
 }
 
 }  // namespace policy