Revert 114095 - 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"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "ui/aura/aura_switches.h"
-#include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/tooltip_client.h"
 #include "ui/aura/client/window_drag_drop_delegate.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/screen_aura.h"
@@ skipping 35 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::AddRootWindowObserver(RootWindowObserver* observer) {
+void RootWindow::AddObserver(RootWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void RootWindow::RemoveRootWindowObserver(RootWindowObserver* observer) {
+void RootWindow::RemoveObserver(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 50 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;
   // An observer may have been added by an animation on the RootWindow.
   layer()->GetAnimator()->RemoveObserver(this);
 #ifdef USE_WEBKIT_COMPOSITOR
   if (!ui::Compositor::compositor_factory())
     ui::CompositorCC::Terminate();
 #endif
   if (instance_ == this)
@@ skipping 116 matching lines @@
 
 void RootWindow::OnLayerAnimationScheduled(
     const ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::OnLayerAnimationAborted(
     const ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::SetFocusedWindow(Window* focused_window) {
-  if (focused_window == focused_window_)
-    return;
-  if (focused_window && !focused_window->CanFocus())
-    return;
-  // The NULL-check of |focused)window| is essential here before asking the
-  // activation client, since it is valid to clear the focus by calling
-  // SetFocusedWindow() to NULL.
-  if (focused_window && ActivationClient::GetActivationClient() &&
-      !ActivationClient::GetActivationClient()->CanFocusWindow(
-          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