Move a bunch of windows stuff from ui/base/win to ui/gfx/win

content/browser/renderer_host/render_widget_host_view_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 "content/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <InputScope.h>
 #include <wtsapi32.h>
 #pragma comment(lib, "wtsapi32.lib")
 
@@ skipping 49 matching lines @@
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/win/imm32_manager.h"
 #include "ui/base/ime/win/tsf_input_scope.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/touch/touch_device.h"
 #include "ui/base/touch/touch_enabled.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/view_prop.h"
-#include "ui/base/win/hwnd_util.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/base/win/touch_input.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/dpi_win.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/text_elider.h"
+#include "ui/gfx/win/dpi.h"
+#include "ui/gfx/win/hwnd_util.h"
 #include "webkit/common/cursors/webcursor.h"
 #include "win8/util/win8_util.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using ui::ViewProp;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebTextDirection;
 
@@ skipping 355 matching lines @@
   close_on_deactivate_ = true;
   DoPopupOrFullscreenInit(parent_host_view->GetNativeView(), pos,
                           WS_EX_TOOLWINDOW);
 }
 
 void RenderWidgetHostViewWin::InitAsFullscreen(
     RenderWidgetHostView* reference_host_view) {
   gfx::Rect pos = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
       reference_host_view->GetNativeView()).bounds();
   is_fullscreen_ = true;
-  DoPopupOrFullscreenInit(ui::GetWindowToParentTo(true), pos, 0);
+  DoPopupOrFullscreenInit(gfx::GetWindowToParentTo(true), pos, 0);
 }
 
 RenderWidgetHost* RenderWidgetHostViewWin::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewWin::WasShown() {
   if (!is_hidden_)
     return;
 
@@ skipping 103 matching lines @@
 static BOOL CALLBACK AddChildWindowToVector(HWND hwnd, LPARAM lparam) {
   std::vector<HWND>* vector = reinterpret_cast<std::vector<HWND>*>(lparam);
   vector->push_back(hwnd);
   return TRUE;
 }
 
 void RenderWidgetHostViewWin::CleanupCompositorWindow() {
   if (!compositor_host_window_)
     return;
 
-  ui::SetWindowUserData(compositor_host_window_, NULL);
+  gfx::SetWindowUserData(compositor_host_window_, NULL);
 
   // Hide the compositor and parent it to the desktop rather than destroying
   // it immediately. The GPU process has a grace period to stop accessing the
   // window. TODO(apatrick): the GPU process should acknowledge that it has
   // finished with the window handle and the browser process should destroy it
   // at that point.
   ::ShowWindow(compositor_host_window_, SW_HIDE);
   ::SetParent(compositor_host_window_, NULL);
 
   BrowserThread::PostDelayedTask(
@@ skipping 30 matching lines @@
   else
     return !!render_widget_host_->GetBackingStore(false);
 }
 
 void RenderWidgetHostViewWin::Show() {
   ShowWindow(SW_SHOW);
   WasShown();
 }
 
 void RenderWidgetHostViewWin::Hide() {
-  if (!is_fullscreen_ && GetParent() == ui::GetWindowToParentTo(true)) {
+  if (!is_fullscreen_ && GetParent() == gfx::GetWindowToParentTo(true)) {
     LOG(WARNING) << "Hide() called twice in a row: " << this << ":"
         << GetParent();
     return;
   }
 
   if (::GetFocus() == m_hWnd)
     ::SetFocus(NULL);
   ShowWindow(SW_HIDE);
 
   WasHidden();
@@ skipping 1671 matching lines @@
     // an event to the renderer which would then eventually send over
     // a setFocus call to the plugin widget. This would ensure that
     // the renderer (webkit) knows about the plugin widget receiving
     // focus.
     // TODO(iyengar) Do the right thing as per the above comment.
     POINT cursor_pos = {0};
     ::GetCursorPos(&cursor_pos);
     ::ScreenToClient(m_hWnd, &cursor_pos);
     HWND child_window = ::RealChildWindowFromPoint(m_hWnd, cursor_pos);
     if (::IsWindow(child_window) && child_window != m_hWnd) {
-      if (ui::GetClassName(child_window) == kWrapperNativeWindowClassName)
+      if (gfx::GetClassName(child_window) == kWrapperNativeWindowClassName)
         child_window = ::GetWindow(child_window, GW_CHILD);
 
       ::SetFocus(child_window);
       return MA_NOACTIVATE;
     }
   }
   handled = FALSE;
   render_widget_host_->OnPointerEventActivate();
   return MA_ACTIVATE;
 }
@@ skipping 125 matching lines @@
   // clear the BrowserAccessibilityManager, because the renderer is
   // dead and any accessibility information we have is now stale.
   SetBrowserAccessibilityManager(NULL);
 }
 
 static void PaintCompositorHostWindow(HWND hWnd) {
   PAINTSTRUCT paint;
   BeginPaint(hWnd, &paint);
 
   RenderWidgetHostViewWin* win = static_cast<RenderWidgetHostViewWin*>(
-      ui::GetWindowUserData(hWnd));
+      gfx::GetWindowUserData(hWnd));
   // Trigger composite to rerender window.
   if (win)
     win->AcceleratedPaint(paint.hdc);
 
   EndPaint(hWnd, &paint);
 }
 
 // WndProc for the compositor host window. We use this instead of Default so
 // we can drop WM_PAINT and WM_ERASEBKGD messages on the floor.
 static LRESULT CALLBACK CompositorHostWindowProc(HWND hWnd, UINT message,
@@ skipping 78 matching lines @@
   int width = std::max(1,
       static_cast<int>(currentRect.right - currentRect.left));
   int height = std::max(1,
       static_cast<int>(currentRect.bottom - currentRect.top));
 
   compositor_host_window_ = CreateWindowEx(
       WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
       MAKEINTATOM(atom), 0,
       WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_DISABLED,
       0, 0, width, height, m_hWnd, 0, instance, 0);
-  ui::CheckWindowCreated(compositor_host_window_);
+  gfx::CheckWindowCreated(compositor_host_window_);
 
-  ui::SetWindowUserData(compositor_host_window_, this);
+  gfx::SetWindowUserData(compositor_host_window_, this);
 
   gfx::GLSurfaceHandle surface_handle(compositor_host_window_,
                                       gfx::NATIVE_TRANSPORT);
   return surface_handle;
 }
 
 void RenderWidgetHostViewWin::OnAcceleratedCompositingStateChange() {
   bool show = render_widget_host_->is_accelerated_compositing_active();
   // When we first create the compositor, we will get a show request from
   // the renderer before we have gotten the create request from the GPU. In this
@@ skipping 620 matching lines @@
   return new RenderWidgetHostViewWin(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
       WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(0, results);
 }
 
 }  // namespace content