Revert 236048 "Rename RootWindowHost* to WindowTreeHost*"

trunk/src/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 51 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);
   }
 }
 
-WindowTreeHost* CreateHost(RootWindow* root_window,
+RootWindowHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
-  WindowTreeHost* host = params.host ?
-      params.host : WindowTreeHost::Create(params.initial_bounds);
+  RootWindowHost* host = params.host ?
+      params.host : RootWindowHost::Create(params.initial_bounds);
   host->set_delegate(root_window);
   return host;
 }
 
 }  // namespace
 
 RootWindow::CreateParams::CreateParams(const gfx::Rect& a_initial_bounds)
     : initial_bounds(a_initial_bounds),
       host(NULL) {
 }
@@ skipping 76 matching lines @@
         base::Bind(&RootWindow::DispatchHeldEventsAsync,
                    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.
   }
 }
 
-WindowTreeHostDelegate* RootWindow::AsWindowTreeHostDelegate() {
+RootWindowHostDelegate* RootWindow::AsRootWindowHostDelegate() {
   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 131 matching lines @@
        window->ContainsPointInRoot(GetLastMouseLocationInRoot()))) {
     PostMouseMoveEventAfterWindowChange();
   }
 }
 
 void RootWindow::OnKeyboardMappingChanged() {
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnKeyboardMappingChanged(this));
 }
 
-void RootWindow::OnWindowTreeHostCloseRequested() {
+void RootWindow::OnRootWindowHostCloseRequested() {
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
-                    OnWindowTreeHostCloseRequested(this));
+                    OnRootWindowHostCloseRequested(this));
 }
 
 void RootWindow::AddRootWindowObserver(RootWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RootWindow::RemoveRootWindowObserver(RootWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 245 matching lines @@
 
 void RootWindow::OnLayerAnimationScheduled(
     ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* animation) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// RootWindow, WindowTreeHostDelegate implementation:
+// RootWindow, RootWindowHostDelegate implementation:
 
 bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
   DispatchDetails details = DispatchHeldEvents();
   if (details.dispatcher_destroyed)
     return false;
   if (event->key_code() == ui::VKEY_UNKNOWN)
     return false;
   client::EventClient* client = client::GetEventClient(window());
   Window* focused_window = client::GetFocusClient(window())->GetFocusedWindow();
   if (client && !client->CanProcessEventsWithinSubtree(focused_window)) {
@@ skipping 86 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_,
-                    OnWindowTreeHostMoved(this, origin));
+                    OnRootWindowHostMoved(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_,
-                    OnWindowTreeHostResized(this));
+                    OnRootWindowHostResized(this));
 }
 
 RootWindow* RootWindow::AsRootWindow() {
   return this;
 }
 
 const RootWindow* RootWindow::AsRootWindow() const {
   return this;
 }
 
@@ skipping 269 matching lines @@
   return OnHostMouseEventImpl(&event);
 }
 
 void RootWindow::SynthesizeMouseMoveEventAsync() {
   DispatchDetails details = SynthesizeMouseMoveEvent();
   if (details.dispatcher_destroyed)
     return;
 }
 
 }  // namespace aura