Rename RootWindowHost to WindowTreeHost

ui/views/widget/desktop_aura/desktop_native_widget_aura.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/views/widget/desktop_aura/desktop_native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 229 matching lines @@
 }
 
 // static
 DesktopNativeWidgetAura* DesktopNativeWidgetAura::ForWindow(
     aura::Window* window) {
   return window->GetProperty(kDesktopNativeWidgetAuraKey);
 }
 
 void DesktopNativeWidgetAura::OnHostClosed() {
   // Don't invoke Widget::OnNativeWidgetDestroying(), its done by
-  // DesktopRootWindowHost.
+  // DesktopWindowTreeHost.
 
   // The WindowModalityController is at the front of the event pretarget
   // handler list. We destroy it first to preserve order symantics.
   if (window_modality_controller_)
     window_modality_controller_.reset();
 
   // Make sure we don't have capture. Otherwise CaptureController and RootWindow
   // are left referencing a deleted Window.
   {
     aura::Window* capture_window = capture_client_->GetCaptureWindow();
     if (capture_window && root_window_->window()->Contains(capture_window))
       capture_window->ReleaseCapture();
   }
 
-  // DesktopRootWindowHost owns the ActivationController which ShadowController
+  // DesktopWindowTreeHost owns the ActivationController which ShadowController
   // references. Make sure we destroy ShadowController early on.
   shadow_controller_.reset();
   tooltip_manager_.reset();
   root_window_->window()->RemovePreTargetHandler(tooltip_controller_.get());
   aura::client::SetTooltipClient(root_window_->window(), NULL);
   tooltip_controller_.reset();
 
   root_window_event_filter_->RemoveHandler(input_method_event_filter_.get());
 
   window_tree_client_.reset();  // Uses root_window_ at destruction.
 
   capture_client_.reset();  // Uses root_window_ at destruction.
 
   root_window_->RemoveRootWindowObserver(this);
   root_window_.reset();  // Uses input_method_event_filter_ at destruction.
   // RootWindow owns |desktop_root_window_host_|.
   desktop_root_window_host_ = NULL;
   content_window_ = NULL;
 
   native_widget_delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
-void DesktopNativeWidgetAura::OnDesktopRootWindowHostDestroyed(
+void DesktopNativeWidgetAura::OnDesktopWindowTreeHostDestroyed(
     aura::RootWindow* root) {
-  // |root_window_| is still valid, but DesktopRootWindowHost is nearly
-  // destroyed. Do cleanup here of members DesktopRootWindowHost may also use.
+  // |root_window_| is still valid, but DesktopWindowTreeHost is nearly
+  // destroyed. Do cleanup here of members DesktopWindowTreeHost may also use.
   aura::client::SetFocusClient(root->window(), NULL);
   aura::client::SetActivationClient(root->window(), NULL);
   focus_client_.reset();
 
   aura::client::SetDispatcherClient(root->window(), NULL);
   dispatcher_client_.reset();
 
   aura::client::SetCursorClient(root->window(), NULL);
   native_cursor_manager_->RemoveRootWindow(root);
 
@@ skipping 58 matching lines @@
   content_window_->Init(params.layer_type);
   corewm::SetShadowType(content_window_, corewm::SHADOW_TYPE_NONE);
 
   content_window_container_ = new aura::Window(NULL);
   content_window_container_->Init(ui::LAYER_NOT_DRAWN);
   content_window_container_->Show();
   content_window_container_->AddChild(content_window_);
 
   desktop_root_window_host_ = params.desktop_root_window_host ?
       params.desktop_root_window_host :
-      DesktopRootWindowHost::Create(native_widget_delegate_, this);
+      DesktopWindowTreeHost::Create(native_widget_delegate_, this);
   aura::RootWindow::CreateParams rw_params(params.bounds);
   desktop_root_window_host_->Init(content_window_, params, &rw_params);
 
   root_window_.reset(new aura::RootWindow(rw_params));
   root_window_->Init();
   root_window_->window()->AddChild(content_window_container_);
 
   // The WindowsModalityController event filter should be at the head of the
   // pre target handlers list. This ensures that it handles input events first
   // when modal windows are at the top of the Zorder.
   if (widget_type_ == Widget::InitParams::TYPE_WINDOW)
     window_modality_controller_.reset(
         new views::corewm::WindowModalityController(root_window_->window()));
 
   // |root_window_event_filter_| must be created before
-  // OnRootWindowHostCreated() is invoked.
+  // OnWindowTreeHostCreated() is invoked.
 
   // CEF sets focus to the window the user clicks down on.
   // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
   //             handed way of accomplishing focus.
   // No event filter for aura::Env. Create CompoundEvnetFilter per RootWindow.
   root_window_event_filter_ = new corewm::CompoundEventFilter;
   // Pass ownership of the filter to the root_window.
   root_window_->window()->SetEventFilter(root_window_event_filter_);
 
   // |root_window_| must be added to |native_cursor_manager_| before
@@ skipping 32 matching lines @@
 
   InstallInputMethodEventFilter();
 
   drag_drop_client_ = desktop_root_window_host_->CreateDragDropClient(
       native_cursor_manager_);
   aura::client::SetDragDropClient(root_window_->window(),
                                   drag_drop_client_.get());
 
   focus_client_->FocusWindow(content_window_);
 
-  OnRootWindowHostResized(root_window_.get());
+  OnWindowTreeHostResized(root_window_.get());
 
   root_window_->AddRootWindowObserver(this);
 
   window_tree_client_.reset(
       new DesktopNativeWidgetAuraWindowTreeClient(root_window_->window()));
   drop_helper_.reset(new DropHelper(
       static_cast<internal::RootView*>(GetWidget()->GetRootView())));
   aura::client::SetDragDropDelegate(content_window_, this);
 
   tooltip_manager_.reset(new TooltipManagerAura(GetWidget()));
@@ skipping 178 matching lines @@
   return content_window_ ?
       desktop_root_window_host_->GetRestoredBounds() : gfx::Rect();
 }
 
 void DesktopNativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
   if (!content_window_)
     return;
   // TODO(ananta)
   // This code by default scales the bounds rectangle by 1.
   // We could probably get rid of this and similar logic from
-  // the DesktopNativeWidgetAura::OnRootWindowHostResized function.
+  // the DesktopNativeWidgetAura::OnWindowTreeHostResized function.
   float scale = 1;
   aura::Window* root = root_window_->window();
   if (root) {
     scale = gfx::Screen::GetScreenFor(root)->
         GetDisplayNearestWindow(root).device_scale_factor();
   }
   gfx::Rect bounds_in_pixels(
       gfx::ToCeiledPoint(gfx::ScalePoint(bounds.origin(), scale)),
       gfx::ToFlooredSize(gfx::ScaleSize(bounds.size(), scale)));
-  desktop_root_window_host_->AsRootWindowHost()->SetBounds(bounds_in_pixels);
+  desktop_root_window_host_->AsWindowTreeHost()->SetBounds(bounds_in_pixels);
 }
 
 void DesktopNativeWidgetAura::SetSize(const gfx::Size& size) {
   if (content_window_)
     desktop_root_window_host_->SetSize(size);
 }
 
 void DesktopNativeWidgetAura::StackAbove(gfx::NativeView native_view) {
 }
 
@@ skipping 21 matching lines @@
 }
 
 void DesktopNativeWidgetAura::CloseNow() {
   if (content_window_)
     desktop_root_window_host_->CloseNow();
 }
 
 void DesktopNativeWidgetAura::Show() {
   if (!content_window_)
     return;
-  desktop_root_window_host_->AsRootWindowHost()->Show();
+  desktop_root_window_host_->AsWindowTreeHost()->Show();
   content_window_->Show();
 }
 
 void DesktopNativeWidgetAura::Hide() {
   if (!content_window_)
     return;
-  desktop_root_window_host_->AsRootWindowHost()->Hide();
+  desktop_root_window_host_->AsWindowTreeHost()->Hide();
   content_window_->Hide();
 }
 
 void DesktopNativeWidgetAura::ShowMaximizedWithBounds(
       const gfx::Rect& restored_bounds) {
   if (!content_window_)
     return;
   desktop_root_window_host_->ShowMaximizedWithBounds(restored_bounds);
   content_window_->Show();
 }
@@ skipping 136 matching lines @@
     desktop_root_window_host_->EndMoveLoop();
 }
 
 void DesktopNativeWidgetAura::SetVisibilityChangedAnimationsEnabled(
     bool value) {
   if (content_window_)
     desktop_root_window_host_->SetVisibilityChangedAnimationsEnabled(value);
 }
 
 ui::NativeTheme* DesktopNativeWidgetAura::GetNativeTheme() const {
-  return DesktopRootWindowHost::GetNativeTheme(content_window_);
+  return DesktopWindowTreeHost::GetNativeTheme(content_window_);
 }
 
 void DesktopNativeWidgetAura::OnRootViewLayout() const {
   if (content_window_)
     desktop_root_window_host_->OnRootViewLayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, aura::WindowDelegate implementation:
 
@@ skipping 207 matching lines @@
 int DesktopNativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   Activate();
   return drop_helper_->OnDrop(event.data(), event.location(),
       last_drop_operation_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, aura::RootWindowObserver implementation:
 
-void DesktopNativeWidgetAura::OnRootWindowHostCloseRequested(
+void DesktopNativeWidgetAura::OnWindowTreeHostCloseRequested(
     const aura::RootWindow* root) {
   Close();
 }
 
-void DesktopNativeWidgetAura::OnRootWindowHostResized(
+void DesktopNativeWidgetAura::OnWindowTreeHostResized(
     const aura::RootWindow* root) {
   // Don't update the bounds of the child layers when animating closed. If we
   // did it would force a paint, which we don't want. We don't want the paint
   // as we can't assume any of the children are valid.
   if (desktop_root_window_host_->IsAnimatingClosed())
     return;
 
   gfx::Rect new_bounds = gfx::Rect(root->window()->bounds().size());
   content_window_->SetBounds(new_bounds);
   // Can be NULL at start.
   if (content_window_container_)
     content_window_container_->SetBounds(new_bounds);
   native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
 }
 
-void DesktopNativeWidgetAura::OnRootWindowHostMoved(
+void DesktopNativeWidgetAura::OnWindowTreeHostMoved(
     const aura::RootWindow* root,
     const gfx::Point& new_origin) {
-  TRACE_EVENT1("views", "DesktopNativeWidgetAura::OnRootWindowHostMoved",
+  TRACE_EVENT1("views", "DesktopNativeWidgetAura::OnWindowTreeHostMoved",
                "new_origin", new_origin.ToString());
 
   native_widget_delegate_->OnNativeWidgetMove();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, NativeWidget implementation:
 
 ui::EventHandler* DesktopNativeWidgetAura::GetEventHandler() {
   return this;
 }
 
 void DesktopNativeWidgetAura::InstallInputMethodEventFilter() {
   DCHECK(!input_method_event_filter_.get());
 
   input_method_event_filter_.reset(new corewm::InputMethodEventFilter(
       root_window_->host()->GetAcceleratedWidget()));
   input_method_event_filter_->SetInputMethodPropertyInRootWindow(
       root_window_->window());
   root_window_event_filter_->AddHandler(input_method_event_filter_.get());
 }
 
 void DesktopNativeWidgetAura::UpdateWindowTransparency() {
   content_window_->SetTransparent(ShouldUseNativeFrame());
 }
 
 }  // namespace views