Rename RootWindowHost to WindowTreeHost

ui/aura/root_window_host_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 "ui/aura/root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
@@ skipping 11 matching lines @@
 using std::min;
 
 namespace aura {
 namespace {
 
 bool use_popup_as_root_window_for_test = false;
 
 }  // namespace
 
 // static
-RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
-  return new RootWindowHostWin(bounds);
+WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
+  return new WindowTreeHostWin(bounds);
 }
 
 // static
-gfx::Size RootWindowHost::GetNativeScreenSize() {
+gfx::Size WindowTreeHost::GetNativeScreenSize() {
   return gfx::Size(GetSystemMetrics(SM_CXSCREEN),
                    GetSystemMetrics(SM_CYSCREEN));
 }
 
-RootWindowHostWin::RootWindowHostWin(const gfx::Rect& bounds)
+WindowTreeHostWin::WindowTreeHostWin(const gfx::Rect& bounds)
     : fullscreen_(false),
       has_capture_(false),
       saved_window_style_(0),
       saved_window_ex_style_(0) {
   if (use_popup_as_root_window_for_test)
     set_window_style(WS_POPUP);
   Init(NULL, bounds);
   SetWindowText(hwnd(), L"aura::RootWindow!");
   CreateCompositor(GetAcceleratedWidget());
 }
 
-RootWindowHostWin::~RootWindowHostWin() {
+WindowTreeHostWin::~WindowTreeHostWin() {
   DestroyWindow(hwnd());
 }
 
-RootWindow* RootWindowHostWin::GetRootWindow() {
+RootWindow* WindowTreeHostWin::GetRootWindow() {
   return delegate_->AsRootWindow();
 }
 
-gfx::AcceleratedWidget RootWindowHostWin::GetAcceleratedWidget() {
+gfx::AcceleratedWidget WindowTreeHostWin::GetAcceleratedWidget() {
   return hwnd();
 }
 
-void RootWindowHostWin::Show() {
+void WindowTreeHostWin::Show() {
   ShowWindow(hwnd(), SW_SHOWNORMAL);
 }
 
-void RootWindowHostWin::Hide() {
+void WindowTreeHostWin::Hide() {
   NOTIMPLEMENTED();
 }
 
-void RootWindowHostWin::ToggleFullScreen() {
+void WindowTreeHostWin::ToggleFullScreen() {
   gfx::Rect target_rect;
   if (!fullscreen_) {
     fullscreen_ = true;
     saved_window_style_ = GetWindowLong(hwnd(), GWL_STYLE);
     saved_window_ex_style_ = GetWindowLong(hwnd(), GWL_EXSTYLE);
     GetWindowRect(hwnd(), &saved_window_rect_);
     SetWindowLong(hwnd(), GWL_STYLE,
                   saved_window_style_ & ~(WS_CAPTION | WS_THICKFRAME));
     SetWindowLong(hwnd(), GWL_EXSTYLE,
                   saved_window_ex_style_ & ~(WS_EX_DLGMODALFRAME |
@@ skipping 11 matching lines @@
   }
   SetWindowPos(hwnd(),
                NULL,
                target_rect.x(),
                target_rect.y(),
                target_rect.width(),
                target_rect.height(),
                SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
 }
 
-gfx::Rect RootWindowHostWin::GetBounds() const {
+gfx::Rect WindowTreeHostWin::GetBounds() const {
   RECT r;
   GetClientRect(hwnd(), &r);
   return gfx::Rect(r);
 }
 
-void RootWindowHostWin::SetBounds(const gfx::Rect& bounds) {
+void WindowTreeHostWin::SetBounds(const gfx::Rect& bounds) {
   if (fullscreen_) {
     saved_window_rect_.right = saved_window_rect_.left + bounds.width();
     saved_window_rect_.bottom = saved_window_rect_.top + bounds.height();
     return;
   }
   RECT window_rect;
   window_rect.left = bounds.x();
   window_rect.top = bounds.y();
   window_rect.right = bounds.right() ;
   window_rect.bottom = bounds.bottom();
@@ skipping 13 matching lines @@
   // Explicity call NotifyHostResized when the scale has changed because
   // the window size may not have changed.
   float current_scale = compositor()->device_scale_factor();
   float new_scale = gfx::Screen::GetScreenFor(
       delegate_->AsRootWindow()->window())->GetDisplayNearestWindow(
           delegate_->AsRootWindow()->window()).device_scale_factor();
   if (current_scale != new_scale)
     NotifyHostResized(bounds.size());
 }
 
-gfx::Insets RootWindowHostWin::GetInsets() const {
+gfx::Insets WindowTreeHostWin::GetInsets() const {
   return gfx::Insets();
 }
 
-void RootWindowHostWin::SetInsets(const gfx::Insets& insets) {
+void WindowTreeHostWin::SetInsets(const gfx::Insets& insets) {
 }
 
-gfx::Point RootWindowHostWin::GetLocationOnNativeScreen() const {
+gfx::Point WindowTreeHostWin::GetLocationOnNativeScreen() const {
   RECT r;
   GetClientRect(hwnd(), &r);
   return gfx::Point(r.left, r.top);
 }
 
 
-void RootWindowHostWin::SetCursor(gfx::NativeCursor native_cursor) {
+void WindowTreeHostWin::SetCursor(gfx::NativeCursor native_cursor) {
   // Custom web cursors are handled directly.
   if (native_cursor == ui::kCursorCustom)
     return;
 
   ui::CursorLoaderWin cursor_loader;
   cursor_loader.SetPlatformCursor(&native_cursor);
   ::SetCursor(native_cursor.platform());
 }
 
-void RootWindowHostWin::SetCapture() {
+void WindowTreeHostWin::SetCapture() {
   if (!has_capture_) {
     has_capture_ = true;
     ::SetCapture(hwnd());
   }
 }
 
-void RootWindowHostWin::ReleaseCapture() {
+void WindowTreeHostWin::ReleaseCapture() {
   if (has_capture_) {
     has_capture_ = false;
     ::ReleaseCapture();
   }
 }
 
-bool RootWindowHostWin::QueryMouseLocation(gfx::Point* location_return) {
+bool WindowTreeHostWin::QueryMouseLocation(gfx::Point* location_return) {
   client::CursorClient* cursor_client =
       client::GetCursorClient(GetRootWindow()->window());
   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
     *location_return = gfx::Point(0, 0);
     return false;
   }
 
   POINT pt;
   GetCursorPos(&pt);
   ScreenToClient(hwnd(), &pt);
   const gfx::Size size = GetBounds().size();
   *location_return =
       gfx::Point(max(0, min(size.width(), static_cast<int>(pt.x))),
                  max(0, min(size.height(), static_cast<int>(pt.y))));
   return (pt.x >= 0 && static_cast<int>(pt.x) < size.width() &&
           pt.y >= 0 && static_cast<int>(pt.y) < size.height());
 }
 
-bool RootWindowHostWin::ConfineCursorToRootWindow() {
+bool WindowTreeHostWin::ConfineCursorToRootWindow() {
   RECT window_rect;
   GetWindowRect(hwnd(), &window_rect);
   return ClipCursor(&window_rect) != 0;
 }
 
-void RootWindowHostWin::UnConfineCursor() {
+void WindowTreeHostWin::UnConfineCursor() {
   ClipCursor(NULL);
 }
 
-void RootWindowHostWin::OnCursorVisibilityChanged(bool show) {
+void WindowTreeHostWin::OnCursorVisibilityChanged(bool show) {
   NOTIMPLEMENTED();
 }
 
-void RootWindowHostWin::MoveCursorTo(const gfx::Point& location) {
+void WindowTreeHostWin::MoveCursorTo(const gfx::Point& location) {
   // Deliberately not implemented.
 }
 
-void RootWindowHostWin::PostNativeEvent(const base::NativeEvent& native_event) {
+void WindowTreeHostWin::PostNativeEvent(const base::NativeEvent& native_event) {
   ::PostMessage(
       hwnd(), native_event.message, native_event.wParam, native_event.lParam);
 }
 
-void RootWindowHostWin::OnDeviceScaleFactorChanged(
+void WindowTreeHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   NOTIMPLEMENTED();
 }
 
-void RootWindowHostWin::PrepareForShutdown() {
+void WindowTreeHostWin::PrepareForShutdown() {
   NOTIMPLEMENTED();
 }
 
-void RootWindowHostWin::OnClose() {
+void WindowTreeHostWin::OnClose() {
   // TODO: this obviously shouldn't be here.
   base::MessageLoopForUI::current()->Quit();
 }
 
-LRESULT RootWindowHostWin::OnKeyEvent(UINT message,
+LRESULT WindowTreeHostWin::OnKeyEvent(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   MSG msg = { hwnd(), message, w_param, l_param };
   ui::KeyEvent keyev(msg, message == WM_CHAR);
   SetMsgHandled(delegate_->OnHostKeyEvent(&keyev));
   return 0;
 }
 
-LRESULT RootWindowHostWin::OnMouseRange(UINT message,
+LRESULT WindowTreeHostWin::OnMouseRange(UINT message,
                                         WPARAM w_param,
                                         LPARAM l_param) {
   MSG msg = { hwnd(), message, w_param, l_param, 0,
               { GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param) } };
   ui::MouseEvent event(msg);
   bool handled = false;
   if (!(event.flags() & ui::EF_IS_NON_CLIENT))
     handled = delegate_->OnHostMouseEvent(&event);
   SetMsgHandled(handled);
   return 0;
 }
 
-LRESULT RootWindowHostWin::OnCaptureChanged(UINT message,
+LRESULT WindowTreeHostWin::OnCaptureChanged(UINT message,
                                             WPARAM w_param,
                                             LPARAM l_param) {
   if (has_capture_) {
     has_capture_ = false;
     delegate_->OnHostLostWindowCapture();
   }
   return 0;
 }
 
-LRESULT RootWindowHostWin::OnNCActivate(UINT message,
+LRESULT WindowTreeHostWin::OnNCActivate(UINT message,
                                         WPARAM w_param,
                                         LPARAM l_param) {
   if (!!w_param)
     delegate_->OnHostActivated();
   return DefWindowProc(hwnd(), message, w_param, l_param);
 }
 
-void RootWindowHostWin::OnMove(const CPoint& point) {
+void WindowTreeHostWin::OnMove(const CPoint& point) {
   if (delegate_)
     delegate_->OnHostMoved(gfx::Point(point.x, point.y));
 }
 
-void RootWindowHostWin::OnPaint(HDC dc) {
+void WindowTreeHostWin::OnPaint(HDC dc) {
   gfx::Rect damage_rect;
   RECT update_rect = {0};
   if (GetUpdateRect(hwnd(), &update_rect, FALSE))
     damage_rect = gfx::Rect(update_rect);
   compositor()->ScheduleRedrawRect(damage_rect);
   ValidateRect(hwnd(), NULL);
 }
 
-void RootWindowHostWin::OnSize(UINT param, const CSize& size) {
+void WindowTreeHostWin::OnSize(UINT param, const CSize& size) {
   // Minimizing resizes the window to 0x0 which causes our layout to go all
   // screwy, so we just ignore it.
   if (delegate_ && param != SIZE_MINIMIZED)
     NotifyHostResized(gfx::Size(size.cx, size.cy));
 }
 
 namespace test {
 
 // static
 void SetUsePopupAsRootWindowForTest(bool use) {
   use_popup_as_root_window_for_test = use;
 }
 
 }  // namespace test
 
 }  // namespace aura