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 25using content::BrowserThread; 26 27namespace { 28 29// Windows implementation of version update functionality, used by the WebUI 30// About/Help page. 31class 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. 87class 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 123VersionUpdaterWin::VersionUpdaterWin() 124 : weak_factory_(this) { 125 CreateGoogleUpdater(); 126} 127 128VersionUpdaterWin::~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 134void 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 155void VersionUpdaterWin::RelaunchBrowser() const { 156 chrome::AttemptRestart(); 157} 158 159void 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 167void 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 236void 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 255void VersionUpdaterWin::CreateGoogleUpdater() { 256 ClearGoogleUpdater(); 257 google_updater_ = new GoogleUpdate(); 258 google_updater_->set_status_listener(this); 259} 260 261void VersionUpdaterWin::ClearGoogleUpdater() { 262 if (google_updater_) { 263 google_updater_->set_status_listener(NULL); 264 google_updater_ = NULL; 265 } 266} 267 268BOOL 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 277HWND 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 295VersionUpdater* VersionUpdater::Create() { 296 return new VersionUpdaterWin; 297} 298