Rename Desktop->RootWindow.

ui/aura/window.cc

 // Copyright (c) 2011 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/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "ui/aura/client/stacking_client.h"
-#include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/layout_manager.h"
+#include "ui/aura/root_window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_types.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 Window::Window(WindowDelegate* delegate)
     : type_(WINDOW_TYPE_UNKNOWN),
       delegate_(delegate),
       parent_(NULL),
       transient_parent_(NULL),
       id_(-1),
       user_data_(NULL),
       stops_event_propagation_(false),
       ignore_events_(false) {
 }
 
 Window::~Window() {
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying();
 
   // Let the root know so that it can remove any references to us.
-  Desktop* desktop = GetDesktop();
-  if (desktop)
-    desktop->WindowDestroying(this);
+  RootWindow* root_window = GetRootWindow();
+  if (root_window)
+    root_window->WindowDestroying(this);
 
   // Then destroy the children.
   while (!children_.empty()) {
     Window* child = children_[0];
     delete child;
     // Deleting the child so remove it from out children_ list.
     DCHECK(std::find(children_.begin(), children_.end(), child) ==
            children_.end());
   }
 
@@ skipping 16 matching lines @@
 
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroyed(this));
 }
 
 void Window::Init(ui::Layer::LayerType layer_type) {
   layer_.reset(new ui::Layer(layer_type));
   layer_->SetVisible(false);
   layer_->set_delegate(this);
   UpdateLayerName(name_);
 
-  Desktop::GetInstance()->WindowInitialized(this);
+  RootWindow::GetInstance()->WindowInitialized(this);
 }
 
 void Window::SetType(WindowType type) {
   // Cannot change type after the window is initialized.
   DCHECK(!layer());
   type_ = type;
 }
 
 void Window::SetName(const std::string& name) {
   name_ = name;
 
   if (layer())
     UpdateLayerName(name_);
 }
 
 void Window::Show() {
   SetVisible(true);
 }
 
 void Window::Hide() {
   SetVisible(false);
   ReleaseCapture();
-  if (Desktop::GetInstance()->active_window() == this ||
-      !Desktop::GetInstance()->active_window()) {
-    Desktop::GetInstance()->ActivateTopmostWindow();
+  if (RootWindow::GetInstance()->active_window() == this ||
+      !RootWindow::GetInstance()->active_window()) {
+    RootWindow::GetInstance()->ActivateTopmostWindow();
   }
 }
 
 bool Window::IsVisible() const {
   return layer_->IsDrawn();
 }
 
 gfx::Rect Window::GetScreenBounds() const {
   gfx::Point origin = bounds().origin();
   Window::ConvertPointToWindow(parent_,
-                               aura::Desktop::GetInstance(),
+                               aura::RootWindow::GetInstance(),
                                &origin);
   return gfx::Rect(origin, bounds().size());
 }
 
 void Window::Activate() {
   // If we support minimization need to ensure this restores the window first.
-  aura::Desktop::GetInstance()->SetActiveWindow(this, this);
+  aura::RootWindow::GetInstance()->SetActiveWindow(this, this);
 }
 
 void Window::Deactivate() {
-  aura::Desktop::GetInstance()->Deactivate(this);
+  aura::RootWindow::GetInstance()->Deactivate(this);
 }
 
 bool Window::IsActive() const {
-  return aura::Desktop::GetInstance()->active_window() == this;
+  return aura::RootWindow::GetInstance()->active_window() == this;
 }
 
 void Window::SetTransform(const ui::Transform& transform) {
   layer()->SetTransform(transform);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   layout_manager_.reset(layout_manager);
 }
 
@@ skipping 20 matching lines @@
   // TODO: figure out how this is going to work when animating the layer. In
   // particular if we're animating the size then the underlying Texture is going
   // to be unhappy if we try to set a texture on a size bigger than the size of
   // the texture.
   layer_->SetCanvas(canvas, origin);
 }
 
 void Window::SetParent(Window* parent) {
   if (parent)
     parent->AddChild(this);
-  else if (Desktop::GetInstance()->stacking_client())
-    Desktop::GetInstance()->stacking_client()->AddChildToDefaultParent(this);
+  else if (RootWindow::GetInstance()->stacking_client())
+    RootWindow::GetInstance()->stacking_client()->AddChildToDefaultParent(this);
   else
     NOTREACHED();
 }
 
 void Window::StackChildAtTop(Window* child) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // In the front already.
   StackChildAbove(child, children_.back());
 }
 
@@ skipping 69 matching lines @@
   if (child->transient_parent_ == this)
     child->transient_parent_ = NULL;
 }
 
 void Window::RemoveChild(Window* child) {
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   if (layout_manager_.get())
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
-  aura::Window* desktop = child->GetDesktop();
+  aura::Window* root_window = child->GetRootWindow();
   child->parent_ = NULL;
-  if (desktop)
-    desktop->WindowDetachedFromDesktop(child);
+  if (root_window)
+    root_window->WindowDetachedFromRootWindow(child);
   layer_->Remove(child->layer_.get());
   children_.erase(i);
   child->OnParentChanged();
 }
 
 bool Window::Contains(const Window* other) const {
   for (const Window* parent = other; parent; parent = parent->parent_) {
     if (parent == this)
       return true;
   }
@@ skipping 107 matching lines @@
 }
 
 const internal::FocusManager* Window::GetFocusManager() const {
   return parent_ ? parent_->GetFocusManager() : NULL;
 }
 
 void Window::SetCapture() {
   if (!IsVisible())
     return;
 
-  Desktop* desktop = GetDesktop();
-  if (!desktop)
+  RootWindow* root_window = GetRootWindow();
+  if (!root_window)
     return;
 
-  desktop->SetCapture(this);
+  root_window->SetCapture(this);
 }
 
 void Window::ReleaseCapture() {
-  Desktop* desktop = GetDesktop();
-  if (!desktop)
+  RootWindow* root_window = GetRootWindow();
+  if (!root_window)
     return;
 
-  desktop->ReleaseCapture(this);
+  root_window->ReleaseCapture(this);
 }
 
 bool Window::HasCapture() {
-  Desktop* desktop = GetDesktop();
-  return desktop && desktop->capture_window() == this;
+  RootWindow* root_window = GetRootWindow();
+  return root_window && root_window->capture_window() == this;
 }
 
 void Window::SetProperty(const char* name, void* value) {
   void* old = GetProperty(name);
   if (value)
     prop_map_[name] = value;
   else
     prop_map_.erase(name);
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowPropertyChanged(this, name, old));
 }
 
 void Window::SetIntProperty(const char* name, int value) {
   SetProperty(name, reinterpret_cast<void*>(value));
 }
 
 void* Window::GetProperty(const char* name) const {
   std::map<const char*, void*>::const_iterator iter = prop_map_.find(name);
   if (iter == prop_map_.end())
     return NULL;
   return iter->second;
 }
 
 int Window::GetIntProperty(const char* name) const {
   return static_cast<int>(reinterpret_cast<intptr_t>(
       GetProperty(name)));
 }
 
-Desktop* Window::GetDesktop() {
-  return parent_ ? parent_->GetDesktop() : NULL;
+RootWindow* Window::GetRootWindow() {
+  return parent_ ? parent_->GetRootWindow() : NULL;
 }
 
-void Window::WindowDetachedFromDesktop(aura::Window* window) {
+void Window::WindowDetachedFromRootWindow(aura::Window* window) {
 }
 
 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
   gfx::Rect actual_new_bounds(new_bounds);
 
   // Ensure we don't go smaller than our minimum bounds.
   if (delegate_) {
     const gfx::Size& min_size = delegate_->GetMinimumSize();
     actual_new_bounds.set_width(
         std::max(min_size.width(), actual_new_bounds.width()));
@@ skipping 107 matching lines @@
   if (id_ != -1) {
     char id_buf[10];
     base::snprintf(id_buf, sizeof(id_buf), " %d", id_);
     layer_name.append(id_buf);
   }
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura