Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/cloud_policy_refresh_scheduler.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_refresh_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 17 matching lines @@
 const int64 CloudPolicyRefreshScheduler::kDefaultRefreshDelayMs =
     3 * 60 * 60 * 1000;  // 3 hours.
 const int64 CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs =
     24 * 60 * 60 * 1000;  // 1 day.
 const int64 CloudPolicyRefreshScheduler::kInitialErrorRetryDelayMs =
     5 * 60 * 1000;  // 5 minutes.
 const int64 CloudPolicyRefreshScheduler::kRefreshDelayMinMs =
     30 * 60 * 1000;  // 30 minutes.
 const int64 CloudPolicyRefreshScheduler::kRefreshDelayMaxMs =
     24 * 60 * 60 * 1000;  // 1 day.
+const int64 CloudPolicyRefreshScheduler::kFirstRefreshDelayMs = 4000;
 
 CloudPolicyRefreshScheduler::CloudPolicyRefreshScheduler(
     CloudPolicyClient* client,
     CloudPolicyStore* store,
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner)
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+    bool invalidations_enabled)
     : client_(client),
       store_(store),
       task_runner_(task_runner),
       error_retry_delay_ms_(kInitialErrorRetryDelayMs),
       refresh_delay_ms_(kDefaultRefreshDelayMs),
       rate_limiter_(kMaxRefreshesPerHour,
                     base::TimeDelta::FromHours(1),
                     base::Bind(&CloudPolicyRefreshScheduler::RefreshNow,
                                base::Unretained(this)),
                     task_runner_,
-                    scoped_ptr<base::TickClock>(new base::DefaultTickClock())) {
+                    scoped_ptr<base::TickClock>(new base::DefaultTickClock())),
+      first_refresh_(base::Time::NowFromSystemTime() +
+                     base::TimeDelta::FromMilliseconds(kFirstRefreshDelayMs)) {
   client_->AddObserver(this);
   store_->AddObserver(this);
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
 
+  // Disable first refresh delay if invalidations are not enabled.
+  if (!invalidations_enabled)
+    first_refresh_ = base::Time();
   UpdateLastRefreshFromPolicy();
   ScheduleRefresh();
 }
 
 CloudPolicyRefreshScheduler::~CloudPolicyRefreshScheduler() {
   store_->RemoveObserver(this);
   client_->RemoveObserver(this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void CloudPolicyRefreshScheduler::SetRefreshDelay(int64 refresh_delay) {
   refresh_delay_ms_ = std::min(std::max(refresh_delay, kRefreshDelayMinMs),
                                kRefreshDelayMaxMs);
   ScheduleRefresh();
 }
 
 void CloudPolicyRefreshScheduler::RefreshSoon() {
   rate_limiter_.PostRequest();
 }
 
+void CloudPolicyRefreshScheduler::RefreshForInvalidation() {
+  // Remove the first refresh time restriction, as the intent is to prevent
+  // refreshes on login from occurring before invalidations can be processed.
+  first_refresh_ = base::Time();
+  RefreshNow();
+}
+
 void CloudPolicyRefreshScheduler::OnPolicyFetched(CloudPolicyClient* client) {
   error_retry_delay_ms_ = kInitialErrorRetryDelayMs;
 
   // Schedule the next refresh.
   last_refresh_ = base::Time::NowFromSystemTime();
   ScheduleRefresh();
 }
 
 void CloudPolicyRefreshScheduler::OnRegistrationStateChanged(
     CloudPolicyClient* client) {
@@ skipping 124 matching lines @@
 
   // This should never happen, as the registration change should have been
   // handled via OnRegistrationStateChanged().
   NOTREACHED();
 }
 
 void CloudPolicyRefreshScheduler::RefreshAfter(int delta_ms) {
   base::TimeDelta delta(base::TimeDelta::FromMilliseconds(delta_ms));
   refresh_callback_.Cancel();
 
+  // Make sure the refresh does not occur before the first refresh time.

[rlarocque, 2013/07/23 17:43:08]

Did cloud policy refresh within minutes of restarting the browser prior to this
change?  If so, where did that call come from?  The refresh delays hard-coded at
the top of this file seem to be significantly longer.

[Joao da Silva, 2013/07/23 20:44:47]

On the desktop, yes (on Android we will delay it depending on the age of the
cache).

Basically |last_refresh_| won't be initialized at startup for managed users, so
the first schedule call will get a huge cache age, and always refreshes. This is
intentional, and is not delayed here (but the networking backend of this code
delays all policy requests by 15 seconds at startup).

[Steve Condie, 2013/07/24 01:42:04]

As we discussed I reverted all my changes to CloudPolicyRefreshScheduler as you
will handle it in your larger Android change to the class.

+  base::Time now = base::Time::NowFromSystemTime();
+  base::TimeDelta min_delay;
+  if (now < first_refresh_)
+    min_delay = first_refresh_ - now;
+
   // Schedule the callback.
-  base::TimeDelta delay =
-      std::max((last_refresh_ + delta) - base::Time::NowFromSystemTime(),
-               base::TimeDelta());
+  base::TimeDelta delay = std::max((last_refresh_ + delta) - now, min_delay);
   refresh_callback_.Reset(
       base::Bind(&CloudPolicyRefreshScheduler::PerformRefresh,
                  base::Unretained(this)));
   task_runner_->PostDelayedTask(FROM_HERE, refresh_callback_.callback(), delay);
 }
 
 }  // namespace policy