Fix DCHECK failure in extension_updater when scheduling first check

chrome/browser/extensions/updater/extension_updater.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/extensions/updater/extension_updater.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 36 matching lines @@
 
 typedef extensions::ExtensionDownloaderDelegate::Error Error;
 typedef extensions::ExtensionDownloaderDelegate::PingResult PingResult;
 
 namespace {
 
 // Wait at least 60 seconds after browser startup before we do any checks. If
 // you change this value, make sure to update comments where it is used.
 const int kStartupWaitSeconds = 60;
 
+// The minimum number of seconds there should be for the delay passed to
+// ScheduleNextCheck.
+const int kScheduleNextCheckMinGapSecs = 1;
+
 // For sanity checking on update frequency - enforced in release mode only.
 #if defined(NDEBUG)
 const int kMinUpdateFrequencySeconds = 30;
 #endif
 const int kMaxUpdateFrequencySeconds = 60 * 60 * 24 * 7;  // 7 days
 
 // When we've computed a days value, we want to make sure we don't send a
 // negative value (due to the system clock being set backwards, etc.), since -1
 // is a special sentinel value that means "never pinged", and other negative
 // values don't make sense.
@@ skipping 104 matching lines @@
   // If someone's testing with a quick frequency, just allow it.
   if (frequency_seconds_ < kStartupWaitSeconds)
     return TimeDelta::FromSeconds(frequency_seconds_);
 
   // If we've never scheduled a check before, start at a random time up to
   // frequency_seconds_ away.
   if (!prefs_->HasPrefPath(pref_names::kNextUpdateCheck))
     return TimeDelta::FromSeconds(
         RandInt(kStartupWaitSeconds, frequency_seconds_));
 
+  // Read the persisted next check time, and use that if it isn't in the past
+  // or too far in the future (this can happen with system clock changes).
   Time saved_next = Time::FromInternalValue(prefs_->GetInt64(
       pref_names::kNextUpdateCheck));
-
   Time now = Time::Now();
-
-  // Read the persisted next check time, and use that if it isn't in the past
-  // or too far in the future (this can happen with system clock changes).
-  if (saved_next > now &&
-      saved_next < now + TimeDelta::FromSeconds(frequency_seconds_)) {
+  base::Time earliest =
+      now + TimeDelta::FromSeconds(kScheduleNextCheckMinGapSecs);
+  base::Time latest = now + TimeDelta::FromSeconds(frequency_seconds_);
+  if (saved_next > earliest && saved_next < latest) {
     return saved_next - now;
   }
 
   // In most cases we'll get here because the persisted next check time passed
   // while we weren't running, so pick something soon.
   return TimeDelta::FromSeconds(
       RandInt(kStartupWaitSeconds, kStartupWaitSeconds * 5));
 }
 
 void ExtensionUpdater::Start() {
@@ skipping 18 matching lines @@
   prefs_ = NULL;
   profile_ = NULL;
   timer_.Stop();
   will_check_soon_ = false;
   downloader_.reset();
 }
 
 void ExtensionUpdater::ScheduleNextCheck(const TimeDelta& target_delay) {
   DCHECK(alive_);
   DCHECK(!timer_.IsRunning());
-  DCHECK(target_delay >= TimeDelta::FromSeconds(1));
+  DCHECK(target_delay >= TimeDelta::FromSeconds(kScheduleNextCheckMinGapSecs));
 
   // Add +/- 10% random jitter.
   double delay_ms = target_delay.InMillisecondsF();
   double jitter_factor = (RandDouble() * .2) - 0.1;
   delay_ms += delay_ms * jitter_factor;
   TimeDelta actual_delay =
       TimeDelta::FromMilliseconds(static_cast<int64_t>(delay_ms));
 
   // Save the time of next check.
   Time next = Time::Now() + actual_delay;
@@ skipping 359 matching lines @@
   const InProgressCheck& request = requests_in_progress_[request_id];
   if (request.in_progress_ids_.empty()) {
     VLOG(2) << "Finished update check " << request_id;
     if (!request.callback.is_null())
       request.callback.Run();
     requests_in_progress_.erase(request_id);
   }
 }
 
 }  // namespace extensions