Don't activate POPUP window

 Clicking keyboard (and any popup like menu) was activating the widget, which
 hides VirtualKeyboard as it was stealing focus from browser window.

 This also moves the code that handles window activation to WindowManaer.

 Removed desktop_window_root_view.cc|h as it's no longer necesssary.

BUG=none
TEST=VirtualKeyboard on views desktop should work.

Review URL: http://codereview.chromium.org/7740039

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@98472 0039d316-1c4b-4281-b951-d872f2087c98

views/desktop/desktop_window_manager.cc

@@ -10,6 +10,7 @@
 #include "ui/gfx/rect.h"
 #include "views/widget/widget.h"
 #include "views/widget/native_widget_private.h"
+#include "views/widget/native_widget_view.h"
 #include "views/widget/native_widget_views.h"
 #include "views/widget/widget_delegate.h"
 #if defined(OS_LINUX)
@@ -92,7 +93,8 @@ WindowController::~WindowController() {
 
 DesktopWindowManager::DesktopWindowManager(Widget* desktop)
     : desktop_(desktop),
-      mouse_capture_(NULL) {
+      mouse_capture_(NULL),
+      active_widget_(NULL) {
 }
 
 DesktopWindowManager::~DesktopWindowManager() {
@@ -154,8 +156,29 @@ bool DesktopWindowManager::HasMouseCapture(const views::Widget* widget) const {
   return widget && mouse_capture_ == widget;
 }
 
+bool DesktopWindowManager::HandleKeyEvent(
+    views::Widget* widget, const views::KeyEvent& event) {
+  return active_widget_ ?
+      static_cast<NativeWidgetViews*>(active_widget_->native_widget_private())
+          ->OnKeyEvent(event) : false;
+}
+
 bool DesktopWindowManager::HandleMouseEvent(
     views::Widget* widget, const views::MouseEvent& event) {
+  if (event.type() == ui::ET_MOUSE_PRESSED) {
+    View* target =
+        widget->GetRootView()->GetEventHandlerForPoint(event.location());
+
+    if (target->GetClassName() == internal::NativeWidgetView::kViewClassName) {
+      internal::NativeWidgetView* native_widget_view =
+          static_cast<internal::NativeWidgetView*>(target);
+      views::Widget* target_widget = native_widget_view->GetAssociatedWidget();
+      if (target_widget->CanActivate())
+        Activate(target_widget);
+    }
+  } else if (event.type() == ui::ET_MOUSEWHEEL && active_widget_) {
+    return active_widget_->OnMouseEvent(event);
+  }
 
   if (window_controller_.get()) {
     if (!window_controller_->OnMouseEvent(event)) {
@@ -174,9 +197,34 @@ bool DesktopWindowManager::HandleMouseEvent(
   return false;
 }
 
+void DesktopWindowManager::Register(Widget* widget) {
+  DCHECK(!widget->HasObserver(this));
+  widget->AddObserver(this);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowManager, private:
 
+void DesktopWindowManager::OnWidgetClosing(Widget* widget) {
+  if (active_widget_ && active_widget_ == widget)
+    active_widget_ = NULL;
+}
+
+void DesktopWindowManager::OnWidgetVisibilityChanged(Widget* widget,
+                                                     bool visible) {
+}
+
+void DesktopWindowManager::OnWidgetActivationChanged(Widget* widget,
+                                                     bool active) {
+  if (active) {
+    if (active_widget_)
+      active_widget_->Deactivate();
+    active_widget_ = widget;
+  } else if (widget == active_widget_) {
+    active_widget_ = NULL;
+  }
+}
+
 void DesktopWindowManager::SetMouseCapture() {
   return desktop_->native_widget_private()->SetMouseCapture();
 }
@@ -189,5 +237,16 @@ bool DesktopWindowManager::HasMouseCapture() const {
   return desktop_->native_widget_private()->HasMouseCapture();
 }
 
+void DesktopWindowManager::Activate(Widget* widget) {
+  if (widget && widget->IsActive())
+    return;
+
+  if (widget) {
+    if (!widget->HasObserver(this))
+      widget->AddObserver(this);
+    widget->Activate();
+  }
+}
+
 }  // namespace desktop
 }  // namespace views

views/desktop/desktop_window_manager.h

@@ -7,6 +7,7 @@
 
 #include "base/compiler_specific.h"
 #include "base/scoped_ptr.h"
+#include "views/widget/widget.h"
 #include "views/widget/window_manager.h"
 
 namespace gfx {
@@ -14,7 +15,6 @@ class Point;
 }
 
 namespace views {
-class Widget;
 
 namespace desktop {
 class WindowController;
@@ -22,8 +22,9 @@ class WindowController;
 // A tentative window manager for views destktop until we have *right*
 // implementation based on aura/layer API. This is minimum
 // implmenetation and complicated actio like moving transformed window
-// doesn't work.  TODO(oshima): move active widget to WindowManager.
-class DesktopWindowManager : public views::WindowManager {
+// doesn't work.
+class DesktopWindowManager : public views::WindowManager,
+                             public Widget::Observer {
  public:
   DesktopWindowManager(Widget* desktop);
   virtual ~DesktopWindowManager();
@@ -37,16 +38,28 @@ class DesktopWindowManager : public views::WindowManager {
   virtual bool SetMouseCapture(views::Widget* widget) OVERRIDE;
   virtual bool ReleaseMouseCapture(views::Widget* widget) OVERRIDE;
   virtual bool HasMouseCapture(const views::Widget* widget) const OVERRIDE;
+  virtual bool HandleKeyEvent(views::Widget* widget,
+                              const views::KeyEvent& event) OVERRIDE;
   virtual bool HandleMouseEvent(views::Widget* widget,
                                 const views::MouseEvent& event) OVERRIDE;
 
+  virtual void Register(Widget* widget) OVERRIDE;
+
  private:
+  // Overridden from Widget::Observer.
+  virtual void OnWidgetClosing(Widget* widget) OVERRIDE;
+  virtual void OnWidgetVisibilityChanged(Widget* widget, bool visible) OVERRIDE;
+  virtual void OnWidgetActivationChanged(Widget* widget, bool active) OVERRIDE;
+
   void SetMouseCapture();
   void ReleaseMouseCapture();
   bool HasMouseCapture() const;
 
+  void Activate(Widget* widget);
+
   views::Widget* desktop_;
   views::Widget* mouse_capture_;
+  views::Widget* active_widget_;
   scoped_ptr<WindowController> window_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopWindowManager);

views/desktop/desktop_window_root_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_root_view.h"
-
-#include "views/desktop/desktop_window_view.h"
-#include "views/widget/native_widget_view.h"
-#include "views/widget/widget.h"
-
-namespace views {
-namespace desktop {
-
-////////////////////////////////////////////////////////////////////////////////
-// DesktopWindowRootView, public:
-
-DesktopWindowRootView::DesktopWindowRootView(
-    DesktopWindowView* desktop_window_view,
-    Widget* window)
-    : internal::RootView(window),
-      desktop_window_view_(desktop_window_view) {
-}
-
-DesktopWindowRootView::~DesktopWindowRootView() {
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// DesktopWindowRootView, internal::RootView overrides:
-
-bool DesktopWindowRootView::OnMousePressed(const MouseEvent& event) {
-  ActivateWidgetAtLocation(event.location());
-  return RootView::OnMousePressed(event);
-}
-
-ui::TouchStatus DesktopWindowRootView::OnTouchEvent(const TouchEvent& event) {
-  ActivateWidgetAtLocation(event.location());
-  return RootView::OnTouchEvent(event);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// DesktopWindowRootView, private
-
-void DesktopWindowRootView::ActivateWidgetAtLocation(const gfx::Point& point) {
-  View* target = GetEventHandlerForPoint(point);
-  if (target->GetClassName() == internal::NativeWidgetView::kViewClassName) {
-    internal::NativeWidgetView* native_widget_view =
-        static_cast<internal::NativeWidgetView*>(target);
-    desktop_window_view_->ActivateWidget(
-        native_widget_view->GetAssociatedWidget());
-  } else {
-    desktop_window_view_->ActivateWidget(NULL);
-  }
-}
-
-}  // namespace desktop
-}  // namespace views

views/desktop/desktop_window_root_view.h

-// 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.
-
-#ifndef VIEWS_DESKTOP_DESKTOP_WINDOW_ROOT_VIEW_H_
-#define VIEWS_DESKTOP_DESKTOP_WINDOW_ROOT_VIEW_H_
-
-#include "views/widget/root_view.h"
-
-namespace views {
-namespace desktop {
-
-class DesktopWindowView;
-
-class DesktopWindowRootView : public internal::RootView {
- public:
-  DesktopWindowRootView(DesktopWindowView* desktop_window_view, Widget* window);
-  virtual ~DesktopWindowRootView();
-
- private:
-  // Overridden from RootView:
-  virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE;
-  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
-
-  // Activates the widget at the specified location and deactivates the
-  // currently selected widget.
-  void ActivateWidgetAtLocation(const gfx::Point& point);
-
-  DesktopWindowView* desktop_window_view_;
-
-  DISALLOW_COPY_AND_ASSIGN(DesktopWindowRootView);
-};
-
-}  // namespace desktop
-}  // namespace views
-
-#endif  // VIEWS_DESKTOP_DESKTOP_WINDOW_ROOT_VIEW_H_

views/desktop/desktop_window_view.cc

@@ -7,7 +7,6 @@
 #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"
@@ -39,23 +38,11 @@ class DesktopWindow : public Widget {
 
  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);
   }
@@ -111,8 +98,7 @@ class TestWindowContentView : public WidgetDelegateView {
 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:
@@ -156,18 +142,6 @@ void DesktopWindowView::CreateDesktopWindow(DesktopType type) {
   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,
@@ -196,15 +170,11 @@ 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);
   }
 }
 
@@ -263,27 +233,5 @@ NonClientFrameView* DesktopWindowView::CreateNonClientFrameView() {
   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

views/desktop/desktop_window_view.h

@@ -6,16 +6,15 @@
 #define VIEWS_DESKTOP_DESKTOP_WINDOW_H_
 
 #include "views/view.h"
-#include "views/widget/widget.h"
 #include "views/widget/widget_delegate.h"
 
 namespace views {
 class NativeWidgetViews;
+class Widget;
 
 namespace desktop {
 
-class DesktopWindowView : public WidgetDelegateView,
-                          public Widget::Observer {
+class DesktopWindowView : public WidgetDelegateView {
  public:
   // The look and feel will be slightly different for different kinds of
   // desktop.
@@ -32,12 +31,6 @@ class DesktopWindowView : public WidgetDelegateView,
 
   static void CreateDesktopWindow(DesktopType type);
 
-  // Changes activation to the specified Widget. The currently active Widget
-  // is de-activated.
-  void ActivateWidget(Widget* widget);
-
-  NativeWidgetViews* active_native_widget() { return active_native_widget_; }
-
   void CreateTestWindow(const std::wstring& title,
                         SkColor color,
                         gfx::Rect initial_bounds,
@@ -64,12 +57,6 @@ class DesktopWindowView : public WidgetDelegateView,
   virtual View* GetContentsView() OVERRIDE;
   virtual NonClientFrameView* CreateNonClientFrameView() OVERRIDE;
 
-  // Overridden from Widget::Observer.
-  virtual void OnWidgetClosing(Widget* widget) OVERRIDE;
-  virtual void OnWidgetVisibilityChanged(Widget* widget, bool visible) OVERRIDE;
-  virtual void OnWidgetActivationChanged(Widget* widget, bool active) OVERRIDE;
-
-  NativeWidgetViews* active_native_widget_;
   DesktopType type_;
   Widget* widget_;
 

views/views.gyp

@@ -718,8 +718,6 @@
         'desktop/desktop_background.h',
         'desktop/desktop_window_manager.cc',
         'desktop/desktop_window_manager.h',
-        'desktop/desktop_window_root_view.cc',
-        'desktop/desktop_window_root_view.h',
         'desktop/desktop_window_view.cc',
         'desktop/desktop_window_view.h',
       ],

views/widget/native_widget_views.h

@@ -11,6 +11,7 @@
 #include "base/message_loop.h"
 #include "ui/gfx/transform.h"
 #include "views/widget/native_widget_private.h"
+#include "views/widget/widget.h"
 
 namespace views {
 namespace desktop {
@@ -43,7 +44,7 @@ class VIEWS_EXPORT NativeWidgetViews : public internal::NativeWidgetPrivate {
     delete_native_view_ = delete_native_view;
   }
 
-  internal::NativeWidgetDelegate* delegate() { return delegate_; }
+  internal::NativeWidgetDelegate* delegate() const { return delegate_; }
 
  protected:
   friend class NativeWidgetView;

views/widget/widget.cc

@@ -66,7 +66,10 @@ class ScopedEvent {
 // WidgetDelegate is supplied.
 class DefaultWidgetDelegate : public WidgetDelegate {
  public:
-  explicit DefaultWidgetDelegate(Widget* widget) : widget_(widget) {}
+  DefaultWidgetDelegate(Widget* widget, const Widget::InitParams& params)
+      : widget_(widget),
+        can_activate_(params.type != Widget::InitParams::TYPE_POPUP) {
+  }
   virtual ~DefaultWidgetDelegate() {}
 
   // Overridden from WidgetDelegate:
@@ -80,8 +83,13 @@ class DefaultWidgetDelegate : public WidgetDelegate {
     return widget_;
   }
 
+  virtual bool CanActivate() const {
+    return can_activate_;
+  }
+
  private:
   Widget* widget_;
+  bool can_activate_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultWidgetDelegate);
 };
@@ -282,8 +290,8 @@ void Widget::Init(const InitParams& params) {
       (!params.child &&
        params.type != InitParams::TYPE_CONTROL &&
        params.type != InitParams::TYPE_TOOLTIP);
-  widget_delegate_ =
-      params.delegate ? params.delegate : new DefaultWidgetDelegate(this);
+  widget_delegate_ = params.delegate ?
+      params.delegate : new DefaultWidgetDelegate(this, params);
   ownership_ = params.ownership;
   native_widget_ = params.native_widget ?
       params.native_widget->AsNativeWidgetPrivate() :

views/widget/window_manager.cc

@@ -48,6 +48,11 @@ class NullWindowManager : public views::WindowManager {
     return mouse_capture_ == widget;
   }
 
+  virtual bool HandleKeyEvent(views::Widget* widget,
+                              const views::KeyEvent& event) OVERRIDE {
+    return false;
+  }
+
   virtual bool HandleMouseEvent(views::Widget* widget,
                                 const views::MouseEvent& event) OVERRIDE {
     if (mouse_capture_) {
@@ -59,6 +64,8 @@ class NullWindowManager : public views::WindowManager {
     return false;
   }
 
+  void Register(views::Widget* widget) OVERRIDE {}
+
  private:
   views::Widget* mouse_capture_;
 };

views/widget/window_manager.h

@@ -14,6 +14,7 @@ class Point;
 }
 
 namespace views {
+class KeyEvent;
 class MouseEvent;
 class Widget;
 
@@ -45,10 +46,17 @@ class VIEWS_EXPORT WindowManager {
   // Checks if the |widget| has mouse capture.
   virtual bool HasMouseCapture(const Widget* widget) const = 0;
 
+  // WindowManager handles mouse event first. It may reisze/move window,
+  // or send the event to widget that has mouse capture.
+  virtual bool HandleKeyEvent(Widget* widget, const KeyEvent& event) = 0;
+
   // WindowManager handles mouse event first. It may reisze/move window,
   // or send the event to widget that has mouse capture.
   virtual bool HandleMouseEvent(Widget* widget, const MouseEvent& event) = 0;
 
+  // Register widget to the window manager.
+  virtual void Register(Widget* widget) = 0;
+
   // Installs window manager.
   static void Install(WindowManager* wm);