Rename RootWindowHost* to WindowTreeHost*

ui/aura/root_window.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.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 52 matching lines @@
       client::GetScreenPositionClient(root_window);
   if (client) {
     gfx::Point location_in_screen = location_in_root;
     client->ConvertPointToScreen(root_window, &location_in_screen);
     Env::GetInstance()->set_last_mouse_location(location_in_screen);
   } else {
     Env::GetInstance()->set_last_mouse_location(location_in_root);
   }
 }
 
-RootWindowHost* CreateHost(RootWindow* root_window,
+WindowTreeHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
-  RootWindowHost* host = params.host ?
-      params.host : RootWindowHost::Create(params.initial_bounds);
+  WindowTreeHost* host = params.host ?
+      params.host : WindowTreeHost::Create(params.initial_bounds);
   host->set_delegate(root_window);
   return host;
 }
 
 bool IsUsingEventProcessorForDispatch(const ui::Event& event) {
   return event.IsKeyEvent() ||
          event.IsScrollEvent();
 }
 
 }  // namespace
@@ skipping 85 matching lines @@
         base::Bind(base::IgnoreResult(&RootWindow::DispatchHeldEvents),
                    repost_event_factory_.GetWeakPtr()));
   } else {
     DCHECK(event.type() == ui::ET_GESTURE_TAP_DOWN);
     held_repostable_event_.reset();
     // TODO(rbyers): Reposing of gestures is tricky to get
     // right, so it's not yet supported.  crbug.com/170987.
   }
 }
 
-RootWindowHostDelegate* RootWindow::AsRootWindowHostDelegate() {
+WindowTreeHostDelegate* RootWindow::AsWindowTreeHostDelegate() {
   return this;
 }
 
 void RootWindow::SetHostSize(const gfx::Size& size_in_pixel) {
   DispatchDetails details = DispatchHeldEvents();
   if (details.dispatcher_destroyed)
     return;
   gfx::Rect bounds = host_->GetBounds();
   bounds.set_size(size_in_pixel);
   host_->SetBounds(bounds);
@@ skipping 137 matching lines @@
        window->ContainsPointInRoot(GetLastMouseLocationInRoot()))) {
     PostMouseMoveEventAfterWindowChange();
   }
 }
 
 void RootWindow::OnKeyboardMappingChanged() {
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnKeyboardMappingChanged(this));
 }
 
-void RootWindow::OnRootWindowHostCloseRequested() {
+void RootWindow::OnWindowTreeHostCloseRequested() {
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
-                    OnRootWindowHostCloseRequested(this));
+                    OnWindowTreeHostCloseRequested(this));
 }
 
 void RootWindow::AddRootWindowObserver(RootWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RootWindow::RemoveRootWindowObserver(RootWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 282 matching lines @@
 
 void RootWindow::OnLayerAnimationScheduled(
     ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* animation) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// RootWindow, RootWindowHostDelegate implementation:
+// RootWindow, WindowTreeHostDelegate implementation:
 
 bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
   DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
     event->SetHandled();
   return event->handled();
 }
 
 bool RootWindow::OnHostMouseEvent(ui::MouseEvent* event) {
   DispatchDetails details = OnHostMouseEventImpl(event);
@@ skipping 52 matching lines @@
 void RootWindow::OnHostLostMouseGrab() {
   mouse_pressed_handler_ = NULL;
   mouse_moved_handler_ = NULL;
 }
 
 void RootWindow::OnHostMoved(const gfx::Point& origin) {
   TRACE_EVENT1("ui", "RootWindow::OnHostMoved",
                "origin", origin.ToString());
 
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
-                    OnRootWindowHostMoved(this, origin));
+                    OnWindowTreeHostMoved(this, origin));
 }
 
 void RootWindow::OnHostResized(const gfx::Size& size) {
   TRACE_EVENT1("ui", "RootWindow::OnHostResized",
                "size", size.ToString());
 
   DispatchDetails details = DispatchHeldEvents();
   if (details.dispatcher_destroyed)
     return;
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
-                    OnRootWindowHostResized(this));
+                    OnWindowTreeHostResized(this));
 }
 
 RootWindow* RootWindow::AsRootWindow() {
   return this;
 }
 
 const RootWindow* RootWindow::AsRootWindow() const {
   return this;
 }
 
@@ skipping 290 matching lines @@
     flags |= ui::EF_IS_NON_CLIENT;
   event->set_flags(flags);
 
   if (!dispatching_held_event_) {
     SetLastMouseLocation(window(), event->location());
     synthesize_mouse_move_ = false;
   }
 }
 
 }  // namespace aura