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"

[sky, 2011/12/09 23:11:23]

Can this be removed now?

 #include "ui/aura/window.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"
@@ skipping 28 matching lines @@
     case Widget::InitParams::TYPE_MENU:
       return aura::WINDOW_TYPE_MENU;
     case Widget::InitParams::TYPE_TOOLTIP:
       return aura::WINDOW_TYPE_TOOLTIP;
     default:
       NOTREACHED() << "Unhandled widget type " << type;
       return aura::WINDOW_TYPE_UNKNOWN;
   }
 }
 
+aura::ActivationClient* GetActivationClient() {
+  return reinterpret_cast<aura::ActivationClient*>(
+      aura::RootWindow::GetInstance()->GetProperty(
+          aura::kRootWindowActivationClient));
+}
 }  // 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::RootWindowObserverImpl : public aura::WindowObserver {
  public:
-  explicit RootWindowObserverImpl(NativeWidgetAura* host)
-      : host_(host) {
+  explicit RootWindowObserverImpl(NativeWidgetAura* host) : host_(host) {
     aura::RootWindow::GetInstance()->AddObserver(this);
   }
-
   virtual ~RootWindowObserverImpl() {
     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 = GetActivationClient()->GetActiveWindow();
     if (!active || (active != host_->window_ &&
                     active->transient_parent() != host_->window_)) {
       host_->delegate_->EnableInactiveRendering();
     }
   }
 
  private:
   NativeWidgetAura* host_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowObserverImpl);
@@ skipping 71 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));
   }
 
+  window_->SetProperty(aura::kActivationDelegateKey,
+                       static_cast<aura::ActivationDelegate*>(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();
+  GetActivationClient()->ActivateWindow(window_);
 }
 
 void NativeWidgetAura::Deactivate() {
-  window_->Deactivate();
+  GetActivationClient()->DeactivateWindow(window_);
 }
 
 bool NativeWidgetAura::IsActive() const {
-  return aura::RootWindow::GetInstance()->active_window() == window_;
+  return 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 166 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 117 matching lines @@
   }
 }
 
 // static
 bool NativeWidgetPrivate::IsMouseButtonDown() {
   return aura::RootWindow::GetInstance()->IsMouseButtonDown();
 }
 
 }  // namespace internal
 }  // namespace views