Pass highest handled invalidation version between invalidators

chrome/browser/chromeos/policy/device_cloud_policy_invalidator.cc

 // Copyright 2014 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/chromeos/policy/device_cloud_policy_invalidator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 100 matching lines @@
     OnIncomingInvalidation(
         const syncer::ObjectIdInvalidationMap& invalidation_map) {
 }
 
 std::string DeviceCloudPolicyInvalidator::InvalidationServiceObserver::
     GetOwnerName() const {
   return "DevicePolicy";
 }
 
 DeviceCloudPolicyInvalidator::DeviceCloudPolicyInvalidator()
-    : invalidation_service_(NULL) {
+    : invalidation_service_(NULL),
+      highest_handled_invalidation_version_(0) {
   // The DeviceCloudPolicyInvalidator should be created before any user
   // Profiles.
   DCHECK(g_browser_process->profile_manager()->GetLoadedProfiles().empty());
 
   // Subscribe to notification about new user profiles becoming available.
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
                  content::NotificationService::AllSources());
 
   TryToCreateInvalidator();
@@ skipping 112 matching lines @@
     // |CloudPolicyInvalidator| backed by it. Otherwise,  a
     // |CloudPolicyInvalidator| will be created later when a connected service
     // becomes available.
     CreateInvalidator(device_invalidation_service_.get());
   }
 }
 
 void DeviceCloudPolicyInvalidator::CreateInvalidator(
     invalidation::InvalidationService* invalidation_service) {
   invalidation_service_ = invalidation_service;
+  DCHECK(!invalidator_);
   invalidator_.reset(new CloudPolicyInvalidator(
       enterprise_management::DeviceRegisterRequest::DEVICE,
       g_browser_process->platform_part()->browser_policy_connector_chromeos()->
           GetDeviceCloudPolicyManager()->core(),
       base::MessageLoopProxy::current(),
-      scoped_ptr<base::Clock>(new base::DefaultClock())));
+      scoped_ptr<base::Clock>(new base::DefaultClock()),
+      highest_handled_invalidation_version_));
   invalidator_->Initialize(invalidation_service);
 }
 
 void DeviceCloudPolicyInvalidator::DestroyInvalidator() {
-  if (invalidator_)
+  if (invalidator_) {
+    highest_handled_invalidation_version_ =
+        invalidator_->highest_handled_invalidation_version();
     invalidator_->Shutdown();
+  }
   invalidator_.reset();
   invalidation_service_ = NULL;
 }
 
 void DeviceCloudPolicyInvalidator::DestroyDeviceInvalidationService() {
   device_invalidation_service_observer_.reset();
   device_invalidation_service_.reset();
 }
 
 }  // namespace policy