Move the concept of Activation to the Shell.

ui/aura/root_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/root_window.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 48 matching lines @@
   explicit DefaultStackingClient(RootWindow* root_window)
       : root_window_(root_window) {}
   virtual ~DefaultStackingClient() {}
 
  private:
 
   // Overridden from StackingClient:
   virtual void AddChildToDefaultParent(Window* window) OVERRIDE {
     root_window_->AddChild(window);
   }
-  virtual bool CanActivateWindow(Window* window) const OVERRIDE {
-    return window->parent() == root_window_;
-  }
-  virtual Window* GetTopmostWindowToActivate(Window* ignore) const OVERRIDE {
-    Window::Windows::const_reverse_iterator i;
-    for (i = root_window_->children().rbegin();
-         i != root_window_->children().rend();
-         ++i) {
-      if (*i == ignore)
-        continue;
-      return *i;
-    }
-    return NULL;
-  }
 
   RootWindow* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultStackingClient);
 };
 
 typedef std::vector<EventFilter*> EventFilters;
 
 void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
   Window* window = target->parent();
@@ skipping 144 matching lines @@
   SetBounds(gfx::Rect(bounds.size()));
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnRootWindowResized(bounds.size()));
 }
 
 void RootWindow::OnNativeScreenResized(const gfx::Size& size) {
   if (use_fullscreen_host_window_)
     SetHostSize(size);
 }
 
-void RootWindow::SetActiveWindow(Window* window, Window* to_focus) {
-  if (!window)
-    return;
-  // The stacking client may impose rules on what window configurations can be
-  // activated or deactivated.
-  if (!stacking_client_->CanActivateWindow(window))
-    return;
-  // The window may not be activate-able.
-  if (!window->CanActivate())
-    return;
-  // Nothing may actually have changed.
-  if (active_window_ == window)
-    return;
-
-  Window* old_active = active_window_;
-  active_window_ = window;
-  // Invoke OnLostActive after we've changed the active window. That way if the
-  // delegate queries for active state it doesn't think the window is still
-  // active.
-  if (old_active && old_active->delegate())
-    old_active->delegate()->OnLostActive();
-  if (active_window_) {
-    active_window_->parent()->StackChildAtTop(active_window_);
-    if (active_window_->delegate())
-      active_window_->delegate()->OnActivated();
-    active_window_->GetFocusManager()->SetFocusedWindow(
-        to_focus ? to_focus : active_window_);
-  }
-  FOR_EACH_OBSERVER(RootWindowObserver, observers_,
-                    OnActiveWindowChanged(active_window_));
-}
-
-void RootWindow::ActivateTopmostWindow() {
-  SetActiveWindow(stacking_client_->GetTopmostWindowToActivate(NULL), NULL);
-}
-
-void RootWindow::Deactivate(Window* window) {
-  // The stacking client may impose rules on what window configurations can be
-  // activated or deactivated.
-  if (!window || !stacking_client_->CanActivateWindow(window))
-    return;
-  if (active_window_ != window)
-    return;
-
-  Window* to_activate = stacking_client_->GetTopmostWindowToActivate(window);
-  if (to_activate)
-    SetActiveWindow(to_activate, NULL);
-}
-
 void RootWindow::WindowInitialized(Window* window) {
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnWindowInitialized(window));
 }
 
 void RootWindow::WindowDestroying(Window* window) {
   // Update the focused window state if the window was focused.
   if (focused_window_ == window)
     SetFocusedWindow(NULL);
 
   // When a window is being destroyed it's likely that the WindowDelegate won't
   // want events, so we reset the mouse_pressed_handler_ and capture_window_ and
   // don't sent it release/capture lost events.
   if (mouse_pressed_handler_ == window)
     mouse_pressed_handler_ = NULL;
   if (mouse_moved_handler_ == window)
     mouse_moved_handler_ = NULL;
   if (capture_window_ == window)
     capture_window_ = NULL;
   if (touch_event_handler_ == window)
     touch_event_handler_ = NULL;
-
-  if (in_destructor_ || window != active_window_)
-    return;
-
-  // Reset active_window_ before invoking SetActiveWindow so that we don't
-  // attempt to notify it while running its destructor.
-  active_window_ = NULL;
-  SetActiveWindow(stacking_client_->GetTopmostWindowToActivate(window), NULL);
 }
 
 MessageLoop::Dispatcher* RootWindow::GetDispatcher() {
   return host_.get();
 }
 
-void RootWindow::AddObserver(RootWindowObserver* observer) {
+void RootWindow::AddRootWindowObserver(RootWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void RootWindow::RemoveObserver(RootWindowObserver* observer) {
+void RootWindow::RemoveRootWindowObserver(RootWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool RootWindow::IsMouseButtonDown() const {
   return mouse_button_flags_ != 0;
 }
 
 void RootWindow::PostNativeEvent(const base::NativeEvent& native_event) {
   host_->PostNativeEvent(native_event);
 }
@@ skipping 49 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 RootWindow::RootWindow()
     : Window(NULL),
       host_(aura::RootWindowHost::Create(GetInitialHostWindowBounds())),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           stacking_client_(new DefaultStackingClient(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
-      active_window_(NULL),
       mouse_button_flags_(0),
       last_cursor_(kCursorNull),
-      in_destructor_(false),
       screen_(new ScreenAura),
       capture_window_(NULL),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       focused_window_(NULL),
       touch_event_handler_(NULL) {
   SetName("RootWindow");
   gfx::Screen::SetInstance(screen_);
   host_->SetRootWindow(this);
   last_mouse_location_ = host_->QueryMouseLocation();
 
   if (ui::Compositor::compositor_factory()) {
     compositor_ = (*ui::Compositor::compositor_factory())(this);
   } else {
 #ifdef USE_WEBKIT_COMPOSITOR
     ui::CompositorCC::Initialize(false);
 #endif
     compositor_ = ui::Compositor::Create(this, host_->GetAcceleratedWidget(),
                                          host_->GetSize());
   }
   DCHECK(compositor_.get());
 }
 
 RootWindow::~RootWindow() {
-  in_destructor_ = true;
   // Make sure to destroy the compositor before terminating so that state is
   // cleared and we don't hit asserts.
   compositor_ = NULL;
 #ifdef USE_WEBKIT_COMPOSITOR
   if (!ui::Compositor::compositor_factory())
     ui::CompositorCC::Terminate();
 #endif
   if (instance_ == this)
     instance_ = NULL;
 }
@@ skipping 123 matching lines @@
 void RootWindow::SetFocusedWindow(Window* focused_window) {
   if (focused_window == focused_window_ ||
       (focused_window && !focused_window->CanFocus())) {
     return;
   }
   if (focused_window_ && focused_window_->delegate())
     focused_window_->delegate()->OnBlur();
   focused_window_ = focused_window;
   if (focused_window_ && focused_window_->delegate())
     focused_window_->delegate()->OnFocus();
+  if (focused_window_) {
+    FOR_EACH_OBSERVER(RootWindowObserver, observers_,
+                      OnWindowFocused(focused_window_));
+  }
 }
 
 Window* RootWindow::GetFocusedWindow() {
   return focused_window_;
 }
 
 bool RootWindow::IsFocusedWindow(const Window* window) const {
   return focused_window_ == window;
 }
 
@@ skipping 18 matching lines @@
       base::StringToInt(parts[1], &parsed_height) && parsed_height > 0) {
     bounds.set_size(gfx::Size(parsed_width, parsed_height));
   } else if (use_fullscreen_host_window_) {
     bounds = gfx::Rect(RootWindowHost::GetNativeScreenSize());
   }
 
   return bounds;
 }
 
 }  // namespace aura