ui: Use base::MessageLoop.

ui/views/win/hwnd_message_handler.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 "ui/views/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/bind.h"
@@ skipping 420 matching lines @@
 
   // Modal dialog windows disable their owner windows; re-enable them now so
   // they can activate as foreground windows upon this window's destruction.
   RestoreEnabledIfNecessary();
 
   if (!close_widget_factory_.HasWeakPtrs()) {
     // And we delay the close so that if we are called from an ATL callback,
     // we don't destroy the window before the callback returned (as the caller
     // may delete ourselves on destroy and the ATL callback would still
     // dereference us when the callback returns).
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&HWNDMessageHandler::CloseNow,
                    close_widget_factory_.GetWeakPtr()));
   }
 }
 
 void HWNDMessageHandler::CloseNow() {
   // We may already have been destroyed if the selection resulted in a tab
   // switch which will have reactivated the browser window and closed us, so
   // we need to check to see if we're still a window before trying to destroy
@@ skipping 327 matching lines @@
     // We must update the back-buffer immediately, since Windows' handling of
     // invalid rects is somewhat mysterious.
     invalid_rect_.Union(rect);
 
     // In some situations, such as drag and drop, when Windows itself runs a
     // nested message loop our message loop appears to be starved and we don't
     // receive calls to DidProcessMessage(). This only seems to affect layered
     // windows, so we schedule a redraw manually using a task, since those never
     // seem to be starved. Also, wtf.
     if (!paint_layered_window_factory_.HasWeakPtrs()) {
-      MessageLoop::current()->PostTask(
+      base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&HWNDMessageHandler::RedrawLayeredWindowContents,
                      paint_layered_window_factory_.GetWeakPtr()));
     }
   } else {
     // InvalidateRect() expects client coordinates.
     RECT r = rect.ToRECT();
     InvalidateRect(hwnd(), &r, FALSE);
   }
 }
@@ skipping 63 matching lines @@
   if (!ProcessWindowMessage(window, message, w_param, l_param, result))
     result = DefWindowProc(window, message, w_param, l_param);
 
   // DefWindowProc() may have destroyed the window in a nested message loop.
   if (!::IsWindow(window))
     return result;
 
   if (delegate_)
     delegate_->PostHandleMSG(message, w_param, l_param);
   if (message == WM_NCDESTROY) {
-    MessageLoopForUI::current()->RemoveObserver(this);
+    base::MessageLoopForUI::current()->RemoveObserver(this);
     if (delegate_)
       delegate_->HandleDestroyed();
   }
 
   // Only top level widget should store/restore focus.
   if (message == WM_ACTIVATE && delegate_->CanSaveFocus())
     PostProcessActivateMessage(LOWORD(w_param));
   if (message == WM_ENABLE && restore_focus_when_enabled_) {
     // This path should be executed only for top level as
     // restore_focus_when_enabled_ is set in PostProcessActivateMessage.
@@ skipping 381 matching lines @@
 
   // We need to allow the delegate to size its contents since the window may not
   // receive a size notification when its initial bounds are specified at window
   // creation time.
   ClientAreaSizeChanged();
 
   // We need to add ourselves as a message loop observer so that we can repaint
   // aggressively if the contents of our window become invalid. Unfortunately
   // WM_PAINT messages are starved and we get flickery redrawing when resizing
   // if we do not do this.
-  MessageLoopForUI::current()->AddObserver(this);
+  base::MessageLoopForUI::current()->AddObserver(this);
 
   delegate_->HandleCreate();
 
   // TODO(beng): move more of NWW::OnCreate here.
   return 0;
 }
 
 void HWNDMessageHandler::OnDestroy() {
   delegate_->HandleDestroying();
 }
@@ skipping 785 matching lines @@
         // WARNING!  Don't set SWP_FRAMECHANGED here, it breaks moving the child
         // HWNDs for some reason.
         window_pos->flags &= ~(SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW);
         window_pos->flags |= SWP_NOCOPYBITS;
 
         // Now ignore all immediately-following SetWindowPos() changes.  Windows
         // likes to (incorrectly) recalculate what our position/size should be
         // and send us further updates.
         ignore_window_pos_changes_ = true;
         DCHECK(!ignore_pos_changes_factory_.HasWeakPtrs());
-        MessageLoop::current()->PostTask(
+        base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&HWNDMessageHandler::StopIgnoringPosChanges,
                        ignore_pos_changes_factory_.GetWeakPtr()));
       }
       last_monitor_ = monitor;
       last_monitor_rect_ = monitor_rect;
       last_work_area_ = work_area;
     }
   }
 
@@ skipping 15 matching lines @@
     DwmExtendFrameIntoClientArea(hwnd(), &m);
   }
   if (window_pos->flags & SWP_SHOWWINDOW)
     delegate_->HandleVisibilityChanged(true);
   else if (window_pos->flags & SWP_HIDEWINDOW)
     delegate_->HandleVisibilityChanged(false);
   SetMsgHandled(FALSE);
 }
 
 }  // namespace views