Fifth patch in getting rid of caching MessageLoop pointers.

chrome/browser/views/shell_dialogs_win.cc

 // Copyright (c) 2006-2008 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/shell_dialogs.h"
 
 #include <windows.h>
 #include <commdlg.h>
 #include <shlobj.h>
 
 #include <algorithm>
 #include <set>
 
 #include "app/gfx/font.h"
 #include "app/l10n_util.h"
 #include "app/win_util.h"
 #include "base/file_util.h"
 #include "base/registry.h"
 #include "base/scoped_comptr_win.h"
 #include "base/string_util.h"
 #include "base/thread.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_thread.h"
 #include "grit/generated_resources.h"
 
 // Helpers to show certain types of Windows shell dialogs in a way that doesn't
 // block the UI of the entire app.
 
 class ShellDialogThread : public base::Thread {
  public:
   ShellDialogThread() : base::Thread("Chrome_ShellDialogThread") { }
 
  protected:
@@ skipping 50 matching lines @@
   // Disables the window |owner|. Can be run from either the ui or the dialog
   // thread. Can be called on either the UI or the dialog thread. This function
   // is called on the dialog thread after the modal Windows Common dialog
   // functions return because Windows automatically re-enables the owning
   // window when those functions return, but we don't actually want them to be
   // re-enabled until the response of the dialog propagates back to the UI
   // thread, so we disable the owner manually after the Common dialog function
   // returns.
   void DisableOwner(HWND owner);
 
-  // The UI thread's message loop.
-  MessageLoop* ui_loop_;
-
  private:
   // Creates a thread to run a shell dialog on. Each dialog requires its own
   // thread otherwise in some situations where a singleton owns a single
   // instance of this object we can have a situation where a modal dialog in
   // one window blocks the appearance of a modal dialog in another.
   static base::Thread* CreateDialogThread();
 
   // Enables the window |owner_|. Can only be run from the ui thread.
   void EnableOwner(HWND owner);
 
@@ skipping 13 matching lines @@
   static Owners owners_;
   static int instance_count_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseShellDialogImpl);
 };
 
 // static
 BaseShellDialogImpl::Owners BaseShellDialogImpl::owners_;
 int BaseShellDialogImpl::instance_count_ = 0;
 
-BaseShellDialogImpl::BaseShellDialogImpl()
-    : ui_loop_(MessageLoop::current()) {
+BaseShellDialogImpl::BaseShellDialogImpl() {
   ++instance_count_;
 }
 
 BaseShellDialogImpl::~BaseShellDialogImpl() {
   // All runs should be complete by the time this is called!
   if (--instance_count_ == 0)
     DCHECK(owners_.empty());
 }
 
 BaseShellDialogImpl::RunState BaseShellDialogImpl::BeginRun(HWND owner) {
@@ skipping 224 matching lines @@
       path = FilePath::FromWStringHack(path_as_wstring);
     }
     DisableOwner(params.run_state.owner);
   } else if (params.type == SELECT_OPEN_FILE) {
     success = RunOpenFileDialog(params.title, filter,
                                 params.run_state.owner, &path);
   } else if (params.type == SELECT_OPEN_MULTI_FILE) {
     std::vector<FilePath> paths;
     if (RunOpenMultiFileDialog(params.title, filter,
                                params.run_state.owner, &paths)) {
-      ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-          &SelectFileDialogImpl::MultiFilesSelected,
-          paths, params.params, params.run_state));
+      ChromeThread::PostTask(
+          ChromeThread::UI, FROM_HERE,
+          NewRunnableMethod(
+              this, &SelectFileDialogImpl::MultiFilesSelected, paths,
+              params.params, params.run_state));
       return;
     }
   }
 
   if (success) {
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFileDialogImpl::FileSelected, path, filter_index,
-        params.params, params.run_state));
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this, &SelectFileDialogImpl::FileSelected, path, filter_index,
+            params.params, params.run_state));
   } else {
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFileDialogImpl::FileNotSelected, params.params,
-        params.run_state));
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this, &SelectFileDialogImpl::FileNotSelected, params.params,
+            params.run_state));
   }
 }
 
 void SelectFileDialogImpl::FileSelected(const FilePath& selected_folder,
                                         int index,
                                         void* params,
                                         RunState run_state) {
   if (listener_)
     listener_->FileSelected(selected_folder, index, params);
   EndRun(run_state);
@@ skipping 250 matching lines @@
 void SelectFontDialogImpl::ExecuteSelectFont(RunState run_state, void* params) {
   LOGFONT logfont;
   CHOOSEFONT cf;
   cf.lStructSize = sizeof(cf);
   cf.hwndOwner = run_state.owner;
   cf.lpLogFont = &logfont;
   cf.Flags = CF_SCREENFONTS;
   bool success = !!ChooseFont(&cf);
   DisableOwner(run_state.owner);
   if (success) {
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFontDialogImpl::FontSelected, logfont, params, run_state));
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this, &SelectFontDialogImpl::FontSelected, logfont, params,
+            run_state));
   } else {
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFontDialogImpl::FontNotSelected, params, run_state));
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this, &SelectFontDialogImpl::FontNotSelected, params, run_state));
   }
 }
 
 void SelectFontDialogImpl::ExecuteSelectFontWithNameSize(
     RunState run_state, void* params, const std::wstring& font_name,
     int font_size) {
   // Create the HFONT from font name and size.
   HDC hdc = GetDC(NULL);
   long lf_height = -MulDiv(font_size, GetDeviceCaps(hdc, LOGPIXELSY), 72);
   ReleaseDC(NULL, hdc);
@@ skipping 33 matching lines @@
       CF_NOVERTFONTS | CF_SCRIPTSONLY | CF_LIMITSIZE;
 
   // These limits are arbitrary and needs to be revisited. Is it bad
   // to clamp the size at 40 from A11Y point of view?
   cf.nSizeMin = 8;
   cf.nSizeMax = 40;
 
   bool success = !!ChooseFont(&cf);
   DisableOwner(run_state.owner);
   if (success) {
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFontDialogImpl::FontSelected, logfont, params, run_state));
+    ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this, &SelectFontDialogImpl::FontSelected, logfont, params,
+          run_state));
   } else {
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFontDialogImpl::FontNotSelected, params, run_state));
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &SelectFontDialogImpl::FontNotSelected, params,
+        run_state));
   }
 }
 
 void SelectFontDialogImpl::FontSelected(LOGFONT logfont,
                                         void* params,
                                         RunState run_state) {
   if (listener_) {
     HFONT font = CreateFontIndirect(&logfont);
     if (font) {
       listener_->FontSelected(gfx::Font::CreateFont(font), params);
       DeleteObject(font);
     } else {
       listener_->FontSelectionCanceled(params);
     }
   }
   EndRun(run_state);
 }
 
 void SelectFontDialogImpl::FontNotSelected(void* params, RunState run_state) {
   if (listener_)
     listener_->FontSelectionCanceled(params);
   EndRun(run_state);
 }
 
 // static
 SelectFontDialog* SelectFontDialog::Create(Listener* listener) {
   return new SelectFontDialogImpl(listener);
 }