aura: Some changes in Window and Desktop.

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_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/compositor/layer.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 using internal::RootWindow;
 
 Window::Window(WindowDelegate* 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() {
+  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowClosing(this));
+
   // 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.
   RootWindow* root = GetRoot();
   if (root)
     root->WindowDestroying(this);
 
   // Then destroy the children.
@@ skipping 59 matching lines @@
   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::Activate() {
   // If we support minimization need to ensure this restores the window first.
   aura::Desktop::GetInstance()->SetActiveWindow(this, this);
+  FOR_EACH_OBSERVER(WindowObserver, observers_,

[sky, 2011/10/12 22:05:38]

This should be up in the Desktop, not here (there are a number of reasons why
this could fail, which would result in a bad notification).

[sadrul, 2011/10/12 22:59:58]

Removed this, added DesktopObserver::OnActiveWindowChanged instead.

+                    OnWindowActivationChanged(this, true));
 }
 
 void Window::Deactivate() {
   aura::Desktop::GetInstance()->Deactivate(this);
+  FOR_EACH_OBSERVER(WindowObserver, observers_,

[sky, 2011/10/12 22:05:38]

Same comment, this should be in Desktop.

[sadrul, 2011/10/12 22:59:58]

Done.

+                    OnWindowActivationChanged(this, false));
 }
 
 bool Window::IsActive() const {
   return aura::Desktop::GetInstance()->active_window() == this;
 }
 
 ToplevelWindowContainer* Window::AsToplevelWindowContainer() {
   return NULL;
 }
 
@@ skipping 121 matching lines @@
   if (!parent_->event_filter_.get())
     parent_->SetEventFilter(new EventFilter(parent_));
   return parent_->event_filter_->OnMouseEvent(this, event) ||
       delegate_->OnMouseEvent(event);
 }
 
 bool Window::OnKeyEvent(KeyEvent* event) {
   return IsVisible() && delegate_->OnKeyEvent(event);
 }
 
+void Window::AddObserver(WindowObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void Window::RemoveObserver(WindowObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 bool Window::HitTest(const gfx::Point& point) {
   gfx::Rect local_bounds(gfx::Point(), bounds().size());
   // TODO(beng): hittest masks.
   return local_bounds.Contains(point);
 }
 
 Window* Window::GetEventHandlerForPoint(const gfx::Point& point) {
   Windows::const_reverse_iterator i = children_.rbegin();
   for (; i != children_.rend(); ++i) {
     Window* child = *i;
@@ skipping 92 matching lines @@
 
 void Window::SetVisible(bool visible) {
   bool was_visible = IsVisible();
   layer_->SetVisible(visible);
   bool is_visible = IsVisible();
   if (was_visible != is_visible) {
     SchedulePaint();
     if (delegate_)
       delegate_->OnWindowVisibilityChanged(is_visible);
   }
+
+  FOR_EACH_OBSERVER(WindowObserver, observers_,
+                    OnWindowVisibilityChanged(this, visible));
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 bool Window::StopsEventPropagation() const {
   return stops_event_propagation_ && !children_.empty();
 }
 
 bool Window::UpdateShowStateAndRestoreBounds(
     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;
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura