Simulate variation seeds using installed version string.

chrome/browser/upgrade_detector_impl.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/upgrade_detector_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/launch.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/network_time/network_time_tracker.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_WIN)
@@ skipping 211 matching lines @@
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&CheckForUnstableChannel,
                                      start_upgrade_check_timer_task,
                                      &is_unstable_channel_));
 #endif
 }
 
 UpgradeDetectorImpl::~UpgradeDetectorImpl() {
 }
 
-// Static
-// This task checks the currently running version of Chrome against the
-// installed version. If the installed version is newer, it calls back
-// UpgradeDetectorImpl::UpgradeDetected using a weak pointer so that it can
-// be interrupted from the UI thread.
-void UpgradeDetectorImpl::DetectUpgradeTask(
-    base::WeakPtr<UpgradeDetectorImpl> upgrade_detector) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+// static
+base::Version UpgradeDetectorImpl::GetCurrentlyInstalledVersion() {
+  base::ThreadRestrictions::AssertIOAllowed();
 
   Version installed_version;
-  Version critical_update;
-
 #if defined(OS_WIN)
   // Get the version of the currently *installed* instance of Chrome,
   // which might be newer than the *running* instance if we have been
   // upgraded in the background.
   bool system_install = IsSystemInstall();
 
   // TODO(tommi): Check if using the default distribution is always the right
   // thing to do.
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   InstallUtil::GetChromeVersion(dist, system_install, &installed_version);
-
-  if (installed_version.IsValid()) {
-    InstallUtil::GetCriticalUpdateVersion(dist, system_install,
-                                          &critical_update);
-  }
 #elif defined(OS_MACOSX)
   installed_version =
       Version(base::UTF16ToASCII(keystone_glue::CurrentlyInstalledVersion()));
 #elif defined(OS_POSIX)
   // POSIX but not Mac OS X: Linux, etc.
   CommandLine command_line(*CommandLine::ForCurrentProcess());
   command_line.AppendSwitch(switches::kProductVersion);
   std::string reply;
   if (!base::GetAppOutput(command_line, &reply)) {
     DLOG(ERROR) << "Failed to get current file version";
     return;
   }
 
   installed_version = Version(reply);
 #endif
+  return installed_version;
+}
+
+// static
+// This task checks the currently running version of Chrome against the
+// installed version. If the installed version is newer, it calls back
+// UpgradeDetectorImpl::UpgradeDetected using a weak pointer so that it can
+// be interrupted from the UI thread.
+void UpgradeDetectorImpl::DetectUpgradeTask(
+    base::WeakPtr<UpgradeDetectorImpl> upgrade_detector) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  Version installed_version = GetCurrentlyInstalledVersion();
+  Version critical_update;
+#if defined(OS_WIN)
+  if (installed_version.IsValid()) {
+    InstallUtil::GetCriticalUpdateVersion(dist, system_install,
+                                          &critical_update);
+  }
+#endif
 
   // Get the version of the currently *running* instance of Chrome.
   chrome::VersionInfo version_info;
   if (!version_info.is_valid()) {
     NOTREACHED() << "Failed to get current file version";
     return;
   }
   Version running_version(version_info.Version());
   if (!running_version.IsValid()) {
     NOTREACHED();
@@ skipping 122 matching lines @@
   bool is_testing = IsTesting();
   int64 time_passed = is_testing ? delta.InSeconds() : delta.InHours();
 
   bool is_critical_or_outdated = upgrade_available_ > UPGRADE_AVAILABLE_REGULAR;
   if (is_unstable_channel_) {
     // There's only one threat level for unstable channels like dev and
     // canary, and it hits after one hour. During testing, it hits after one
     // second.
     const int kUnstableThreshold = 1;
 
-    if (is_critical_or_outdated)
+    if (is_critical_or_outdated) {
       set_upgrade_notification_stage(UPGRADE_ANNOYANCE_CRITICAL);
-    else if (time_passed >= kUnstableThreshold) {
+    } else if (time_passed >= kUnstableThreshold) {
       set_upgrade_notification_stage(UPGRADE_ANNOYANCE_LOW);
 
       // That's as high as it goes.
       upgrade_notification_timer_.Stop();
     } else {
       return;  // Not ready to recommend upgrade.
     }
   } else {
     const int kMultiplier = is_testing ? 10 : 24;
     // 14 days when not testing, otherwise 14 seconds.
@@ skipping 26 matching lines @@
 
 // static
 UpgradeDetectorImpl* UpgradeDetectorImpl::GetInstance() {
   return Singleton<UpgradeDetectorImpl>::get();
 }
 
 // static
 UpgradeDetector* UpgradeDetector::GetInstance() {
   return UpgradeDetectorImpl::GetInstance();
 }