Switch about box to web ui on Windows.

chrome/browser/google/google_update_win.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/google/google_update.h"
+#include "chrome/browser/google/google_update_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 54 matching lines @@
 // Creates an instance of a COM Local Server class using either plain vanilla
 // CoCreateInstance, or using the Elevation moniker if running on Vista.
 // hwnd must refer to a foregound window in order to get the UAC prompt
 // showing up in the foreground if running on Vista. It can also be NULL if
 // background UAC prompts are desired.
 HRESULT CoCreateInstanceAsAdmin(REFCLSID class_id, REFIID interface_id,
                                 HWND hwnd, void** interface_ptr) {
   if (!interface_ptr)
     return E_POINTER;
 
-  // For Vista we need to instantiate the COM server via the elevation
+  // For Vista, need to instantiate the COM server via the elevation
   // moniker. This ensures that the UAC dialog shows up.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     wchar_t class_id_as_string[MAX_PATH] = {0};
     StringFromGUID2(class_id, class_id_as_string,
                     arraysize(class_id_as_string));
 
     string16 elevation_moniker_name =
         base::StringPrintf(L"Elevation:Administrator!new:%ls",
                            class_id_as_string);
 
     BIND_OPTS3 bind_opts;
     memset(&bind_opts, 0, sizeof(bind_opts));
     bind_opts.cbStruct = sizeof(bind_opts);
     bind_opts.dwClassContext = CLSCTX_LOCAL_SERVER;
     bind_opts.hwnd = hwnd;
 
     return CoGetObject(elevation_moniker_name.c_str(), &bind_opts,
                        interface_id, reinterpret_cast<void**>(interface_ptr));
   }
 
   return CoCreateInstance(class_id, NULL, CLSCTX_LOCAL_SERVER,
                           interface_id,
                           reinterpret_cast<void**>(interface_ptr));
 }
 
 
 }  // namespace
 
-////////////////////////////////////////////////////////////////////////////////
-//
 // The GoogleUpdateJobObserver COM class is responsible for receiving status
-// reports from google Update. It keeps track of the progress as Google Update
-// notifies us and ends the message loop we are spinning in once Google Update
-// reports that it is done.
-//
-////////////////////////////////////////////////////////////////////////////////
+// reports from google Update. It keeps track of the progress as GoogleUpdate
+// notifies this observer and ends the message loop that is spinning in once
+// GoogleUpdate reports that it is done.
 class GoogleUpdateJobObserver
   : public CComObjectRootEx<CComSingleThreadModel>,
     public IJobObserver {
  public:
   BEGIN_COM_MAP(GoogleUpdateJobObserver)
     COM_INTERFACE_ENTRY(IJobObserver)
   END_COM_MAP()
 
   GoogleUpdateJobObserver()
     : result_(UPGRADE_ERROR) {
@@ skipping 43 matching lines @@
         error_message_ = text;
       default: {
         NOTREACHED();
         result_ = UPGRADE_ERROR;
         break;
       }
     }
 
     event_sink_ = NULL;
 
-    // We no longer need to spin the message loop that we started spinning in
+    // No longer need to spin the message loop that started spinning in
     // InitiateGoogleUpdateCheck.
     MessageLoop::current()->Quit();
     return S_OK;
   }
   STDMETHOD(SetEventSink)(IProgressWndEvents* event_sink) {
     event_sink_ = event_sink;
     return S_OK;
   }
 
   // Returns the results of the update operation.
@@ skipping 37 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // GoogleUpdate, public:
 
 GoogleUpdate::GoogleUpdate()
     : listener_(NULL) {
 }
 
 GoogleUpdate::~GoogleUpdate() {
 }
 
-void GoogleUpdate::CheckForUpdate(bool install_if_newer,
-                                  views::Widget* window) {
-  // We need to shunt this request over to InitiateGoogleUpdateCheck and have
+void GoogleUpdate::CheckForUpdate(bool install_if_newer, HWND window) {
+  // Need to shunt this request over to InitiateGoogleUpdateCheck and have
   // it run in the file thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&GoogleUpdate::InitiateGoogleUpdateCheck, this,
                  install_if_newer, window, MessageLoop::current()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GoogleUpdate, private:
 
 void GoogleUpdate::InitiateGoogleUpdateCheck(bool install_if_newer,
-                                             views::Widget* window,
+                                             HWND window,
                                              MessageLoop* main_loop) {
   FilePath chrome_exe;
   if (!PathService::Get(base::DIR_EXE, &chrome_exe))
     NOTREACHED();
 
   GoogleUpdateErrorCode error_code = CanUpdateCurrentChrome(chrome_exe);
   if (error_code != GOOGLE_UPDATE_NO_ERROR) {
     main_loop->PostTask(
         FROM_HERE,
         base::Bind(&GoogleUpdate::ReportResults, this,
@@ skipping 20 matching lines @@
   base::win::ScopedComPtr<IJobObserver> job_holder(job_observer);
 
   base::win::ScopedComPtr<IGoogleUpdate> on_demand;
 
   bool system_level = false;
 
   if (InstallUtil::IsPerUserInstall(chrome_exe.value().c_str())) {
     hr = on_demand.CreateInstance(CLSID_OnDemandUserAppsClass);
   } else {
     // The Update operation needs Admin privileges for writing
-    // to %ProgramFiles%. On Vista we need to elevate before instantiating
+    // to %ProgramFiles%. On Vista, need to elevate before instantiating
     // the updater instance.
     if (!install_if_newer) {
       hr = on_demand.CreateInstance(CLSID_OnDemandMachineAppsClass);
     } else {
-      HWND foreground_hwnd = NULL;
-      if (window != NULL) {
-        foreground_hwnd = window->GetNativeWindow();
-      }
-
       hr = CoCreateInstanceAsAdmin(CLSID_OnDemandMachineAppsClass,
-          IID_IGoogleUpdate, foreground_hwnd,
+          IID_IGoogleUpdate, window,
           reinterpret_cast<void**>(on_demand.Receive()));
     }
     system_level = true;
   }
 
   if (hr != S_OK) {
     GoogleUpdateErrorCode error = GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND;
     string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
     if (system_level)
       error_code += L" -- system level";
@@ skipping 17 matching lines @@
     GoogleUpdateErrorCode error = GOOGLE_UPDATE_ONDEMAND_CLASS_REPORTED_ERROR;
     string16 error_code = base::StringPrintf(L"%d: 0x%x", error, hr);
     ReportFailure(hr, error,
                   l10n_util::GetStringFUTF16(
                       IDS_ABOUT_BOX_ERROR_UPDATE_CHECK_FAILED,
                       error_code),
                   main_loop);
     return;
   }
 
-  // We need to spin the message loop while Google Update is running so that it
+  // Need to spin the message loop while Google Update is running so that it
   // can report back to us through GoogleUpdateJobObserver. This message loop
   // will terminate once Google Update sends us the completion status
   // (success/error). See OnComplete().
   MessageLoop::current()->Run();
 
   GoogleUpdateUpgradeResult results;
   hr = job_observer->GetResult(&results);
 
   if (hr != S_OK) {
     GoogleUpdateErrorCode error = GOOGLE_UPDATE_GET_RESULT_CALL_FAILED;
@@ skipping 29 matching lines @@
       FROM_HERE,
       base::Bind(&GoogleUpdate::ReportResults, this,
                  results, GOOGLE_UPDATE_NO_ERROR, string16()));
   job_holder = NULL;
   on_demand = NULL;
 }
 
 void GoogleUpdate::ReportResults(GoogleUpdateUpgradeResult results,
                                  GoogleUpdateErrorCode error_code,
                                  const string16& error_message) {
-  // If we get an error, then error code must not be blank, and vice versa.
+  // If there is an error, then error code must not be blank, and vice versa.
   DCHECK(results == UPGRADE_ERROR ? error_code != GOOGLE_UPDATE_NO_ERROR :
                                     error_code == GOOGLE_UPDATE_NO_ERROR);
   if (listener_) {
     listener_->OnReportResults(
         results, error_code, error_message, version_available_);
   }
 }
 
 bool GoogleUpdate::ReportFailure(HRESULT hr,
                                  GoogleUpdateErrorCode error_code,
                                  const string16& error_message,
                                  MessageLoop* main_loop) {
   NOTREACHED() << "Communication with Google Update failed: " << hr
                << " error: " << error_code
                << ", message: " << error_message.c_str();
   main_loop->PostTask(
       FROM_HERE,
       base::Bind(&GoogleUpdate::ReportResults, this,
                  UPGRADE_ERROR, error_code, error_message));
   return false;
 }