Move the concept of Activation to the Shell.

ui/views/widget/native_widget_aura.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/views/widget/native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
+#include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/shadow_types.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
-#include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_observer.h"
 #include "ui/aura/window_types.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
@@ skipping 43 matching lines @@
   for (aura::Window::Windows::const_iterator it = children.begin();
        it != children.end(); ++it) {
     NotifyLocaleChangedInternal(*it);
   }
 }
 
 }  // namespace
 
 // Used when SetInactiveRenderingDisabled() is invoked to track when active
 // status changes in such a way that we should enable inactive rendering.
-class NativeWidgetAura::RootWindowObserverImpl
-    : public aura::RootWindowObserver {
+class NativeWidgetAura::ActiveWindowObserver : public aura::WindowObserver {
  public:
-  explicit RootWindowObserverImpl(NativeWidgetAura* host)
-      : host_(host) {
+  explicit ActiveWindowObserver(NativeWidgetAura* host) : host_(host) {
     aura::RootWindow::GetInstance()->AddObserver(this);
   }
-
-  virtual ~RootWindowObserverImpl() {
+  virtual ~ActiveWindowObserver() {
     aura::RootWindow::GetInstance()->RemoveObserver(this);
   }
 
-  // RootWindowObserver overrides:
-  virtual void OnActiveWindowChanged(aura::Window* active) OVERRIDE {
+  // Overridden from aura::WindowObserver:
+  virtual void OnWindowPropertyChanged(aura::Window* window,
+                                       const char* key,
+                                       void* old) OVERRIDE {
+    if (key != aura::kRootWindowActiveWindow)
+      return;
+    aura::Window* active =
+        aura::ActivationClient::GetActivationClient()->GetActiveWindow();
     if (!active || (active != host_->window_ &&
                     active->transient_parent() != host_->window_)) {
       host_->delegate_->EnableInactiveRendering();
     }
   }
 
  private:
   NativeWidgetAura* host_;
 
-  DISALLOW_COPY_AND_ASSIGN(RootWindowObserverImpl);
+  DISALLOW_COPY_AND_ASSIGN(ActiveWindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, public:
 
 NativeWidgetAura::NativeWidgetAura(internal::NativeWidgetDelegate* delegate)
     : delegate_(delegate),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
@@ skipping 61 matching lines @@
     tooltip_manager_.reset(new views::TooltipManagerAura(this));
   }
 
   drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
   if (params.type != Widget::InitParams::TYPE_TOOLTIP &&
       params.type != Widget::InitParams::TYPE_POPUP) {
     window_->SetProperty(aura::kDragDropDelegateKey,
         static_cast<aura::WindowDragDropDelegate*>(this));
   }
 
+  aura::ActivationDelegate::SetActivationDelegate(window_, this);
+
   if (window_type == Widget::InitParams::TYPE_MENU ||
       window_type == Widget::InitParams::TYPE_TOOLTIP)
     window_->SetIntProperty(aura::kShadowTypeKey,
                             aura::SHADOW_TYPE_RECTANGULAR);
 }
 
 NonClientFrameView* NativeWidgetAura::CreateNonClientFrameView() {
   return NULL;
 }
 
@@ skipping 224 matching lines @@
 }
 
 void NativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
   if (state == ui::SHOW_STATE_MAXIMIZED ||
       state == ui::SHOW_STATE_FULLSCREEN) {
     window_->SetIntProperty(aura::kShowStateKey, state);
   }
   window_->Show();
   if (can_activate_ && (state != ui::SHOW_STATE_INACTIVE ||
                         !GetWidget()->SetInitialFocus())) {
-    window_->Activate();
+    Activate();
   }
 }
 
 bool NativeWidgetAura::IsVisible() const {
   return window_->IsVisible();
 }
 
 void NativeWidgetAura::Activate() {
-  window_->Activate();
+  aura::ActivationClient::GetActivationClient()->ActivateWindow(window_);
 }
 
 void NativeWidgetAura::Deactivate() {
-  window_->Deactivate();
+  aura::ActivationClient::GetActivationClient()->DeactivateWindow(window_);
 }
 
 bool NativeWidgetAura::IsActive() const {
-  return aura::RootWindow::GetInstance()->active_window() == window_;
+  return aura::ActivationClient::GetActivationClient()->GetActiveWindow() ==
+      window_;
 }
 
 void NativeWidgetAura::SetAlwaysOnTop(bool on_top) {
   window_->SetIntProperty(aura::kAlwaysOnTopKey, on_top);
 }
 
 void NativeWidgetAura::Maximize() {
   window_->SetIntProperty(aura::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 }
 
@@ skipping 69 matching lines @@
 void NativeWidgetAura::FocusNativeView(gfx::NativeView native_view) {
   window_->GetFocusManager()->SetFocusedWindow(native_view);
 }
 
 gfx::Rect NativeWidgetAura::GetWorkAreaBoundsInScreen() const {
   return gfx::Screen::GetMonitorWorkAreaNearestWindow(GetNativeView());
 }
 
 void NativeWidgetAura::SetInactiveRenderingDisabled(bool value) {
   if (!value)
-    root_window_observer_.reset();
+    active_window_observer_.reset();
   else
-    root_window_observer_.reset(new RootWindowObserverImpl(this));
+    active_window_observer_.reset(new ActiveWindowObserver(this));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, views::InputMethodDelegate implementation:
 
 void NativeWidgetAura::DispatchKeyEventPostIME(const KeyEvent& key) {
   if (delegate_->OnKeyEvent(key))
     return;
   if (key.type() == ui::ET_KEY_PRESSED && GetWidget()->GetFocusManager())
     GetWidget()->GetFocusManager()->OnKeyEvent(key);
@@ skipping 74 matching lines @@
 ui::TouchStatus NativeWidgetAura::OnTouchEvent(aura::TouchEvent* event) {
   DCHECK(window_->IsVisible());
   TouchEvent touch_event(event);
   return delegate_->OnTouchEvent(touch_event);
 }
 
 bool NativeWidgetAura::CanFocus() {
   return true;
 }
 
-bool NativeWidgetAura::ShouldActivate(aura::Event* event) {
-  return can_activate_;
-}
-
-void NativeWidgetAura::OnActivated() {
-  delegate_->OnNativeWidgetActivationChanged(true);
-  if (IsVisible() && GetWidget()->non_client_view())
-    GetWidget()->non_client_view()->SchedulePaint();
-}
-
-void NativeWidgetAura::OnLostActive() {
-  delegate_->OnNativeWidgetActivationChanged(false);
-  if (IsVisible() && GetWidget()->non_client_view())
-    GetWidget()->non_client_view()->SchedulePaint();
-}
-
 void NativeWidgetAura::OnCaptureLost() {
   delegate_->OnMouseCaptureLost();
 }
 
 void NativeWidgetAura::OnPaint(gfx::Canvas* canvas) {
   delegate_->OnNativeWidgetPaint(canvas);
 }
 
 void NativeWidgetAura::OnWindowDestroying() {
   window_->SetProperty(aura::kDragDropDelegateKey, NULL);
   delegate_->OnNativeWidgetDestroying();
 
   // If the aura::Window is destroyed, we can no longer show tooltips.
   tooltip_manager_.reset();
 }
 
 void NativeWidgetAura::OnWindowDestroyed() {
   window_ = NULL;
   tooltip_manager_.reset();
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
 void NativeWidgetAura::OnWindowVisibilityChanged(bool visible) {
   delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetAura, aura::ActivationDelegate implementation:
+
+bool NativeWidgetAura::ShouldActivate(aura::Event* event) {
+  return can_activate_;
+}
+
+void NativeWidgetAura::OnActivated() {
+  delegate_->OnNativeWidgetActivationChanged(true);
+  if (IsVisible() && GetWidget()->non_client_view())
+    GetWidget()->non_client_view()->SchedulePaint();
+}
+
+void NativeWidgetAura::OnLostActive() {
+  delegate_->OnNativeWidgetActivationChanged(false);
+  if (IsVisible() && GetWidget()->non_client_view())
+    GetWidget()->non_client_view()->SchedulePaint();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetAura, aura::WindowDragDropDelegate implementation:
+
 void NativeWidgetAura::OnDragEntered(const aura::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   drop_helper_->OnDragOver(event.data(), event.location(),
       event.source_operations());
 }
 
 int NativeWidgetAura::OnDragUpdated(const aura::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   return drop_helper_->OnDragOver(event.data(), event.location(),
       event.source_operations());
@@ skipping 116 matching lines @@
   }
 }
 
 // static
 bool NativeWidgetPrivate::IsMouseButtonDown() {
   return aura::RootWindow::GetInstance()->IsMouseButtonDown();
 }
 
 }  // namespace internal
 }  // namespace views