Prevent mouse from getting stuck on second display in login

ash/root_window_controller.cc

 // Copyright (c) 2012 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 "ash/root_window_controller.h"
 
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 30 matching lines @@
 #include "ash/wm/toplevel_window_event_handler.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/command_line.h"
 #include "base/time/time.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/tooltip_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
+#include "ui/base/hit_test.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/screen.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/corewm/visibility_controller.h"
 #include "ui/views/view_model.h"
 #include "ui/views/view_model_utils.h"
 
 namespace ash {
@@ skipping 95 matching lines @@
 void SetUsesScreenCoordinates(aura::Window* container) {
   container->SetProperty(internal::kUsesScreenCoordinatesKey, true);
 }
 
 // Mark the container window so that a widget added to this container will
 // say in the same root window regardless of the bounds specified.
 void DescendantShouldStayInSameRootWindow(aura::Window* container) {
   container->SetProperty(internal::kStayInSameRootWindowKey, true);
 }
 
+// A window delegate which does nothing. Used to create a window that
+// is a event target, but do nothing.
+class EmptyWindowDelegate : public aura::WindowDelegate {
+ public:
+  EmptyWindowDelegate() {}
+  virtual ~EmptyWindowDelegate() {}
+
+  // aura::WindowDelegate overrides:
+  virtual gfx::Size GetMinimumSize() const OVERRIDE {
+    return gfx::Size();
+  }
+  virtual gfx::Size GetMaximumSize() const OVERRIDE {
+    return gfx::Size();
+  }
+  virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
+                               const gfx::Rect& new_bounds) OVERRIDE {
+  }
+  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
+    return gfx::kNullCursor;
+  }
+  virtual int GetNonClientComponent(
+      const gfx::Point& point) const OVERRIDE {
+    return HTNOWHERE;
+  }
+  virtual bool ShouldDescendIntoChildForEventHandling(
+      aura::Window* child,
+      const gfx::Point& location) OVERRIDE {
+    return false;
+  }
+  virtual bool CanFocus() OVERRIDE {
+    return false;
+  }
+  virtual void OnCaptureLost() OVERRIDE {
+  }
+  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
+  }
+  virtual void OnDeviceScaleFactorChanged(
+      float device_scale_factor) OVERRIDE {
+  }
+  virtual void OnWindowDestroying() OVERRIDE {}
+  virtual void OnWindowDestroyed() OVERRIDE {}
+  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {
+  }
+  virtual bool HasHitTestMask() const OVERRIDE {
+    return false;
+  }
+  virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {}
+  virtual scoped_refptr<ui::Texture> CopyTexture() OVERRIDE {
+    NOTREACHED();
+    return scoped_refptr<ui::Texture>();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EmptyWindowDelegate);
+};
+
 }  // namespace
 
 namespace internal {
 
 RootWindowController::RootWindowController(aura::RootWindow* root_window)
     : root_window_(root_window),
       root_window_layout_(NULL),
       docked_layout_manager_(NULL),
       panel_layout_manager_(NULL),
       touch_hud_debug_(NULL),
@@ skipping 117 matching lines @@
     panel_layout_manager_->SetLauncher(shelf_->launcher());
   if (docked_layout_manager_) {
     docked_layout_manager_->SetLauncher(shelf_->launcher());
     if (shelf_->shelf_layout_manager())
       docked_layout_manager_->AddObserver(shelf_->shelf_layout_manager());
   }
 }
 
 void RootWindowController::UpdateAfterLoginStatusChange(
     user::LoginStatus status) {
+  if (status != user::LOGGED_IN_NONE)
+    mouse_event_target_.reset();
   if (shelf_->status_area_widget())
     shelf_->status_area_widget()->UpdateAfterLoginStatusChange(status);
 }
 
 void RootWindowController::HandleInitialDesktopBackgroundAnimationStarted() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshAnimateFromBootSplashScreen) &&
       boot_splash_screen_.get()) {
     // Make the splash screen fade out so it doesn't obscure the desktop
     // wallpaper's brightness/grayscale animation.
@@ skipping 18 matching lines @@
     // |desktop_widget_| should be the same animating widget we try to move
     // to |kDesktopController|. Otherwise, we may close |desktop_widget_|
     // before move it to |kDesktopController|.
     DCHECK_EQ(controller->widget(), widget);
     // Release the old controller and close its background widget.
     SetWallpaperController(controller);
   }
 }
 
 void RootWindowController::CloseChildWindows() {
+  mouse_event_target_.reset();
+
   if (!shelf_.get())
     return;
   // panel_layout_manager_ needs to be shut down before windows are destroyed.
   if (panel_layout_manager_) {
     panel_layout_manager_->Shutdown();
     panel_layout_manager_ = NULL;
   }
   // docked_layout_manager_ needs to be shut down before windows are destroyed.
   if (docked_layout_manager_) {
     if (shelf_->shelf_layout_manager())
@@ skipping 124 matching lines @@
 
   DCHECK(!shelf_.get());
   aura::Window* shelf_container =
       GetContainer(internal::kShellWindowId_ShelfContainer);
   // TODO(harrym): Remove when status area is view.
   aura::Window* status_container =
       GetContainer(internal::kShellWindowId_StatusContainer);
   shelf_.reset(new ShelfWidget(
       shelf_container, status_container, workspace_controller()));
 
+  if (!Shell::GetInstance()->session_state_delegate()->
+      IsActiveUserSessionStarted()) {
+    // This window exists only to be a event target on login screen.
+    // It does not have to handle events, nor be visible.
+    mouse_event_target_.reset(new aura::Window(new EmptyWindowDelegate));
+    mouse_event_target_->Init(ui::LAYER_NOT_DRAWN);
+
+    aura::Window* lock_background_container =
+        GetContainer(internal::kShellWindowId_LockScreenBackgroundContainer);
+    lock_background_container->AddChild(mouse_event_target_.get());
+    mouse_event_target_->Show();
+  }
+
   // Create Docked windows layout manager
   aura::Window* docked_container = GetContainer(
       internal::kShellWindowId_DockedContainer);
   docked_layout_manager_ =
       new internal::DockedWindowLayoutManager(docked_container);
   docked_container_handler_.reset(
       new ToplevelWindowEventHandler(docked_container));
   docked_container->SetLayoutManager(docked_layout_manager_);
 
   // Create Panel layout manager
@@ skipping 219 matching lines @@
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 }  // namespace internal
 }  // namespace ash