Home | History | Annotate | Download | only in google 
      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 "chrome/browser/google/google_update_win.h"
      6 
      7 #include <atlbase.h>
      8 #include <atlcom.h>
      9 
     10 #include "base/bind.h"
     11 #include "base/files/file_path.h"
     12 #include "base/message_loop/message_loop.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/metrics/sparse_histogram.h"
     15 #include "base/path_service.h"
     16 #include "base/strings/string_util.h"
     17 #include "base/strings/stringprintf.h"
     18 #include "base/threading/thread.h"
     19 #include "base/win/scoped_comptr.h"
     20 #include "base/win/windows_version.h"
     21 #include "chrome/grit/generated_resources.h"
     22 #include "chrome/installer/util/browser_distribution.h"
     23 #include "chrome/installer/util/google_update_settings.h"
     24 #include "chrome/installer/util/helper.h"
     25 #include "chrome/installer/util/install_util.h"
     26 #include "content/public/browser/browser_thread.h"
     27 #include "google_update/google_update_idl.h"
     28 #include "ui/base/l10n/l10n_util.h"
     29 #include "ui/base/win/atl_module.h"
     30 #include "ui/views/widget/widget.h"
     31 
     32 using content::BrowserThread;
     33 
     34 namespace {
     35 
     36 // Check if the currently running instance can be updated by Google Update.
     37 // Returns GOOGLE_UPDATE_NO_ERROR only if the instance running is a Google
     38 // Chrome distribution installed in a standard location.
     39 GoogleUpdateErrorCode CanUpdateCurrentChrome(
     40     const base::FilePath& chrome_exe_path) {
     41 #if !defined(GOOGLE_CHROME_BUILD)
     42   return CANNOT_UPGRADE_CHROME_IN_THIS_DIRECTORY;
     43 #else
     44   // TODO(tommi): Check if using the default distribution is always the right
     45   // thing to do.
     46   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     47   base::FilePath user_exe_path = installer::GetChromeInstallPath(false, dist);
     48   base::FilePath machine_exe_path = installer::GetChromeInstallPath(true, dist);
     49   if (!base::FilePath::CompareEqualIgnoreCase(chrome_exe_path.value(),
     50                                         user_exe_path.value()) &&
     51       !base::FilePath::CompareEqualIgnoreCase(chrome_exe_path.value(),
     52                                         machine_exe_path.value())) {
     53     LOG(ERROR) << L"Google Update cannot update Chrome installed in a "
     54                << L"non-standard location: " << chrome_exe_path.value().c_str()
     55                << L". The standard location is: "
     56                    << user_exe_path.value().c_str()
     57                << L" or " << machine_exe_path.value().c_str() << L".";
     58     return CANNOT_UPGRADE_CHROME_IN_THIS_DIRECTORY;
     59   }
     60 
     61   base::string16 app_guid = installer::GetAppGuidForUpdates(
     62       !InstallUtil::IsPerUserInstall(chrome_exe_path.value().c_str()));
     63   DCHECK(!app_guid.empty());
     64 
     65   GoogleUpdateSettings::UpdatePolicy update_policy =
     66       GoogleUpdateSettings::GetAppUpdatePolicy(app_guid, NULL);
     67 
     68   if (update_policy == GoogleUpdateSettings::UPDATES_DISABLED)
     69     return GOOGLE_UPDATE_DISABLED_BY_POLICY;
     70 
     71   if (update_policy == GoogleUpdateSettings::AUTO_UPDATES_ONLY)
     72     return GOOGLE_UPDATE_DISABLED_BY_POLICY_AUTO_ONLY;
     73 
     74   return GOOGLE_UPDATE_NO_ERROR;
     75 #endif
     76 }
     77 
     78 // Creates an instance of a COM Local Server class using either plain vanilla
     79 // CoCreateInstance, or using the Elevation moniker if running on Vista.
     80 // hwnd must refer to a foregound window in order to get the UAC prompt
     81 // showing up in the foreground if running on Vista. It can also be NULL if
     82 // background UAC prompts are desired.
     83 HRESULT CoCreateInstanceAsAdmin(REFCLSID class_id, REFIID interface_id,
     84                                 HWND hwnd, void** interface_ptr) {
     85   if (!interface_ptr)
     86     return E_POINTER;
     87 
     88   // For Vista, need to instantiate the COM server via the elevation
     89   // moniker. This ensures that the UAC dialog shows up.
     90   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     91     wchar_t class_id_as_string[MAX_PATH] = {0};
     92     StringFromGUID2(class_id, class_id_as_string,
     93                     arraysize(class_id_as_string));
     94 
     95     base::string16 elevation_moniker_name =
     96         base::StringPrintf(L"Elevation:Administrator!new:%ls",
     97                            class_id_as_string);
     98 
     99     BIND_OPTS3 bind_opts;
    100     memset(&bind_opts, 0, sizeof(bind_opts));
    101     bind_opts.cbStruct = sizeof(bind_opts);
    102     bind_opts.dwClassContext = CLSCTX_LOCAL_SERVER;
    103     bind_opts.hwnd = hwnd;
    104 
    105     return CoGetObject(elevation_moniker_name.c_str(), &bind_opts,
    106                        interface_id, reinterpret_cast<void**>(interface_ptr));
    107   }
    108 
    109   return CoCreateInstance(class_id, NULL, CLSCTX_LOCAL_SERVER,
    110                           interface_id,
    111                           reinterpret_cast<void**>(interface_ptr));
    112 }
    113 
    114 
    115 }  // namespace
    116 
    117 // The GoogleUpdateJobObserver COM class is responsible for receiving status
    118 // reports from google Update. It keeps track of the progress as GoogleUpdate
    119 // notifies this observer and ends the message loop that is spinning in once
    120 // GoogleUpdate reports that it is done.
    121 class GoogleUpdateJobObserver
    122   : public CComObjectRootEx<CComSingleThreadModel>,
    123     public IJobObserver {
    124  public:
    125   BEGIN_COM_MAP(GoogleUpdateJobObserver)
    126     COM_INTERFACE_ENTRY(IJobObserver)
    127   END_COM_MAP()
    128 
    129   GoogleUpdateJobObserver()
    130     : result_(UPGRADE_ERROR) {
    131   }
    132   virtual ~GoogleUpdateJobObserver() {}
    133 
    134   // Notifications from Google Update:
    135   STDMETHOD(OnShow)() {
    136     return S_OK;
    137   }
    138   STDMETHOD(OnCheckingForUpdate)() {
    139     result_ = UPGRADE_CHECK_STARTED;
    140     return S_OK;
    141   }
    142   STDMETHOD(OnUpdateAvailable)(const TCHAR* version_string) {
    143     result_ = UPGRADE_IS_AVAILABLE;
    144     new_version_ = version_string;
    145     return S_OK;
    146   }
    147   STDMETHOD(OnWaitingToDownload)() {
    148     return S_OK;
    149   }
    150   STDMETHOD(OnDownloading)(int time_remaining_ms, int pos) {
    151     return S_OK;
    152   }
    153   STDMETHOD(OnWaitingToInstall)() {
    154     return S_OK;
    155   }
    156   STDMETHOD(OnInstalling)() {
    157     result_ = UPGRADE_STARTED;
    158     return S_OK;
    159   }
    160   STDMETHOD(OnPause)() {
    161     return S_OK;
    162   }
    163   STDMETHOD(OnComplete)(LegacyCompletionCodes code, const TCHAR* text) {
    164     switch (code) {
    165       case COMPLETION_CODE_SUCCESS_CLOSE_UI:
    166       case COMPLETION_CODE_SUCCESS: {
    167         if (result_ == UPGRADE_STARTED)
    168           result_ = UPGRADE_SUCCESSFUL;
    169         else if (result_ == UPGRADE_CHECK_STARTED)
    170           result_ = UPGRADE_ALREADY_UP_TO_DATE;
    171         break;
    172       }
    173       case COMPLETION_CODE_ERROR:
    174         error_message_ = text;
    175       default: {
    176         NOTREACHED();
    177         result_ = UPGRADE_ERROR;
    178         break;
    179       }
    180     }
    181 
    182     event_sink_ = NULL;
    183 
    184     // No longer need to spin the message loop that started spinning in
    185     // InitiateGoogleUpdateCheck.
    186     base::MessageLoop::current()->Quit();
    187     return S_OK;
    188   }
    189   STDMETHOD(SetEventSink)(IProgressWndEvents* event_sink) {
    190     event_sink_ = event_sink;
    191     return S_OK;
    192   }
    193 
    194   // Returns the results of the update operation.
    195   STDMETHOD(GetResult)(GoogleUpdateUpgradeResult* result) {
    196     // Intermediary steps should never be reported to the client.
    197     DCHECK(result_ != UPGRADE_STARTED && result_ != UPGRADE_CHECK_STARTED);
    198 
    199     *result = result_;
    200     return S_OK;
    201   }
    202 
    203   // Returns which version Google Update found on the server (if a more
    204   // recent version was found). Otherwise, this will be blank.
    205   STDMETHOD(GetVersionInfo)(base::string16* version_string) {
    206     *version_string = new_version_;
    207     return S_OK;
    208   }
    209 
    210   // Returns the Google Update supplied error string that describes the error
    211   // that occurred during the update check/upgrade.
    212   STDMETHOD(GetErrorMessage)(base::string16* error_message) {
    213     *error_message = error_message_;
    214     return S_OK;
    215   }
    216 
    217  private:
    218   // The status/result of the Google Update operation.
    219   GoogleUpdateUpgradeResult result_;
    220 
    221   // The version string Google Update found.
    222   base::string16 new_version_;
    223 
    224   // An error message, if any.
    225   base::string16 error_message_;
    226 
    227   // Allows us control the upgrade process to a small degree. After OnComplete
    228   // has been called, this object can not be used.
    229   base::win::ScopedComPtr<IProgressWndEvents> event_sink_;
    230 };
    231 
    232 ////////////////////////////////////////////////////////////////////////////////
    233 // GoogleUpdate, public:
    234 
    235 GoogleUpdate::GoogleUpdate()
    236     : listener_(NULL) {
    237 }
    238 
    239 GoogleUpdate::~GoogleUpdate() {
    240 }
    241 
    242 void GoogleUpdate::CheckForUpdate(bool install_if_newer, HWND window) {
    243   // Need to shunt this request over to InitiateGoogleUpdateCheck and have
    244   // it run in the file thread.
    245   BrowserThread::PostTask(
    246       BrowserThread::FILE, FROM_HERE,
    247       base::Bind(&GoogleUpdate::InitiateGoogleUpdateCheck, this,
    248                  install_if_newer, window, base::MessageLoop::current()));
    249 }
    250 
    251 ////////////////////////////////////////////////////////////////////////////////
    252 // GoogleUpdate, private:
    253 
    254 void GoogleUpdate::InitiateGoogleUpdateCheck(bool install_if_newer,
    255                                              HWND window,
    256                                              base::MessageLoop* main_loop) {
    257   base::FilePath chrome_exe;
    258   if (!PathService::Get(base::DIR_EXE, &chrome_exe))
    259     NOTREACHED();
    260 
    261   GoogleUpdateErrorCode error_code = CanUpdateCurrentChrome(chrome_exe);
    262   if (error_code != GOOGLE_UPDATE_NO_ERROR) {
    263     main_loop->PostTask(
    264         FROM_HERE,
    265         base::Bind(&GoogleUpdate::ReportResults, this,
    266                    UPGRADE_ERROR, error_code, base::string16()));
    267     return;
    268   }
    269 
    270   // Make sure ATL is initialized in this module.
    271   ui::win::CreateATLModuleIfNeeded();
    272 
    273   CComObject<GoogleUpdateJobObserver>* job_observer;
    274   HRESULT hr =
    275       CComObject<GoogleUpdateJobObserver>::CreateInstance(&job_observer);
    276   if (hr != S_OK) {
    277     // Most of the error messages come straight from Google Update. This one is
    278     // deemed worthy enough to also warrant its own error.
    279     GoogleUpdateErrorCode error = GOOGLE_UPDATE_JOB_SERVER_CREATION_FAILED;
    280     base::string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
    281     ReportFailure(
    282         hr, error,
    283         l10n_util::GetStringFUTF16(IDS_ABOUT_BOX_ERROR_UPDATE_CHECK_FAILED,
    284                                    error_code),
    285         main_loop);
    286     return;
    287   }
    288 
    289   base::win::ScopedComPtr<IJobObserver> job_holder(job_observer);
    290 
    291   base::win::ScopedComPtr<IGoogleUpdate> on_demand;
    292 
    293   bool system_level = false;
    294 
    295   if (InstallUtil::IsPerUserInstall(chrome_exe.value().c_str())) {
    296     hr = on_demand.CreateInstance(CLSID_OnDemandUserAppsClass);
    297   } else {
    298     // The Update operation needs Admin privileges for writing
    299     // to %ProgramFiles%. On Vista, need to elevate before instantiating
    300     // the updater instance.
    301     if (!install_if_newer) {
    302       hr = on_demand.CreateInstance(CLSID_OnDemandMachineAppsClass);
    303     } else {
    304       hr = CoCreateInstanceAsAdmin(CLSID_OnDemandMachineAppsClass,
    305           IID_IGoogleUpdate, window,
    306           reinterpret_cast<void**>(on_demand.Receive()));
    307     }
    308     system_level = true;
    309   }
    310 
    311   if (hr != S_OK) {
    312     GoogleUpdateErrorCode error = GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND;
    313     base::string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
    314     if (system_level)
    315       error_code += L" -- system level";
    316     ReportFailure(hr, error,
    317                   l10n_util::GetStringFUTF16(
    318                       IDS_ABOUT_BOX_ERROR_UPDATE_CHECK_FAILED,
    319                       error_code),
    320                   main_loop);
    321     return;
    322   }
    323 
    324   base::string16 app_guid = installer::GetAppGuidForUpdates(system_level);
    325   DCHECK(!app_guid.empty());
    326 
    327   if (!install_if_newer)
    328     hr = on_demand->CheckForUpdate(app_guid.c_str(), job_observer);
    329   else
    330     hr = on_demand->Update(app_guid.c_str(), job_observer);
    331 
    332   if (hr != S_OK) {
    333     GoogleUpdateErrorCode error = GOOGLE_UPDATE_ONDEMAND_CLASS_REPORTED_ERROR;
    334     base::string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
    335     ReportFailure(hr, error,
    336                   l10n_util::GetStringFUTF16(
    337                       IDS_ABOUT_BOX_ERROR_UPDATE_CHECK_FAILED,
    338                       error_code),
    339                   main_loop);
    340     return;
    341   }
    342 
    343   // Need to spin the message loop while Google Update is running so that it
    344   // can report back to us through GoogleUpdateJobObserver. This message loop
    345   // will terminate once Google Update sends us the completion status
    346   // (success/error). See OnComplete().
    347   base::MessageLoop::current()->Run();
    348 
    349   GoogleUpdateUpgradeResult results;
    350   hr = job_observer->GetResult(&results);
    351 
    352   if (hr != S_OK) {
    353     GoogleUpdateErrorCode error = GOOGLE_UPDATE_GET_RESULT_CALL_FAILED;
    354     base::string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
    355     ReportFailure(hr, error,
    356                   l10n_util::GetStringFUTF16(
    357                       IDS_ABOUT_BOX_ERROR_UPDATE_CHECK_FAILED,
    358                       error_code),
    359                   main_loop);
    360     return;
    361   }
    362 
    363   if (results == UPGRADE_ERROR) {
    364     base::string16 error_message;
    365     job_observer->GetErrorMessage(&error_message);
    366     ReportFailure(hr, GOOGLE_UPDATE_ERROR_UPDATING, error_message, main_loop);
    367     return;
    368   }
    369 
    370   hr = job_observer->GetVersionInfo(&version_available_);
    371   if (hr != S_OK) {
    372     GoogleUpdateErrorCode error = GOOGLE_UPDATE_GET_VERSION_INFO_FAILED;
    373     base::string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
    374     ReportFailure(hr, error,
    375                   l10n_util::GetStringFUTF16(
    376                       IDS_ABOUT_BOX_ERROR_UPDATE_CHECK_FAILED,
    377                       error_code),
    378                   main_loop);
    379     return;
    380   }
    381 
    382   main_loop->PostTask(
    383       FROM_HERE,
    384       base::Bind(&GoogleUpdate::ReportResults, this,
    385                  results, GOOGLE_UPDATE_NO_ERROR, base::string16()));
    386   job_holder = NULL;
    387   on_demand = NULL;
    388 }
    389 
    390 void GoogleUpdate::ReportResults(GoogleUpdateUpgradeResult results,
    391                                  GoogleUpdateErrorCode error_code,
    392                                  const base::string16& error_message) {
    393   // If there is an error, then error code must not be blank, and vice versa.
    394   DCHECK(results == UPGRADE_ERROR ? error_code != GOOGLE_UPDATE_NO_ERROR :
    395                                     error_code == GOOGLE_UPDATE_NO_ERROR);
    396   UMA_HISTOGRAM_ENUMERATION(
    397       "GoogleUpdate.UpgradeResult", results, NUM_UPGRADE_RESULTS);
    398   if (results == UPGRADE_ERROR) {
    399     UMA_HISTOGRAM_ENUMERATION(
    400         "GoogleUpdate.UpdateErrorCode", error_code, NUM_ERROR_CODES);
    401   }
    402   if (listener_) {
    403     listener_->OnReportResults(
    404         results, error_code, error_message, version_available_);
    405   }
    406 }
    407 
    408 bool GoogleUpdate::ReportFailure(HRESULT hr,
    409                                  GoogleUpdateErrorCode error_code,
    410                                  const base::string16& error_message,
    411                                  base::MessageLoop* main_loop) {
    412   DLOG(ERROR) << "Communication with Google Update failed: " << hr
    413               << " error: " << error_code
    414               << ", message: " << error_message.c_str();
    415   UMA_HISTOGRAM_SPARSE_SLOWLY("GoogleUpdate.ErrorHresult", hr);
    416   main_loop->PostTask(
    417       FROM_HERE,
    418       base::Bind(&GoogleUpdate::ReportResults, this,
    419                  UPGRADE_ERROR, error_code, error_message));
    420   return false;
    421 }
    422