Home | History | Annotate | Download | only in help 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/memory/ref_counted.h"
      6 #include "base/memory/scoped_ptr.h"
      7 #include "base/memory/weak_ptr.h"
      8 #include "base/strings/string16.h"
      9 #include "base/version.h"
     10 #include "base/win/win_util.h"
     11 #include "base/win/windows_version.h"
     12 #include "chrome/browser/google/google_update_win.h"
     13 #include "chrome/browser/lifetime/application_lifetime.h"
     14 #include "chrome/browser/ui/browser.h"
     15 #include "chrome/browser/ui/webui/help/version_updater.h"
     16 #include "chrome/common/chrome_version_info.h"
     17 #include "chrome/grit/chromium_strings.h"
     18 #include "chrome/grit/generated_resources.h"
     19 #include "chrome/installer/util/browser_distribution.h"
     20 #include "chrome/installer/util/install_util.h"
     21 #include "content/public/browser/browser_thread.h"
     22 #include "ui/base/l10n/l10n_util.h"
     23 #include "ui/views/widget/widget.h"
     24 
     25 using content::BrowserThread;
     26 
     27 namespace {
     28 
     29 // Windows implementation of version update functionality, used by the WebUI
     30 // About/Help page.
     31 class VersionUpdaterWin : public VersionUpdater,
     32                           public GoogleUpdateStatusListener {
     33  private:
     34   friend class VersionReader;
     35   friend class VersionUpdater;
     36 
     37   // Clients must use VersionUpdater::Create().
     38   VersionUpdaterWin();
     39   virtual ~VersionUpdaterWin();
     40 
     41   // VersionUpdater implementation.
     42   virtual void CheckForUpdate(const StatusCallback& callback) OVERRIDE;
     43   virtual void RelaunchBrowser() const OVERRIDE;
     44 
     45   // GoogleUpdateStatusListener implementation.
     46   virtual void OnReportResults(GoogleUpdateUpgradeResult result,
     47                                GoogleUpdateErrorCode error_code,
     48                                const base::string16& error_message,
     49                                const base::string16& version) OVERRIDE;
     50 
     51   // Update the UI to show the status of the upgrade.
     52   void UpdateStatus(GoogleUpdateUpgradeResult result,
     53                     GoogleUpdateErrorCode error_code,
     54                     const base::string16& error_message);
     55 
     56   // Got the intalled version so the handling of the UPGRADE_ALREADY_UP_TO_DATE
     57   // result case can now be completeb on the UI thread.
     58   void GotInstalledVersion(const Version& version);
     59 
     60   // Little helper function to create google_updater_.
     61   void CreateGoogleUpdater();
     62 
     63   // Helper function to clear google_updater_.
     64   void ClearGoogleUpdater();
     65 
     66   // Returns a window that can be used for elevation.
     67   HWND GetElevationParent();
     68 
     69   // The class that communicates with Google Update to find out if an update is
     70   // available and asks it to start an upgrade.
     71   scoped_refptr<GoogleUpdate> google_updater_;
     72 
     73   // Used for callbacks.
     74   base::WeakPtrFactory<VersionUpdaterWin> weak_factory_;
     75 
     76   // Callback used to communicate update status to the client.
     77   StatusCallback callback_;
     78 
     79   DISALLOW_COPY_AND_ASSIGN(VersionUpdaterWin);
     80 };
     81 
     82 // This class is used to read the version on the FILE thread and then call back
     83 // the version updater in the UI thread. Using a class helps better control
     84 // the lifespan of the Version independently of the lifespan of the version
     85 // updater, which may die while asynchonicity is happening, thus the usage of
     86 // the WeakPtr, which can only be used from the thread that created it.
     87 class VersionReader
     88     : public base::RefCountedThreadSafe<VersionReader> {
     89  public:
     90   explicit VersionReader(
     91       const base::WeakPtr<VersionUpdaterWin>& version_updater)
     92       : version_updater_(version_updater) {
     93   }
     94 
     95   void GetVersionFromFileThread() {
     96     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     97     InstallUtil::GetChromeVersion(dist, false, &installed_version_);
     98     if (!installed_version_.IsValid()) {
     99       // User-level Chrome is not installed, check system-level.
    100       InstallUtil::GetChromeVersion(dist, true, &installed_version_);
    101     }
    102     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
    103           &VersionReader::SetVersionInUIThread, this));
    104   }
    105 
    106   void SetVersionInUIThread() {
    107     if (version_updater_.get() != NULL)
    108       version_updater_->GotInstalledVersion(installed_version_);
    109   }
    110 
    111  private:
    112   friend class base::RefCountedThreadSafe<VersionReader>;
    113 
    114   // The version updater that must be called back when we are done.
    115   // We use a weak pointer in case the updater gets destroyed while waiting.
    116   base::WeakPtr<VersionUpdaterWin> version_updater_;
    117 
    118   // This is the version that gets read in the FILE thread and set on the
    119   // the updater in the UI thread.
    120   Version installed_version_;
    121 };
    122 
    123 VersionUpdaterWin::VersionUpdaterWin()
    124     : weak_factory_(this) {
    125   CreateGoogleUpdater();
    126 }
    127 
    128 VersionUpdaterWin::~VersionUpdaterWin() {
    129   // The Google Updater will hold a pointer to the listener until it reports
    130   // status, so that pointer must be cleared when the listener is destoyed.
    131   ClearGoogleUpdater();
    132 }
    133 
    134 void VersionUpdaterWin::CheckForUpdate(const StatusCallback& callback) {
    135   callback_ = callback;
    136 
    137   // On-demand updates for Chrome don't work in Vista RTM when UAC is turned
    138   // off. So, in this case, the version updater must not mention
    139   // on-demand updates. Silent updates (in the background) should still
    140   // work as before - enabling UAC or installing the latest service pack
    141   // for Vista is another option.
    142   if (!(base::win::GetVersion() == base::win::VERSION_VISTA &&
    143         (base::win::OSInfo::GetInstance()->service_pack().major == 0) &&
    144         !base::win::UserAccountControlIsEnabled())) {
    145     // This could happen if the page got refreshed after results were returned.
    146     if (!google_updater_)
    147       CreateGoogleUpdater();
    148     UpdateStatus(UPGRADE_CHECK_STARTED, GOOGLE_UPDATE_NO_ERROR,
    149                  base::string16());
    150     // Specify false to not upgrade yet.
    151     google_updater_->CheckForUpdate(false, GetElevationParent());
    152   }
    153 }
    154 
    155 void VersionUpdaterWin::RelaunchBrowser() const {
    156   chrome::AttemptRestart();
    157 }
    158 
    159 void VersionUpdaterWin::OnReportResults(
    160     GoogleUpdateUpgradeResult result, GoogleUpdateErrorCode error_code,
    161     const base::string16& error_message, const base::string16& version) {
    162   // Drop the last reference to the object so that it gets cleaned up here.
    163   ClearGoogleUpdater();
    164   UpdateStatus(result, error_code, error_message);
    165 }
    166 
    167 void VersionUpdaterWin::UpdateStatus(GoogleUpdateUpgradeResult result,
    168                                      GoogleUpdateErrorCode error_code,
    169                                      const base::string16& error_message) {
    170   // For Chromium builds it would show an error message.
    171   // But it looks weird because in fact there is no error,
    172   // just the update server is not available for non-official builds.
    173 #if defined(GOOGLE_CHROME_BUILD)
    174   Status status = UPDATED;
    175   base::string16 message;
    176 
    177   switch (result) {
    178     case UPGRADE_CHECK_STARTED: {
    179       status = CHECKING;
    180       break;
    181     }
    182     case UPGRADE_STARTED: {
    183       status = UPDATING;
    184       break;
    185     }
    186     case UPGRADE_IS_AVAILABLE: {
    187       DCHECK(!google_updater_);  // Should have been nulled out already.
    188       CreateGoogleUpdater();
    189       UpdateStatus(UPGRADE_STARTED, GOOGLE_UPDATE_NO_ERROR, base::string16());
    190       // Specify true to upgrade now.
    191       google_updater_->CheckForUpdate(true, GetElevationParent());
    192       return;
    193     }
    194     case UPGRADE_ALREADY_UP_TO_DATE: {
    195       // Google Update reported that Chrome is up-to-date.
    196       // To confirm the updated version is running, the reading
    197       // must be done on the file thread. The rest of this case
    198       // will be handled within GotInstalledVersion.
    199       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
    200             &VersionReader::GetVersionFromFileThread,
    201             new VersionReader(weak_factory_.GetWeakPtr())));
    202       return;
    203     }
    204     case UPGRADE_SUCCESSFUL: {
    205       status = NEARLY_UPDATED;
    206       break;
    207     }
    208     case UPGRADE_ERROR: {
    209       status = FAILED;
    210       if (error_code == GOOGLE_UPDATE_DISABLED_BY_POLICY) {
    211         message =
    212             l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY);
    213       } else if (error_code == GOOGLE_UPDATE_DISABLED_BY_POLICY_AUTO_ONLY) {
    214         message =
    215             l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY_MANUAL);
    216       } else {
    217         message =
    218             l10n_util::GetStringFUTF16Int(IDS_UPGRADE_ERROR, error_code);
    219       }
    220 
    221       if (!error_message.empty()) {
    222         message +=
    223             l10n_util::GetStringFUTF16(IDS_ABOUT_BOX_ERROR_DURING_UPDATE_CHECK,
    224                                        error_message);
    225       }
    226       break;
    227     }
    228   }
    229 
    230   // TODO(mad): Get proper progress value instead of passing 0.
    231   // http://crbug.com/136117
    232   callback_.Run(status, 0, message);
    233 #endif  //  defined(GOOGLE_CHROME_BUILD)
    234 }
    235 
    236 void VersionUpdaterWin::GotInstalledVersion(const Version& version) {
    237   // This must be called on the UI thread so that callback_ can be called.
    238   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    239 
    240   // Make sure that the latest version is running and if not,
    241   // notify the user by setting the status to NEARLY_UPDATED.
    242   //
    243   // The extra version check is necessary on Windows because the application
    244   // may be already up to date on disk though the running app is still
    245   // out of date.
    246   chrome::VersionInfo version_info;
    247   Version running_version(version_info.Version());
    248   callback_.Run((version.IsValid() && version.CompareTo(running_version) > 0)
    249                     ? NEARLY_UPDATED
    250                     : UPDATED,
    251                 0,
    252                 base::string16());
    253 }
    254 
    255 void VersionUpdaterWin::CreateGoogleUpdater() {
    256   ClearGoogleUpdater();
    257   google_updater_ = new GoogleUpdate();
    258   google_updater_->set_status_listener(this);
    259 }
    260 
    261 void VersionUpdaterWin::ClearGoogleUpdater() {
    262   if (google_updater_) {
    263     google_updater_->set_status_listener(NULL);
    264     google_updater_ = NULL;
    265   }
    266 }
    267 
    268 BOOL CALLBACK WindowEnumeration(HWND window, LPARAM param) {
    269   if (IsWindowVisible(window)) {
    270     HWND* returned_window = reinterpret_cast<HWND*>(param);
    271     *returned_window = window;
    272     return FALSE;
    273   }
    274   return TRUE;
    275 }
    276 
    277 HWND VersionUpdaterWin::GetElevationParent() {
    278   // Look for a visible window belonging to the UI thread.
    279   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    280   HWND window = NULL;
    281   EnumThreadWindows(GetCurrentThreadId(),
    282                     WindowEnumeration,
    283                     reinterpret_cast<LPARAM>(&window));
    284 #if !defined(USE_AURA)
    285   // If using Aura, we might not have a Visible window in this process. In
    286   // theory Google update can cope with that.
    287   DCHECK(window != NULL) << "Failed to find a valid window handle on thread: "
    288                          << GetCurrentThreadId();
    289 #endif
    290   return window;
    291 }
    292 
    293 }  // namespace
    294 
    295 VersionUpdater* VersionUpdater::Create() {
    296   return new VersionUpdaterWin;
    297 }
    298