Don't activate POPUP window

views/desktop/desktop_window_view.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 "views/desktop/desktop_window_view.h"
 
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/transform.h"
 #include "views/desktop/desktop_background.h"
-#include "views/desktop/desktop_window_root_view.h"
 #include "views/desktop/desktop_window_manager.h"
 #include "views/layer_property_setter.h"
 #include "views/widget/native_widget_view.h"
 #include "views/widget/native_widget_views.h"
 #include "views/widget/widget.h"
 #include "views/window/native_frame_view.h"
 
 #if defined(USE_AURA)
 #include "views/widget/native_widget_aura.h"
 #elif defined(OS_WIN)
 #include "views/widget/native_widget_win.h"
 #elif defined(TOOLKIT_USES_GTK)
 #include "views/widget/native_widget_gtk.h"
 #endif
 
 namespace views {
 namespace desktop {
 
 // The Widget that hosts the DesktopWindowView. Subclasses Widget to override
 // CreateRootView() so that the DesktopWindowRootView can be supplied instead
 // for custom event filtering.
 class DesktopWindow : public Widget {
  public:
   explicit DesktopWindow(DesktopWindowView* desktop_window_view)
       : desktop_window_view_(desktop_window_view) {}
   virtual ~DesktopWindow() {}
 
  private:
   // Overridden from Widget:
-  virtual internal::RootView* CreateRootView() OVERRIDE {
-    return new DesktopWindowRootView(desktop_window_view_, this);
-  }
-
   virtual bool OnKeyEvent(const KeyEvent& event) OVERRIDE {
-    NativeWidgetViews* native_widget =
-        desktop_window_view_->active_native_widget();
-    return native_widget ? native_widget->OnKeyEvent(event) : false;
+    return WindowManager::Get()->HandleKeyEvent(this, event);
   }
 
   virtual bool OnMouseEvent(const MouseEvent& event) {
-    if (event.type() == ui::ET_MOUSEWHEEL) {
-      NativeWidgetViews* native_widget =
-          desktop_window_view_->active_native_widget();
-      if (native_widget)
-        return native_widget->delegate()->OnMouseEvent(event);
-    }
     return WindowManager::Get()->HandleMouseEvent(this, event) ||
         Widget::OnMouseEvent(event);
   }
 
   DesktopWindowView* desktop_window_view_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopWindow);
 };
 
 class TestWindowContentView : public WidgetDelegateView {
@@ skipping 35 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestWindowContentView);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowView, public:
 
 // static
 DesktopWindowView* DesktopWindowView::desktop_window_view = NULL;
 
 DesktopWindowView::DesktopWindowView(DesktopType type)
-    : active_native_widget_(NULL),
-      type_(type) {
+    : type_(type) {
   switch (type_) {
     case DESKTOP_DEFAULT:
     case DESKTOP_NETBOOK:
       set_background(new DesktopBackground);
       break;
     case DESKTOP_OTHER:
       set_background(Background::CreateStandardPanelBackground());
       break;
   }
 }
@@ skipping 21 matching lines @@
   params.native_widget = new views::NativeWidgetWin(window);
 #elif defined(TOOLKIT_USES_GTK)
   params.native_widget = new views::NativeWidgetGtk(window);
   params.maximize = true;
 #endif
   params.bounds = gfx::Rect(20, 20, 1920, 1200);
   window->Init(params);
   window->Show();
 }
 
-void DesktopWindowView::ActivateWidget(Widget* widget) {
-  if (widget && widget->IsActive())
-    return;
-
-  if (widget) {
-    if (!widget->HasObserver(this))
-      widget->AddObserver(this);
-    widget->Activate();
-  }
-}
-
-
 void DesktopWindowView::CreateTestWindow(const std::wstring& title,
                                          SkColor color,
                                          gfx::Rect initial_bounds,
                                          bool rotate) {
   views::Widget* window = views::Widget::CreateWindowWithBounds(
       new TestWindowContentView(title, color),
       initial_bounds);
   window->Show();
 
   if (rotate) {
     ui::Transform transform;
     transform.SetRotate(90.0f);
     transform.SetTranslateX(window->GetWindowScreenBounds().width());
     static_cast<NativeWidgetViews*>(window->native_widget())->GetView()->
         SetTransform(transform);
   }
   static_cast<NativeWidgetViews*>(window->native_widget())->GetView()->
       SetLayerPropertySetter(LayerPropertySetter::CreateAnimatingSetter());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowView, View overrides:
 
 void DesktopWindowView::Layout() {
 }
 
 void DesktopWindowView::ViewHierarchyChanged(
     bool is_add, View* parent, View* child) {
-  if (!is_add &&
-      active_native_widget_ &&
-      active_native_widget_->GetView() == child) {
-    active_native_widget_ = NULL;
-  } else if (is_add &&
-      child->GetClassName() == internal::NativeWidgetView::kViewClassName) {
-    internal::NativeWidgetView* native_widget_view =
-        static_cast<internal::NativeWidgetView*>(child);
-    native_widget_view->GetAssociatedWidget()->AddObserver(this);
+  if (child->GetClassName() == internal::NativeWidgetView::kViewClassName) {
+    Widget* widget =
+        static_cast<internal::NativeWidgetView*>(child)->GetAssociatedWidget();
+    if (is_add)
+      WindowManager::Get()->Register(widget);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowView, WidgetDelegate implementation:
 
 Widget* DesktopWindowView::GetWidget() {
   return widget_;
 }
 
@@ skipping 38 matching lines @@
     case DESKTOP_DEFAULT:
     case DESKTOP_NETBOOK:
       return NULL;
 
     case DESKTOP_OTHER:
       return new NativeFrameView(widget_);
   }
   return NULL;
 }
 
-void DesktopWindowView::OnWidgetClosing(Widget* widget) {
-  if (active_native_widget_ && static_cast<internal::NativeWidgetPrivate*>
-      (active_native_widget_)->GetWidget() == widget)
-    active_native_widget_ = NULL;
-}
-
-void DesktopWindowView::OnWidgetVisibilityChanged(Widget* widget,
-                                                  bool visible) {
-}
-
-void DesktopWindowView::OnWidgetActivationChanged(Widget* widget,
-                                                  bool active) {
-  if (active) {
-    if (active_native_widget_)
-      active_native_widget_->GetWidget()->Deactivate();
-    active_native_widget_ =
-        static_cast<NativeWidgetViews*>(widget->native_widget());
-  } else if (widget == active_native_widget_->GetWidget()) {
-    active_native_widget_ = NULL;
-  }
-}
-
 }  // namespace desktop
 }  // namespace views