Revert 236048 "Rename RootWindowHost* to WindowTreeHost*"

trunk/src/ui/aura/remote_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/remote_root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/cursor/cursor_loader_win.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/view_prop.h"
 #include "ui/gfx/insets.h"
 #include "ui/metro_viewer/metro_viewer_messages.h"
 
 namespace aura {
 
 namespace {
 
-const char* kWindowTreeHostWinKey = "__AURA_REMOTE_ROOT_WINDOW_HOST_WIN__";
+const char* kRootWindowHostWinKey = "__AURA_REMOTE_ROOT_WINDOW_HOST_WIN__";
 
 // Sets the keystate for the virtual key passed in to down or up.
 void SetKeyState(uint8* key_states, bool key_down, uint32 virtual_key_code) {
   DCHECK(key_states);
 
   if (key_down)
     key_states[virtual_key_code] |= 0x80;
   else
     key_states[virtual_key_code] &= 0x7F;
 }
@@ skipping 16 matching lines @@
   ::SetKeyboardState(keyboard_state);
 }
 
 }  // namespace
 
 void HandleOpenFile(const base::string16& title,
                     const base::FilePath& default_path,
                     const base::string16& filter,
                     const OpenFileCompletion& on_success,
                     const FileSelectionCanceled& on_failure) {
-  DCHECK(aura::RemoteWindowTreeHostWin::Instance());
-  aura::RemoteWindowTreeHostWin::Instance()->HandleOpenFile(title,
+  DCHECK(aura::RemoteRootWindowHostWin::Instance());
+  aura::RemoteRootWindowHostWin::Instance()->HandleOpenFile(title,
                                                             default_path,
                                                             filter,
                                                             on_success,
                                                             on_failure);
 }
 
 void HandleOpenMultipleFiles(const base::string16& title,
                              const base::FilePath& default_path,
                              const base::string16& filter,
                              const OpenMultipleFilesCompletion& on_success,
                              const FileSelectionCanceled& on_failure) {
-  DCHECK(aura::RemoteWindowTreeHostWin::Instance());
-  aura::RemoteWindowTreeHostWin::Instance()->HandleOpenMultipleFiles(
+  DCHECK(aura::RemoteRootWindowHostWin::Instance());
+  aura::RemoteRootWindowHostWin::Instance()->HandleOpenMultipleFiles(
       title,
       default_path,
       filter,
       on_success,
       on_failure);
 }
 
 void HandleSaveFile(const base::string16& title,
                     const base::FilePath& default_path,
                     const base::string16& filter,
                     int filter_index,
                     const base::string16& default_extension,
                     const SaveFileCompletion& on_success,
                     const FileSelectionCanceled& on_failure) {
-  DCHECK(aura::RemoteWindowTreeHostWin::Instance());
-  aura::RemoteWindowTreeHostWin::Instance()->HandleSaveFile(title,
+  DCHECK(aura::RemoteRootWindowHostWin::Instance());
+  aura::RemoteRootWindowHostWin::Instance()->HandleSaveFile(title,
                                                             default_path,
                                                             filter,
                                                             filter_index,
                                                             default_extension,
                                                             on_success,
                                                             on_failure);
 }
 
 void HandleSelectFolder(const base::string16& title,
                         const SelectFolderCompletion& on_success,
                         const FileSelectionCanceled& on_failure) {
-  DCHECK(aura::RemoteWindowTreeHostWin::Instance());
-  aura::RemoteWindowTreeHostWin::Instance()->HandleSelectFolder(title,
+  DCHECK(aura::RemoteRootWindowHostWin::Instance());
+  aura::RemoteRootWindowHostWin::Instance()->HandleSelectFolder(title,
                                                                 on_success,
                                                                 on_failure);
 }
 
 void HandleActivateDesktop(const base::FilePath& shortcut,
                            const ActivateDesktopCompleted& on_success) {
-  DCHECK(aura::RemoteWindowTreeHostWin::Instance());
-  aura::RemoteWindowTreeHostWin::Instance()->HandleActivateDesktop(shortcut,
+  DCHECK(aura::RemoteRootWindowHostWin::Instance());
+  aura::RemoteRootWindowHostWin::Instance()->HandleActivateDesktop(shortcut,
                                                                    on_success);
 }
 
-RemoteWindowTreeHostWin* g_instance = NULL;
+RemoteRootWindowHostWin* g_instance = NULL;
 
-RemoteWindowTreeHostWin* RemoteWindowTreeHostWin::Instance() {
+RemoteRootWindowHostWin* RemoteRootWindowHostWin::Instance() {
   if (g_instance)
     return g_instance;
   return Create(gfx::Rect());
 }
 
-RemoteWindowTreeHostWin* RemoteWindowTreeHostWin::Create(
+RemoteRootWindowHostWin* RemoteRootWindowHostWin::Create(
     const gfx::Rect& bounds) {
-  g_instance = g_instance ? g_instance : new RemoteWindowTreeHostWin(bounds);
+  g_instance = g_instance ? g_instance : new RemoteRootWindowHostWin(bounds);
   return g_instance;
 }
 
-RemoteWindowTreeHostWin::RemoteWindowTreeHostWin(const gfx::Rect& bounds)
+RemoteRootWindowHostWin::RemoteRootWindowHostWin(const gfx::Rect& bounds)
     : remote_window_(NULL),
       host_(NULL),
       ignore_mouse_moves_until_set_cursor_ack_(false),
       event_flags_(0) {
-  prop_.reset(new ui::ViewProp(NULL, kWindowTreeHostWinKey, this));
+  prop_.reset(new ui::ViewProp(NULL, kRootWindowHostWinKey, this));
   CreateCompositor(GetAcceleratedWidget());
 }
 
-RemoteWindowTreeHostWin::~RemoteWindowTreeHostWin() {
+RemoteRootWindowHostWin::~RemoteRootWindowHostWin() {
   g_instance = NULL;
 }
 
-void RemoteWindowTreeHostWin::Connected(IPC::Sender* host, HWND remote_window) {
+void RemoteRootWindowHostWin::Connected(IPC::Sender* host, HWND remote_window) {
   CHECK(host_ == NULL);
   host_ = host;
   remote_window_ = remote_window;
 }
 
-void RemoteWindowTreeHostWin::Disconnected() {
+void RemoteRootWindowHostWin::Disconnected() {
   // Don't CHECK here, Disconnected is called on a channel error which can
   // happen before we're successfully Connected.
   host_ = NULL;
   remote_window_ = NULL;
 }
 
-bool RemoteWindowTreeHostWin::OnMessageReceived(const IPC::Message& message) {
+bool RemoteRootWindowHostWin::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(RemoteWindowTreeHostWin, message)
+  IPC_BEGIN_MESSAGE_MAP(RemoteRootWindowHostWin, message)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MouseMoved, OnMouseMoved)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MouseButton, OnMouseButton)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_KeyDown, OnKeyDown)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_KeyUp, OnKeyUp)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_Character, OnChar)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_WindowActivated,
                         OnWindowActivated)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchDown,
                         OnTouchDown)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchUp,
@@ skipping 12 matching lines @@
                         OnSetCursorPosAck)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_WindowSizeChanged,
                         OnWindowSizeChanged)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ActivateDesktopDone,
                         OnDesktopActivated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void RemoteWindowTreeHostWin::HandleOpenURLOnDesktop(
+void RemoteRootWindowHostWin::HandleOpenURLOnDesktop(
     const base::FilePath& shortcut,
     const base::string16& url) {
   if (!host_)
     return;
   host_->Send(new MetroViewerHostMsg_OpenURLOnDesktop(shortcut, url));
 }
 
-void RemoteWindowTreeHostWin::HandleActivateDesktop(
+void RemoteRootWindowHostWin::HandleActivateDesktop(
     const base::FilePath& shortcut,
     const ActivateDesktopCompleted& on_success) {
   if (!host_)
     return;
   DCHECK(activate_completed_callback_.is_null());
   activate_completed_callback_ = on_success;
   host_->Send(new MetroViewerHostMsg_ActivateDesktop(shortcut));
 }
 
-void RemoteWindowTreeHostWin::HandleOpenFile(
+void RemoteRootWindowHostWin::HandleOpenFile(
     const base::string16& title,
     const base::FilePath& default_path,
     const base::string16& filter,
     const OpenFileCompletion& on_success,
     const FileSelectionCanceled& on_failure) {
   if (!host_)
     return;
 
   // Can only have one of these operations in flight.
   DCHECK(file_open_completion_callback_.is_null());
   DCHECK(failure_callback_.is_null());
 
   file_open_completion_callback_ = on_success;
   failure_callback_ = on_failure;
 
   host_->Send(new MetroViewerHostMsg_DisplayFileOpen(title,
                                                      filter,
                                                      default_path,
                                                      false));
 }
 
-void RemoteWindowTreeHostWin::HandleOpenMultipleFiles(
+void RemoteRootWindowHostWin::HandleOpenMultipleFiles(
     const base::string16& title,
     const base::FilePath& default_path,
     const base::string16& filter,
     const OpenMultipleFilesCompletion& on_success,
     const FileSelectionCanceled& on_failure) {
   if (!host_)
     return;
 
   // Can only have one of these operations in flight.
   DCHECK(multi_file_open_completion_callback_.is_null());
   DCHECK(failure_callback_.is_null());
   multi_file_open_completion_callback_ = on_success;
   failure_callback_ = on_failure;
 
   host_->Send(new MetroViewerHostMsg_DisplayFileOpen(title,
                                                      filter,
                                                      default_path,
                                                      true));
 }
 
-void RemoteWindowTreeHostWin::HandleSaveFile(
+void RemoteRootWindowHostWin::HandleSaveFile(
     const base::string16& title,
     const base::FilePath& default_path,
     const base::string16& filter,
     int filter_index,
     const base::string16& default_extension,
     const SaveFileCompletion& on_success,
     const FileSelectionCanceled& on_failure) {
   if (!host_)
     return;
 
   MetroViewerHostMsg_SaveAsDialogParams params;
   params.title = title;
   params.default_extension = default_extension;
   params.filter = filter;
   params.filter_index = filter_index;
   params.suggested_name = default_path;
 
   // Can only have one of these operations in flight.
   DCHECK(file_saveas_completion_callback_.is_null());
   DCHECK(failure_callback_.is_null());
   file_saveas_completion_callback_ = on_success;
   failure_callback_ = on_failure;
 
   host_->Send(new MetroViewerHostMsg_DisplayFileSaveAs(params));
 }
 
-void RemoteWindowTreeHostWin::HandleSelectFolder(
+void RemoteRootWindowHostWin::HandleSelectFolder(
     const base::string16& title,
     const SelectFolderCompletion& on_success,
     const FileSelectionCanceled& on_failure) {
   if (!host_)
     return;
 
   // Can only have one of these operations in flight.
   DCHECK(select_folder_completion_callback_.is_null());
   DCHECK(failure_callback_.is_null());
   select_folder_completion_callback_ = on_success;
   failure_callback_ = on_failure;
 
   host_->Send(new MetroViewerHostMsg_DisplaySelectFolder(title));
 }
 
-bool RemoteWindowTreeHostWin::IsForegroundWindow() {
+bool RemoteRootWindowHostWin::IsForegroundWindow() {
   return ::GetForegroundWindow() == remote_window_;
 }
 
-Window* RemoteWindowTreeHostWin::GetAshWindow() {
+Window* RemoteRootWindowHostWin::GetAshWindow() {
   return GetRootWindow()->window();
 }
 
-RootWindow* RemoteWindowTreeHostWin::GetRootWindow() {
+RootWindow* RemoteRootWindowHostWin::GetRootWindow() {
   return delegate_->AsRootWindow();
 }
 
-gfx::AcceleratedWidget RemoteWindowTreeHostWin::GetAcceleratedWidget() {
+gfx::AcceleratedWidget RemoteRootWindowHostWin::GetAcceleratedWidget() {
   if (remote_window_)
     return remote_window_;
   // Getting here should only happen for ash_unittests.exe and related code.
   return ::GetDesktopWindow();
 }
 
-void RemoteWindowTreeHostWin::Show() {
+void RemoteRootWindowHostWin::Show() {
 }
 
-void RemoteWindowTreeHostWin::Hide() {
+void RemoteRootWindowHostWin::Hide() {
   NOTIMPLEMENTED();
 }
 
-void RemoteWindowTreeHostWin::ToggleFullScreen() {
+void RemoteRootWindowHostWin::ToggleFullScreen() {
 }
 
-gfx::Rect RemoteWindowTreeHostWin::GetBounds() const {
-  gfx::Rect r(gfx::Point(0, 0), aura::WindowTreeHost::GetNativeScreenSize());
+gfx::Rect RemoteRootWindowHostWin::GetBounds() const {
+  gfx::Rect r(gfx::Point(0, 0), aura::RootWindowHost::GetNativeScreenSize());
   return r;
 }
 
-void RemoteWindowTreeHostWin::SetBounds(const gfx::Rect& bounds) {
+void RemoteRootWindowHostWin::SetBounds(const gfx::Rect& bounds) {
   NotifyHostResized(bounds.size());
 }
 
-gfx::Insets RemoteWindowTreeHostWin::GetInsets() const {
+gfx::Insets RemoteRootWindowHostWin::GetInsets() const {
   return gfx::Insets();
 }
 
-void RemoteWindowTreeHostWin::SetInsets(const gfx::Insets& insets) {
+void RemoteRootWindowHostWin::SetInsets(const gfx::Insets& insets) {
 }
 
-gfx::Point RemoteWindowTreeHostWin::GetLocationOnNativeScreen() const {
+gfx::Point RemoteRootWindowHostWin::GetLocationOnNativeScreen() const {
   return gfx::Point(0, 0);
 }
 
-void RemoteWindowTreeHostWin::SetCursor(gfx::NativeCursor native_cursor) {
+void RemoteRootWindowHostWin::SetCursor(gfx::NativeCursor native_cursor) {
   if (!host_)
     return;
   host_->Send(
       new MetroViewerHostMsg_SetCursor(uint64(native_cursor.platform())));
 }
 
-void RemoteWindowTreeHostWin::SetCapture() {
+void RemoteRootWindowHostWin::SetCapture() {
 }
 
-void RemoteWindowTreeHostWin::ReleaseCapture() {
+void RemoteRootWindowHostWin::ReleaseCapture() {
 }
 
-bool RemoteWindowTreeHostWin::QueryMouseLocation(gfx::Point* location_return) {
+bool RemoteRootWindowHostWin::QueryMouseLocation(gfx::Point* location_return) {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(GetRootWindow()->window());
   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
     *location_return = gfx::Point(0, 0);
     return false;
   }
   POINT pt;
   GetCursorPos(&pt);
   *location_return =
       gfx::Point(static_cast<int>(pt.x), static_cast<int>(pt.y));
   return true;
 }
 
-bool RemoteWindowTreeHostWin::ConfineCursorToRootWindow() {
+bool RemoteRootWindowHostWin::ConfineCursorToRootWindow() {
   return true;
 }
 
-void RemoteWindowTreeHostWin::UnConfineCursor() {
+void RemoteRootWindowHostWin::UnConfineCursor() {
 }
 
-void RemoteWindowTreeHostWin::OnCursorVisibilityChanged(bool show) {
+void RemoteRootWindowHostWin::OnCursorVisibilityChanged(bool show) {
   NOTIMPLEMENTED();
 }
 
-void RemoteWindowTreeHostWin::MoveCursorTo(const gfx::Point& location) {
+void RemoteRootWindowHostWin::MoveCursorTo(const gfx::Point& location) {
   VLOG(1) << "In MoveCursorTo: " << location.x() << ", " << location.y();
   if (!host_)
     return;
 
   // This function can be called in cases like when the mouse cursor is
   // restricted within a viewport (For e.g. LockCursor) which assumes that
   // subsequent mouse moves would be received starting with the new cursor
   // coordinates. This is a challenge for Windows ASH for the reasons
   // outlined below.
   // Other cases which don't expect this behavior should continue to work
   // without issues.
 
   // The mouse events are received by the viewer process and sent to the
   // browser. If we invoke the SetCursor API here we continue to receive
   // mouse messages from the viewer which were posted before the SetCursor
   // API executes which messes up the state in the browser. To workaround
   // this we invoke the SetCursor API in the viewer process and ignore
   // mouse messages until we received an ACK from the viewer indicating that
   // the SetCursor operation completed.
   ignore_mouse_moves_until_set_cursor_ack_ = true;
   VLOG(1) << "In MoveCursorTo. Sending IPC";
   host_->Send(new MetroViewerHostMsg_SetCursorPos(location.x(), location.y()));
 }
 
-void RemoteWindowTreeHostWin::PostNativeEvent(
+void RemoteRootWindowHostWin::PostNativeEvent(
     const base::NativeEvent& native_event) {
 }
 
-void RemoteWindowTreeHostWin::OnDeviceScaleFactorChanged(
+void RemoteRootWindowHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   NOTIMPLEMENTED();
 }
 
-void RemoteWindowTreeHostWin::PrepareForShutdown() {
+void RemoteRootWindowHostWin::PrepareForShutdown() {
 }
 
-void RemoteWindowTreeHostWin::OnMouseMoved(int32 x, int32 y, int32 flags) {
+void RemoteRootWindowHostWin::OnMouseMoved(int32 x, int32 y, int32 flags) {
   if (ignore_mouse_moves_until_set_cursor_ack_)
     return;
 
   gfx::Point location(x, y);
   ui::MouseEvent event(ui::ET_MOUSE_MOVED, location, location, flags);
   delegate_->OnHostMouseEvent(&event);
 }
 
-void RemoteWindowTreeHostWin::OnMouseButton(
+void RemoteRootWindowHostWin::OnMouseButton(
     int32 x,
     int32 y,
     int32 extra,
     ui::EventType type,
     ui::EventFlags flags) {
   gfx::Point location(x, y);
   ui::MouseEvent mouse_event(type, location, location, flags);
 
   SetEventFlags(flags | key_event_flags());
   if (type == ui::ET_MOUSEWHEEL) {
@@ skipping 13 matching lines @@
     } else {
       mouse_event.SetClickCount(1);
     }
     last_mouse_click_event_ .reset(new ui::MouseEvent(mouse_event));
     delegate_->OnHostMouseEvent(&mouse_event);
   } else {
     delegate_->OnHostMouseEvent(&mouse_event);
   }
 }
 
-void RemoteWindowTreeHostWin::OnKeyDown(uint32 vkey,
+void RemoteRootWindowHostWin::OnKeyDown(uint32 vkey,
                                         uint32 repeat_count,
                                         uint32 scan_code,
                                         uint32 flags) {
   DispatchKeyboardMessage(ui::ET_KEY_PRESSED, vkey, repeat_count, scan_code,
                           flags, false);
 }
 
-void RemoteWindowTreeHostWin::OnKeyUp(uint32 vkey,
+void RemoteRootWindowHostWin::OnKeyUp(uint32 vkey,
                                       uint32 repeat_count,
                                       uint32 scan_code,
                                       uint32 flags) {
   DispatchKeyboardMessage(ui::ET_KEY_RELEASED, vkey, repeat_count, scan_code,
                           flags, false);
 }
 
-void RemoteWindowTreeHostWin::OnChar(uint32 key_code,
+void RemoteRootWindowHostWin::OnChar(uint32 key_code,
                                      uint32 repeat_count,
                                      uint32 scan_code,
                                      uint32 flags) {
   DispatchKeyboardMessage(ui::ET_KEY_PRESSED, key_code, repeat_count,
                           scan_code, flags, true);
 }
 
-void RemoteWindowTreeHostWin::OnWindowActivated() {
+void RemoteRootWindowHostWin::OnWindowActivated() {
   delegate_->OnHostActivated();
 }
 
-void RemoteWindowTreeHostWin::OnTouchDown(int32 x,
+void RemoteRootWindowHostWin::OnTouchDown(int32 x,
                                           int32 y,
                                           uint64 timestamp,
                                           uint32 pointer_id) {
   ui::TouchEvent event(ui::ET_TOUCH_PRESSED,
                        gfx::Point(x, y),
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
   delegate_->OnHostTouchEvent(&event);
 }
 
-void RemoteWindowTreeHostWin::OnTouchUp(int32 x,
+void RemoteRootWindowHostWin::OnTouchUp(int32 x,
                                         int32 y,
                                         uint64 timestamp,
                                         uint32 pointer_id) {
   ui::TouchEvent event(ui::ET_TOUCH_RELEASED,
                        gfx::Point(x, y),
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
   delegate_->OnHostTouchEvent(&event);
 }
 
-void RemoteWindowTreeHostWin::OnTouchMoved(int32 x,
+void RemoteRootWindowHostWin::OnTouchMoved(int32 x,
                                            int32 y,
                                            uint64 timestamp,
                                            uint32 pointer_id) {
   ui::TouchEvent event(ui::ET_TOUCH_MOVED,
                        gfx::Point(x, y),
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
   delegate_->OnHostTouchEvent(&event);
 }
 
-void RemoteWindowTreeHostWin::OnFileSaveAsDone(bool success,
+void RemoteRootWindowHostWin::OnFileSaveAsDone(bool success,
                                                const base::FilePath& filename,
                                                int filter_index) {
   if (success)
     file_saveas_completion_callback_.Run(filename, filter_index, NULL);
   else
     failure_callback_.Run(NULL);
   file_saveas_completion_callback_.Reset();
   failure_callback_.Reset();
 }
 
 
-void RemoteWindowTreeHostWin::OnFileOpenDone(bool success,
+void RemoteRootWindowHostWin::OnFileOpenDone(bool success,
                                              const base::FilePath& filename) {
   if (success)
     file_open_completion_callback_.Run(base::FilePath(filename), 0, NULL);
   else
     failure_callback_.Run(NULL);
   file_open_completion_callback_.Reset();
   failure_callback_.Reset();
 }
 
-void RemoteWindowTreeHostWin::OnMultiFileOpenDone(
+void RemoteRootWindowHostWin::OnMultiFileOpenDone(
     bool success,
     const std::vector<base::FilePath>& files) {
   if (success)
     multi_file_open_completion_callback_.Run(files, NULL);
   else
     failure_callback_.Run(NULL);
   multi_file_open_completion_callback_.Reset();
   failure_callback_.Reset();
 }
 
-void RemoteWindowTreeHostWin::OnSelectFolderDone(
+void RemoteRootWindowHostWin::OnSelectFolderDone(
     bool success,
     const base::FilePath& folder) {
   if (success)
     select_folder_completion_callback_.Run(base::FilePath(folder), 0, NULL);
   else
     failure_callback_.Run(NULL);
   select_folder_completion_callback_.Reset();
   failure_callback_.Reset();
 }
 
-void RemoteWindowTreeHostWin::OnSetCursorPosAck() {
+void RemoteRootWindowHostWin::OnSetCursorPosAck() {
   DCHECK(ignore_mouse_moves_until_set_cursor_ack_);
   ignore_mouse_moves_until_set_cursor_ack_ = false;
 }
 
-void RemoteWindowTreeHostWin::OnWindowSizeChanged(uint32 width, uint32 height) {
+void RemoteRootWindowHostWin::OnWindowSizeChanged(uint32 width, uint32 height) {
   SetBounds(gfx::Rect(0, 0, width, height));
 }
 
-void RemoteWindowTreeHostWin::OnDesktopActivated() {
+void RemoteRootWindowHostWin::OnDesktopActivated() {
   ActivateDesktopCompleted temp = activate_completed_callback_;
   activate_completed_callback_.Reset();
   temp.Run();
 }
 
-void RemoteWindowTreeHostWin::DispatchKeyboardMessage(ui::EventType type,
+void RemoteRootWindowHostWin::DispatchKeyboardMessage(ui::EventType type,
                                                       uint32 vkey,
                                                       uint32 repeat_count,
                                                       uint32 scan_code,
                                                       uint32 flags,
                                                       bool is_character) {
   SetEventFlags(flags | mouse_event_flags());
   if (base::MessageLoop::current()->IsNested()) {
     uint32 message = is_character ? WM_CHAR :
         (type == ui::ET_KEY_PRESSED ? WM_KEYDOWN : WM_KEYUP);
     ::PostThreadMessage(::GetCurrentThreadId(),
                         message,
                         vkey,
                         repeat_count | scan_code >> 15);
   } else {
     ui::KeyEvent event(type,
                        ui::KeyboardCodeForWindowsKeyCode(vkey),
                        flags,
                        is_character);
     delegate_->OnHostKeyEvent(&event);
   }
 }
 
-void RemoteWindowTreeHostWin::SetEventFlags(uint32 flags) {
+void RemoteRootWindowHostWin::SetEventFlags(uint32 flags) {
   if (flags == event_flags_)
     return;
   event_flags_ = flags;
   SetVirtualKeyStates(event_flags_);
 }
 
 }  // namespace aura