Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/cloud_policy_client.cc

 // 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.
 
 #include "chrome/browser/policy/cloud/cloud_policy_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 40 matching lines @@
                                      UserAffiliation user_affiliation,
                                      StatusProvider* status_provider,
                                      DeviceManagementService* service)
     : machine_id_(machine_id),
       machine_model_(machine_model),
       user_affiliation_(user_affiliation),
       device_mode_(DEVICE_MODE_NOT_SET),
       submit_machine_id_(false),
       public_key_version_(-1),
       public_key_version_valid_(false),
+      invalidation_version_(0),
+      fetched_invalidation_version_(0),
       service_(service),                  // Can be NULL for unit tests.
       status_provider_(status_provider),  // Can be NULL for unit tests.
       status_(DM_STATUS_SUCCESS) {
 }
 
 CloudPolicyClient::~CloudPolicyClient() {
   STLDeleteValues(&responses_);
 }
 
 void CloudPolicyClient::SetupRegistration(const std::string& dm_token,
@@ skipping 47 matching lines @@
   if (!requisition.empty())
     request->set_requisition(requisition);
 
   request_job_->SetRetryCallback(
       base::Bind(&CloudPolicyClient::OnRetryRegister, base::Unretained(this)));
 
   request_job_->Start(base::Bind(&CloudPolicyClient::OnRegisterCompleted,
                                  base::Unretained(this)));
 }
 
+void CloudPolicyClient::SetInvalidationInfo(
+    int64 version,
+    const std::string& payload) {
+  invalidation_version_ = version;
+  invalidation_payload_ = payload;
+}
+
 void CloudPolicyClient::FetchPolicy() {
   CHECK(is_registered());
   CHECK(!namespaces_to_fetch_.empty());
 
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH));
   request_job_->SetDMToken(dm_token_);
   request_job_->SetClientID(client_id_);
   request_job_->SetUserAffiliation(user_affiliation_);
 
@@ skipping 20 matching lines @@
 
     // These fields are included only in requests for chrome policy.
     if (IsChromePolicy(it->first)) {
       if (submit_machine_id_ && !machine_id_.empty())
         fetch_request->set_machine_id(machine_id_);
       if (!last_policy_timestamp_.is_null()) {
         base::TimeDelta timestamp(
             last_policy_timestamp_ - base::Time::UnixEpoch());
         fetch_request->set_timestamp(timestamp.InMilliseconds());
       }
+      if (!invalidation_payload_.empty()) {
+        fetch_request->set_invalidation_version(invalidation_version_);
+        fetch_request->set_invalidation_payload(invalidation_payload_);
+      }
     }
   }
 
   // Add status data.
   if (status_provider_) {
     if (!status_provider_->GetDeviceStatus(
             request->mutable_device_status_report_request())) {
       request->clear_device_status_report_request();
     }
     if (!status_provider_->GetSessionStatus(
             request->mutable_session_status_report_request())) {
       request->clear_session_status_report_request();
     }
   }
 
   // Fire the job.
+  fetched_invalidation_version_ = invalidation_version_;

[Joao da Silva, 2013/07/24 15:34:07]

This should be at OnPolicyFetchCompleted, and done only if the request
succeeded.

[Steve Condie, 2013/07/25 01:18:08]

That actually wouldn't do what I want because it's possible that in between the
call to FetchPolicy and the call to OnPolicyFetchCompleted, another invalidation
was received, but due to "jittering", FetchPolicy hasn't been called again. In
that case, fetched_invalidation_version_ would be set to the latest invalidation
instead of the true invalidation which was fetched which would then cause the
invalidator to cancel the refresh for the latter invalidation.

[Joao da Silva, 2013/07/25 18:03:53]

I see, thanks for clarifying. Please add a comment explaining that here.

[Steve Condie, 2013/07/26 01:39:25]

Done.

   request_job_->Start(base::Bind(&CloudPolicyClient::OnPolicyFetchCompleted,
                                  base::Unretained(this)));
 }
 
 void CloudPolicyClient::FetchRobotAuthCodes(const std::string& auth_token) {
   CHECK(is_registered());
   DCHECK(!auth_token.empty());
 
   request_job_.reset(service_->CreateJob(
       DeviceManagementRequestJob::TYPE_API_AUTH_CODE_FETCH));
@@ skipping 224 matching lines @@
 
 void CloudPolicyClient::NotifyRobotAuthCodesFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRobotAuthCodesFetched(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy