aura: Draw drop shadows under browsers and menus.

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"
@@ skipping 60 matching lines @@
   STLDeleteElements(&transient_children);
   DCHECK(transient_children_.empty());
 
   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);
+
 #if !defined(NDEBUG)
   std::string layer_name(name_);
   if (layer_name.empty())
     layer_name.append("Unnamed Window");
 
   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
+
+  Desktop::GetInstance()->WindowInitialized(this);
 }
 
 void Window::SetType(WindowType type) {
   // Cannot change type after the window is initialized.
   DCHECK(!layer());
   type_ = type;
 }
 
 void Window::Show() {
   SetVisible(true);
@@ skipping 108 matching lines @@
   // 'child'.
   Window* last_transient = child;
   for (Windows::iterator i = child->transient_children_.begin();
        i != child->transient_children_.end(); ++i) {
     Window* transient_child = *i;
     if (transient_child->parent_ == this) {
       MoveChildAbove(transient_child, last_transient);
       last_transient = transient_child;
     }
   }
+
+  child->OnStackingChanged();
 }
 
 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);
   if (layout_manager_.get())
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
+  child->OnParentChanged();
 }
 
 void Window::AddTransientChild(Window* child) {
   if (child->transient_parent_)
     child->transient_parent_->RemoveTransientChild(child);
   DCHECK(std::find(transient_children_.begin(), transient_children_.end(),
                    child) == transient_children_.end());
   transient_children_.push_back(child);
   child->transient_parent_ = this;
 }
@@ skipping 12 matching lines @@
   DCHECK(i != children_.end());
   if (layout_manager_.get())
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
   aura::Window* desktop = child->GetDesktop();
   child->parent_ = NULL;
   if (desktop)
     desktop->WindowDetachedFromDesktop(child);
   layer_->Remove(child->layer_.get());
   children_.erase(i);
+  child->OnParentChanged();
 }
 
 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)
@@ skipping 163 matching lines @@
 
   // If we're not changing the effective bounds, then we can bail early and skip
   // notifying our listeners.
   if (old_bounds == actual_new_bounds)
     return;
 
   if (layout_manager_.get())
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, actual_new_bounds);
+  FOR_EACH_OBSERVER(WindowObserver,
+                    observers_,
+                    OnWindowBoundsChanged(this, actual_new_bounds));
 }
 
 void Window::SetVisible(bool visible) {
   if (visible == layer_->visible())
     return;  // No change.
 
   bool was_visible = IsVisible();
   layer_->SetVisible(visible);
   bool is_visible = IsVisible();
   if (was_visible != is_visible) {
     SchedulePaint();
     if (delegate_)
       delegate_->OnWindowVisibilityChanged(is_visible);
   }
+
   if (parent_ && parent_->layout_manager_.get())
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanged(this, visible));
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
@@ skipping 28 matching lines @@
     if (match)
       return match;
 
     if (for_event_handling && child->StopsEventPropagation())
       break;
   }
 
   return delegate_ ? this : NULL;
 }
 
+void Window::OnParentChanged() {
+  FOR_EACH_OBSERVER(
+      WindowObserver, observers_, OnWindowParentChanged(this, parent_));
+}
+
+void Window::OnStackingChanged() {
+  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowStackingChanged(this));
+}
+
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura