Remove first check random delay on older devices

components/quirks/quirks_manager.cc

 // Copyright 2016 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 "components/quirks/quirks_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
-#include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/quirks/pref_names.h"
 #include "components/quirks/quirks_client.h"
 #include "components/quirks/switches.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
@@ skipping 16 matching lines @@
   // TODO(glevin): If file exists, do we want to implement a hash to verify that
   // the file hasn't been corrupted or tampered with?
   return exists;
 }
 
 base::FilePath CheckForIccFile(base::FilePath built_in_path,
                                base::FilePath download_path,
                                bool quirks_enabled) {
   // First, look for icc file in old read-only location.  If there, we don't use
   // the Quirks server.
-  // TODO(glevin): Awaiting final decision on how to handle old read-only files.
   if (CheckAndLogFile(built_in_path))
     return built_in_path;
 
   // If experimental Quirks flag isn't set, no other icc file is available.
   if (!quirks_enabled) {
     VLOG(1) << "Quirks Client disabled, no built-in icc file available.";
     return base::FilePath();
   }
 
   // Check if QuirksClient has already downloaded icc file from server.
@@ skipping 122 matching lines @@
     on_request_finished.Run(path, false);
     // TODO(glevin): If Quirks files are ever modified on the server, we'll need
     // to modify this logic to check for updates. See crbug.com/595024.
     return;
   }
 
   double last_check = 0.0;
   local_state_->GetDictionary(prefs::kQuirksClientLastServerCheck)
       ->GetDouble(IdToHexString(product_id), &last_check);
 
-  // If never checked server before, need to check for new device.
-  if (last_check == 0.0) {
-    delegate_->GetDaysSinceOobe(base::Bind(
-        &QuirksManager::OnDaysSinceOobeReceived, weak_ptr_factory_.GetWeakPtr(),
-        product_id, on_request_finished));
-    return;
-  }
-
   const base::TimeDelta time_since =
       base::Time::Now() - base::Time::FromDoubleT(last_check);
 
   // Don't need server check if we've checked within last 30 days.
   if (time_since < base::TimeDelta::FromDays(kDaysBetweenServerChecks)) {
     VLOG(2) << time_since.InDays()
             << " days since last Quirks Server check for display "
             << IdToHexString(product_id);
     on_request_finished.Run(base::FilePath(), false);
     return;
   }
 
-  CreateClient(product_id, on_request_finished);
-}
-
-void QuirksManager::OnDaysSinceOobeReceived(
-    int64_t product_id,
-    const RequestFinishedCallback& on_request_finished,
-    int days_since_oobe) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // On newer devices, we want to check server immediately (after OOBE/login).
-  if (days_since_oobe <= kDaysBetweenServerChecks) {
-    CreateClient(product_id, on_request_finished);
-    return;
-  }
-
-  // Otherwise, for the first check on an older device, we want to stagger
-  // it over 30 days, so artificially set last check accordingly.
-  // TODO(glevin): I believe that it makes sense to remove this random delay
-  // in the next Chrome release.
-  const int rand_days = base::RandInt(0, kDaysBetweenServerChecks);
-  const base::Time fake_last_check =
-      base::Time::Now() - base::TimeDelta::FromDays(rand_days);
-  SetLastServerCheck(product_id, fake_last_check);
-  VLOG(2) << "Delaying first Quirks Server check by "
-          << kDaysBetweenServerChecks - rand_days << " days.";
-
-  on_request_finished.Run(base::FilePath(), false);
-}
-
-void QuirksManager::CreateClient(
-    int64_t product_id,
-    const RequestFinishedCallback& on_request_finished) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  // Create and start a client to download file.
   QuirksClient* client =
       new QuirksClient(product_id, on_request_finished, this);
   clients_.insert(base::WrapUnique(client));
   if (!waiting_for_login_)
     client->StartDownload();
   else
     VLOG(2) << "Quirks Client created; waiting for login to begin download.";
 }
 
 bool QuirksManager::QuirksEnabled() {
@@ skipping 10 matching lines @@
 }
 
 void QuirksManager::SetLastServerCheck(int64_t product_id,
                                        const base::Time& last_check) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DictionaryPrefUpdate dict(local_state_, prefs::kQuirksClientLastServerCheck);
   dict->SetDouble(IdToHexString(product_id), last_check.ToDoubleT());
 }
 
 }  // namespace quirks