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);
 }
 
+class EmptyWindowDelegate : public aura::WindowDelegate {

[Daniel Erat, 2013/08/02 15:40:26]

add a comment describing what this class is/does

+ 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 155 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()));
 
+  // 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 207 matching lines @@
   set_touch_hud_projection(new TouchHudProjection(root_window_.get()));
 }
 
 void RootWindowController::DisableTouchHudProjection() {
   if (!touch_hud_projection_)
     return;
   touch_hud_projection_->Remove();
 }
 
 void RootWindowController::OnLoginStateChanged(user::LoginStatus status) {
+  if (status != user::LOGGED_IN_NONE)
+    mouse_event_target_.reset();
   shelf_->shelf_layout_manager()->UpdateVisibilityState();
 }
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 }  // namespace internal
 }  // namespace ash