change the way windows are parented when their parent is set to NULL.

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 "ui/aura/desktop.h"
+#include "ui/aura/desktop_delegate.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.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/compositor/layer.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 using internal::RootWindow;
 
 Window::Window(WindowDelegate* delegate)
-    : delegate_(delegate),
+    : type_(kWindowType_Toplevel),
+      delegate_(delegate),
       show_state_(ui::SHOW_STATE_NORMAL),
       parent_(NULL),
       id_(-1),
       user_data_(NULL),
       stops_event_propagation_(false) {
 }
 
 Window::~Window() {
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
@@ skipping 24 matching lines @@
   if (delegate_)
     type = ui::Layer::LAYER_HAS_TEXTURE;
   layer_.reset(new ui::Layer(Desktop::GetInstance()->compositor(), type));
   // Windows (and therefore the layer) should initially be hidden.
   // TODO: when we distinguish control (child) windows, they should be initially
   // visible.
   layer_->SetVisible(false);
   layer_->set_delegate(this);
 }
 
+void Window::SetType(int type) {
+  // Cannot change type after the window is initialized.
+  DCHECK(!layer());
+  type_ = type;
+}
+
 void Window::Show() {
   SetVisible(true);
 }
 
 void Window::Hide() {
   SetVisible(false);
   ReleaseCapture();
   if (Desktop::GetInstance()->active_window() == this ||
       !Desktop::GetInstance()->active_window()) {
     Desktop::GetInstance()->ActivateTopmostWindow();
@@ skipping 38 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()->delegate())
+    Desktop::GetInstance()->delegate()->AddChildToDefaultParent(this);
   else
-    Desktop::GetInstance()->default_parent()->AddChild(this);
+    NOTREACHED();
 }
 
 void Window::Restore() {
   if (show_state_ != ui::SHOW_STATE_NORMAL) {
     show_state_ = ui::SHOW_STATE_NORMAL;
     SetBounds(restore_bounds_);
     restore_bounds_.SetRect(0, 0, 0, 0);
   }
 }
 
 void Window::Maximize() {
   if (UpdateShowStateAndRestoreBounds(ui::SHOW_STATE_MAXIMIZED))
     SetBounds(gfx::Screen::GetMonitorWorkAreaNearestWindow(this));
 }
 
 void Window::Fullscreen() {
   if (UpdateShowStateAndRestoreBounds(ui::SHOW_STATE_FULLSCREEN))
     SetBounds(gfx::Screen::GetMonitorAreaNearestWindow(this));
 }
 
-bool Window::IsToplevelWindowContainer() const {
-  return false;
+ToplevelWindowContainer* Window::AsToplevelWindowContainer() {
+  return NULL;
+}
+
+const ToplevelWindowContainer* Window::AsToplevelWindowContainer() const {
+  return NULL;
 }
 
 void Window::MoveChildToFront(Window* child) {
   DCHECK_EQ(child->parent(), this);
   const Windows::iterator i(std::find(children_.begin(), children_.end(),
                                       child));
   DCHECK(i != children_.end());
   children_.erase(i);
 
   // TODO(beng): this obviously has to handle different window types.
   children_.insert(children_.begin() + children_.size(), child);
   SchedulePaintInRect(gfx::Rect());
 
   child->layer()->parent()->MoveToFront(child->layer());
 }
 
+bool Window::CanActivate() const {
+  return IsVisible() && delegate_ && delegate_->ShouldActivate(NULL);
+}
+
 void Window::AddChild(Window* child) {
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
     child->parent()->RemoveChild(child);
   child->parent_ = this;
   layer_->Add(child->layer_.get());
   children_.push_back(child);
 }
 
 void Window::RemoveChild(Window* child) {
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   child->parent_ = NULL;
   layer_->Remove(child->layer_.get());
   children_.erase(i);
 }
 
 Window* Window::GetChildById(int id) {
+  return const_cast<Window*>(const_cast<const Window*>(this)->GetChildById(id));
+}
+
+const Window* Window::GetChildById(int id) const {
   Windows::const_iterator i;
   for (i = children_.begin(); i != children_.end(); ++i) {
     if ((*i)->id() == id)
       return *i;
-    Window* result = (*i)->GetChildById(id);
+    const Window* result = (*i)->GetChildById(id);
     if (result)
       return result;
   }
   return NULL;
 }
 
 // static
 void Window::ConvertPointToWindow(Window* source,
                                   Window* target,
                                   gfx::Point* point) {
@@ skipping 140 matching lines @@
     ui::WindowShowState new_show_state) {
   if (show_state_ == new_show_state)
     return false;
   show_state_ = new_show_state;
   if (restore_bounds_.IsEmpty())
     restore_bounds_ = bounds();
   return true;
 }
 
 }  // namespace aura