Block keyboard and mouse input when maximize mode is activated by accelerometer.

BUG=353409
TEST=MaximizeModeControllerTest.BlocksKeyboardAndMouse

Review URL: https://codereview.chromium.org/230613004

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

15 files changed, 292 insertions, 34 deletions

diff --git a/ash/ash.gyp b/ash/ash.gyp
index a668338..290271d 100644
--- a/ash/ash.gyp
+++ b/ash/ash.gyp
@@ -575,6 +575,8 @@
         'wm/lock_state_observer.h',
         'wm/maximize_mode/maximize_mode_controller.cc',
         'wm/maximize_mode/maximize_mode_controller.h',
+        'wm/maximize_mode/maximize_mode_event_blocker.cc',
+        'wm/maximize_mode/maximize_mode_event_blocker.h',
         'wm/maximize_mode/maximize_mode_window_manager.cc',
         'wm/maximize_mode/maximize_mode_window_manager.h',
         'wm/maximize_mode/maximize_mode_window_state.cc',
diff --git a/ash/desktop_background/desktop_background_controller.cc b/ash/desktop_background/desktop_background_controller.cc
index bada383..8b54cb5 100644
--- a/ash/desktop_background/desktop_background_controller.cc
+++ b/ash/desktop_background/desktop_background_controller.cc
@@ -48,10 +48,12 @@ DesktopBackgroundController::DesktopBackgroundController()
       desktop_background_mode_(BACKGROUND_NONE),
       wallpaper_reload_delay_(kWallpaperReloadDelayMs) {
   Shell::GetInstance()->display_controller()->AddObserver(this);
+  Shell::GetInstance()->AddShellObserver(this);
 }
 
 DesktopBackgroundController::~DesktopBackgroundController() {
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
+  Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 gfx::ImageSkia DesktopBackgroundController::GetWallpaper() const {
@@ -76,23 +78,6 @@ WallpaperLayout DesktopBackgroundController::GetWallpaperLayout() const {
   return WALLPAPER_LAYOUT_CENTER_CROPPED;
 }
 
-void DesktopBackgroundController::OnRootWindowAdded(aura::Window* root_window) {
-  // The background hasn't been set yet.
-  if (desktop_background_mode_ == BACKGROUND_NONE)
-    return;
-
-  // Handle resolution change for "built-in" images.
-  gfx::Size max_display_size = GetMaxDisplaySizeInNative();
-  if (current_max_display_size_ != max_display_size) {
-    current_max_display_size_ = max_display_size;
-    if (desktop_background_mode_ == BACKGROUND_IMAGE &&
-        current_wallpaper_.get())
-      UpdateWallpaper();
-  }
-
-  InstallDesktopController(root_window);
-}
-
 bool DesktopBackgroundController::SetWallpaperImage(const gfx::ImageSkia& image,
                                                     WallpaperLayout layout) {
   VLOG(1) << "SetWallpaper: image_id=" << WallpaperResizer::GetImageId(image)
@@ -169,6 +154,23 @@ void DesktopBackgroundController::OnDisplayConfigurationChanged() {
   }
 }
 
+void DesktopBackgroundController::OnRootWindowAdded(aura::Window* root_window) {
+  // The background hasn't been set yet.
+  if (desktop_background_mode_ == BACKGROUND_NONE)
+    return;
+
+  // Handle resolution change for "built-in" images.
+  gfx::Size max_display_size = GetMaxDisplaySizeInNative();
+  if (current_max_display_size_ != max_display_size) {
+    current_max_display_size_ = max_display_size;
+    if (desktop_background_mode_ == BACKGROUND_IMAGE &&
+        current_wallpaper_.get())
+      UpdateWallpaper();
+  }
+
+  InstallDesktopController(root_window);
+}
+
 // static
 gfx::Size DesktopBackgroundController::GetMaxDisplaySizeInNative() {
   int width = 0;
diff --git a/ash/desktop_background/desktop_background_controller.h b/ash/desktop_background/desktop_background_controller.h
index 219e3c8..b1099c6 100644
--- a/ash/desktop_background/desktop_background_controller.h
+++ b/ash/desktop_background/desktop_background_controller.h
@@ -7,6 +7,7 @@
 
 #include "ash/ash_export.h"
 #include "ash/display/display_controller.h"
+#include "ash/shell_observer.h"
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
@@ -46,7 +47,8 @@ class WallpaperResizer;
 
 // Updates background layer if necessary.
 class ASH_EXPORT DesktopBackgroundController
-    : public DisplayController::Observer {
+    : public DisplayController::Observer,
+      public ShellObserver {
  public:
   class TestAPI;
 
@@ -72,9 +74,6 @@ class ASH_EXPORT DesktopBackgroundController
 
   WallpaperLayout GetWallpaperLayout() const;
 
-  // Initialize root window's background.
-  void OnRootWindowAdded(aura::Window* root_window);
-
   // Sets wallpaper. This is mostly called by WallpaperManager to set
   // the default or user selected custom wallpaper.
   // Returns true if new image was actually set. And false when duplicate set
@@ -99,9 +98,12 @@ class ASH_EXPORT DesktopBackgroundController
   // Returns true if the desktop moved.
   bool MoveDesktopToUnlockedContainer();
 
-  // Overrides DisplayController::Observer:
+  // DisplayController::Observer:
   virtual void OnDisplayConfigurationChanged() OVERRIDE;
 
+  // ShellObserver:
+  virtual void OnRootWindowAdded(aura::Window* root_window) OVERRIDE;
+
   // Returns the maximum size of all displays combined in native
   // resolutions.  Note that this isn't the bounds of the display who
   // has maximum resolutions. Instead, this returns the size of the
diff --git a/ash/high_contrast/high_contrast_controller.cc b/ash/high_contrast/high_contrast_controller.cc
index 03618c56..418dd71 100644
--- a/ash/high_contrast/high_contrast_controller.cc
+++ b/ash/high_contrast/high_contrast_controller.cc
@@ -12,6 +12,11 @@ namespace ash {
 
 HighContrastController::HighContrastController()
     : enabled_(false) {
+  Shell::GetInstance()->AddShellObserver(this);
+}
+
+HighContrastController::~HighContrastController() {
+  Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 void HighContrastController::SetEnabled(bool enabled) {
@@ -25,12 +30,12 @@ void HighContrastController::SetEnabled(bool enabled) {
   }
 }
 
-void HighContrastController::OnRootWindowAdded(aura::Window* root_window) {
-  UpdateDisplay(root_window);
-}
-
 void HighContrastController::UpdateDisplay(aura::Window* root_window) {
   root_window->layer()->SetLayerInverted(enabled_);
 }
 
+void HighContrastController::OnRootWindowAdded(aura::Window* root_window) {
+  UpdateDisplay(root_window);
+}
+
 }  // namespace ash
diff --git a/ash/high_contrast/high_contrast_controller.h b/ash/high_contrast/high_contrast_controller.h
index 49aca61..10d0b7d 100644
--- a/ash/high_contrast/high_contrast_controller.h
+++ b/ash/high_contrast/high_contrast_controller.h
@@ -6,26 +6,25 @@
 #define ASH_HIGH_CONTRAST_HIGH_CONTRAST_CONTROLLER_H_
 
 #include "ash/ash_export.h"
+#include "ash/shell_observer.h"
 #include "base/basictypes.h"
 
 namespace aura {
-class RootWindow;
 class Window;
 }
 
 namespace ash {
 
-class ASH_EXPORT HighContrastController {
+class ASH_EXPORT HighContrastController : public ShellObserver {
  public:
   HighContrastController();
-
-  ~HighContrastController() {}
+  virtual ~HighContrastController();
 
   // Set high contrast mode and update all available displays.
   void SetEnabled(bool enabled);
 
-  // Update high contrast mode on the just added display.
-  void OnRootWindowAdded(aura::Window* root_window);
+  // ShellObserver:
+  virtual void OnRootWindowAdded(aura::Window* root_window) OVERRIDE;
 
  private:
   // Update high contrast mode on the passed display.
diff --git a/ash/root_window_controller.cc b/ash/root_window_controller.cc
index 6477b14..3690dfe 100644
--- a/ash/root_window_controller.cc
+++ b/ash/root_window_controller.cc
@@ -721,13 +721,14 @@ void RootWindowController::Init(RootWindowType root_window_type,
       shell->InitKeyboard();
   } else {
     root_window_layout()->OnWindowResized();
-    shell->desktop_background_controller()->OnRootWindowAdded(root_window);
-    shell->high_contrast_controller()->OnRootWindowAdded(root_window);
     ash_host_->AsWindowTreeHost()->Show();
 
     // Create a shelf if a user is already logged in.
     if (shell->session_state_delegate()->NumberOfLoggedInUsers())
       shelf()->CreateShelf();
+
+    // Notify shell observers about new root window.
+    shell->OnRootWindowAdded(root_window);
   }
 }
 
diff --git a/ash/shell.cc b/ash/shell.cc
index e4dec64..98f7346 100644
--- a/ash/shell.cc
+++ b/ash/shell.cc
@@ -396,6 +396,10 @@ void Shell::OnMaximizeModeEnded() {
   FOR_EACH_OBSERVER(ShellObserver, observers_, OnMaximizeModeEnded());
 }
 
+void Shell::OnRootWindowAdded(aura::Window* root_window) {
+  FOR_EACH_OBSERVER(ShellObserver, observers_, OnRootWindowAdded(root_window));
+}
+
 void Shell::CreateShelf() {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
@@ -698,6 +702,7 @@ Shell::~Shell() {
   video_activity_notifier_.reset();
 #endif  // defined(OS_CHROMEOS)
   video_detector_.reset();
+  high_contrast_controller_.reset();
 
   shadow_controller_.reset();
   resize_shadow_controller_.reset();
diff --git a/ash/shell.h b/ash/shell.h
index ba9ddfd..56af8d1 100644
--- a/ash/shell.h
+++ b/ash/shell.h
@@ -301,6 +301,9 @@ class ASH_EXPORT Shell : public SystemModalContainerEventFilterDelegate,
   // their original position.
   void OnMaximizeModeEnded();
 
+  // Called when a root window is created.
+  void OnRootWindowAdded(aura::Window* root_window);
+
   // Initializes |shelf_|.  Does nothing if it's already initialized.
   void CreateShelf();
 
diff --git a/ash/shell_observer.h b/ash/shell_observer.h
index d1b3d86..8c393d3 100644
--- a/ash/shell_observer.h
+++ b/ash/shell_observer.h
@@ -29,6 +29,9 @@ class ASH_EXPORT ShellObserver {
   // unlocked.
   virtual void OnLockStateChanged(bool locked) {}
 
+  // Invoked after a non-primary root window is created.
+  virtual void OnRootWindowAdded(aura::Window* root_window) {}
+
   // Invoked when the shelf alignment in |root_window| is changed.
   virtual void OnShelfAlignmentChanged(aura::Window* root_window) {}
 
diff --git a/ash/wm/maximize_mode/maximize_mode_controller.cc b/ash/wm/maximize_mode/maximize_mode_controller.cc
index 7fec420..47ae3c8 100644
--- a/ash/wm/maximize_mode/maximize_mode_controller.cc
+++ b/ash/wm/maximize_mode/maximize_mode_controller.cc
@@ -7,6 +7,7 @@
 #include "ash/accelerometer/accelerometer_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
+#include "ash/wm/maximize_mode/maximize_mode_event_blocker.h"
 #include "ui/gfx/vector3d_f.h"
 
 namespace ash {
@@ -113,9 +114,11 @@ void MaximizeModeController::HandleHingeRotation(const gfx::Vector3dF& base,
       angle > kFullyOpenAngleErrorTolerance &&
       angle < kExitMaximizeModeAngle) {
     Shell::GetInstance()->EnableMaximizeModeWindowManager(false);
+    event_blocker_.reset();
   } else if (!maximize_mode_engaged &&
       angle > kEnterMaximizeModeAngle) {
     Shell::GetInstance()->EnableMaximizeModeWindowManager(true);
+    event_blocker_.reset(new MaximizeModeEventBlocker);
   }
 }
 
diff --git a/ash/wm/maximize_mode/maximize_mode_controller.h b/ash/wm/maximize_mode/maximize_mode_controller.h
index 0ef1b9f..03662d2 100644
--- a/ash/wm/maximize_mode/maximize_mode_controller.h
+++ b/ash/wm/maximize_mode/maximize_mode_controller.h
@@ -7,9 +7,12 @@
 
 #include "ash/accelerometer/accelerometer_observer.h"
 #include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
 
 namespace ash {
 
+class MaximizeModeEventBlocker;
+
 // MaximizeModeController listens to accelerometer events and automatically
 // enters and exits maximize mode when the lid is opened beyond the triggering
 // angle and rotates the display to match the device when in maximize mode.
@@ -18,6 +21,7 @@ class MaximizeModeController : public AccelerometerObserver {
   MaximizeModeController();
   virtual ~MaximizeModeController();
 
+  // AccelerometerObserver:
   virtual void OnAccelerometerUpdated(const gfx::Vector3dF& base,
                                       const gfx::Vector3dF& lid) OVERRIDE;
  private:
@@ -30,6 +34,10 @@ class MaximizeModeController : public AccelerometerObserver {
   // screen.
   void HandleScreenRotation(const gfx::Vector3dF& lid);
 
+  // An event handler which traps mouse and keyboard events while maximize
+  // mode is engaged.
+  scoped_ptr<MaximizeModeEventBlocker> event_blocker_;
+
   DISALLOW_COPY_AND_ASSIGN(MaximizeModeController);
 };
 
diff --git a/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc b/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
index 3237524..0348be3 100644
--- a/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
+++ b/ash/wm/maximize_mode/maximize_mode_controller_unittest.cc
@@ -9,6 +9,8 @@
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
+#include "ui/aura/test/event_generator.h"
+#include "ui/events/event_handler.h"
 #include "ui/gfx/vector3d_f.h"
 
 namespace ash {
@@ -17,6 +19,39 @@ namespace {
 
 const float kDegreesToRadians = 3.14159265f / 180.0f;
 
+// Filter to count the number of events seen.
+class EventCounter : public ui::EventHandler {
+ public:
+  EventCounter();
+  virtual ~EventCounter();
+
+  // Overridden from ui::EventHandler:
+  virtual void OnEvent(ui::Event* event) OVERRIDE;
+
+  void reset() {
+    event_count_ = 0;
+  }
+
+  size_t event_count() const { return event_count_; }
+
+ private:
+  size_t event_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventCounter);
+};
+
+EventCounter::EventCounter() : event_count_(0) {
+  Shell::GetInstance()->AddPreTargetHandler(this);
+}
+
+EventCounter::~EventCounter() {
+  Shell::GetInstance()->RemovePreTargetHandler(this);
+}
+
+void EventCounter::OnEvent(ui::Event* event) {
+  event_count_++;
+}
+
 }  // namespace
 
 class MaximizeModeControllerTest : public test::AshTestBase {
@@ -232,4 +267,50 @@ TEST_F(MaximizeModeControllerTest, RotationOnlyInMaximizeMode) {
   EXPECT_EQ(gfx::Display::ROTATE_0, GetInternalDisplayRotation());
 }
 
+// Tests that maximize mode blocks keyboard events but not touch events. Mouse
+// events are blocked too but EventGenerator does not construct mouse events
+// with a NativeEvent so they would not be blocked in testing.
+TEST_F(MaximizeModeControllerTest, BlocksKeyboard) {
+  aura::Window* root = Shell::GetPrimaryRootWindow();
+  aura::test::EventGenerator event_generator(root, root);
+  EventCounter counter;
+
+  event_generator.PressKey(ui::VKEY_ESCAPE, 0);
+  event_generator.ReleaseKey(ui::VKEY_ESCAPE, 0);
+  EXPECT_GT(counter.event_count(), 0u);
+  counter.reset();
+
+  event_generator.PressTouch();
+  event_generator.ReleaseTouch();
+  EXPECT_GT(counter.event_count(), 0u);
+  counter.reset();
+
+  // Open up 270 degrees.
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, 1.0f),
+                             gfx::Vector3dF(1.0f, 0.0f, 0.0f));
+  ASSERT_TRUE(IsMaximizeModeStarted());
+
+  event_generator.PressKey(ui::VKEY_ESCAPE, 0);
+  event_generator.ReleaseKey(ui::VKEY_ESCAPE, 0);
+  EXPECT_EQ(0u, counter.event_count());
+  counter.reset();
+
+ // Touch should not be blocked.
+  event_generator.PressTouch();
+  event_generator.ReleaseTouch();
+  EXPECT_GT(counter.event_count(), 0u);
+  counter.reset();
+
+  gfx::Vector3dF base;
+
+  // Lid open 90 degrees.
+  TriggerAccelerometerUpdate(gfx::Vector3dF(0.0f, 0.0f, 1.0f),
+                             gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+
+  event_generator.PressKey(ui::VKEY_ESCAPE, 0);
+  event_generator.ReleaseKey(ui::VKEY_ESCAPE, 0);
+  EXPECT_GT(counter.event_count(), 0u);
+  counter.reset();
+}
+
 }  // namespace ash
diff --git a/ash/wm/maximize_mode/maximize_mode_event_blocker.cc b/ash/wm/maximize_mode/maximize_mode_event_blocker.cc
new file mode 100644
index 0000000..e283149
--- /dev/null
+++ b/ash/wm/maximize_mode/maximize_mode_event_blocker.cc
@@ -0,0 +1,100 @@
+// Copyright 2014 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/wm/maximize_mode/maximize_mode_event_blocker.h"
+
+#include "ash/shell.h"
+#include "base/memory/scoped_ptr.h"
+#include "ui/aura/client/cursor_client.h"
+#include "ui/events/event_targeter.h"
+
+namespace ash {
+
+namespace {
+
+// Event targeter to prevent delivery of mouse and touchpad events while
+// maximize mode is active. Other events such as touch are passed on to the
+// default targeter.
+// TODO(flackr): This should only stop events from the internal keyboard and
+// touchpad.
+class BlockKeyboardAndTouchpadTargeter : public ui::EventTargeter {
+ public:
+  BlockKeyboardAndTouchpadTargeter();
+  virtual ~BlockKeyboardAndTouchpadTargeter();
+
+  // Sets the default targeter to use when the event is not being blocked.
+  void SetDefaultTargeter(EventTargeter* default_targeter);
+
+  // Overridden from ui::EventTargeter:
+  virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
+                                              ui::Event* event) OVERRIDE;
+
+ private:
+  // A weak pointer to the targeter this targeter is wrapping. The
+  // default_targeter is owned by the ScopedWindowTargeter which will be valid
+  // as long as this targeter is alive.
+  ui::EventTargeter* default_targeter_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlockKeyboardAndTouchpadTargeter);
+};
+
+BlockKeyboardAndTouchpadTargeter::BlockKeyboardAndTouchpadTargeter()
+    : default_targeter_(NULL) {
+}
+
+BlockKeyboardAndTouchpadTargeter::~BlockKeyboardAndTouchpadTargeter() {
+}
+
+void BlockKeyboardAndTouchpadTargeter::SetDefaultTargeter(
+    ui::EventTargeter* default_targeter) {
+  default_targeter_ = default_targeter;
+}
+
+ui::EventTarget* BlockKeyboardAndTouchpadTargeter::FindTargetForEvent(
+    ui::EventTarget* root,
+    ui::Event* event) {
+  if (event->HasNativeEvent() && (event->IsMouseEvent() || event->IsKeyEvent()))
+    return NULL;
+  return default_targeter_->FindTargetForEvent(root, event);
+}
+
+}  // namespace
+
+MaximizeModeEventBlocker::MaximizeModeEventBlocker() {
+  Shell::GetInstance()->AddShellObserver(this);
+
+  // Hide the cursor as mouse events will be blocked.
+  aura::client::CursorClient* cursor_client_ =
+      aura::client::GetCursorClient(Shell::GetTargetRootWindow());
+  if (cursor_client_)
+    cursor_client_->HideCursor();
+
+  // Block keyboard and mouse events on all existing and new root windows for
+  // the lifetime of this class.
+  aura::Window::Windows root_windows(Shell::GetAllRootWindows());
+  for (aura::Window::Windows::iterator iter = root_windows.begin();
+       iter != root_windows.end(); ++iter) {
+    AddEventTargeterOn(*iter);
+  }
+}
+
+MaximizeModeEventBlocker::~MaximizeModeEventBlocker() {
+  Shell::GetInstance()->RemoveShellObserver(this);
+}
+
+void MaximizeModeEventBlocker::OnRootWindowAdded(aura::Window* root_window) {
+  AddEventTargeterOn(root_window);
+}
+
+void MaximizeModeEventBlocker::AddEventTargeterOn(
+    aura::Window* root_window) {
+  BlockKeyboardAndTouchpadTargeter* targeter =
+      new BlockKeyboardAndTouchpadTargeter();
+  aura::ScopedWindowTargeter* scoped_targeter = new aura::ScopedWindowTargeter(
+      root_window, scoped_ptr<ui::EventTargeter>(targeter));
+  targeter->SetDefaultTargeter(scoped_targeter->old_targeter());
+  targeters_.push_back(scoped_targeter);
+}
+
+}  // namespace ash
diff --git a/ash/wm/maximize_mode/maximize_mode_event_blocker.h b/ash/wm/maximize_mode/maximize_mode_event_blocker.h
new file mode 100644
index 0000000..9e4a1a0
--- /dev/null
+++ b/ash/wm/maximize_mode/maximize_mode_event_blocker.h
@@ -0,0 +1,40 @@
+// Copyright 2014 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 ASH_WM_MAXIMIZE_MODE_MAXIMIZE_MODE_EVENT_BLOCKER_H_
+#define ASH_WM_MAXIMIZE_MODE_MAXIMIZE_MODE_EVENT_BLOCKER_H_
+
+#include "ash/shell_observer.h"
+#include "base/macros.h"
+#include "base/memory/scoped_vector.h"
+#include "ui/aura/scoped_window_targeter.h"
+
+namespace aura {
+class Window;
+}  // namespace aura
+
+namespace ash {
+
+// A class which blocks mouse and keyboard events while instantiated by
+// replacing the root window event targeter.
+class MaximizeModeEventBlocker : public ShellObserver {
+ public:
+  MaximizeModeEventBlocker();
+  virtual ~MaximizeModeEventBlocker();
+
+  // ShellObserver:
+  virtual void OnRootWindowAdded(aura::Window* root_window) OVERRIDE;
+
+ private:
+  // Adds an event targeter on |root_window| to block mouse and keyboard events.
+  void AddEventTargeterOn(aura::Window* root_window);
+
+  ScopedVector<aura::ScopedWindowTargeter> targeters_;
+
+  DISALLOW_COPY_AND_ASSIGN(MaximizeModeEventBlocker);
+};
+
+}  // namespace ash
+
+#endif  // ASH_WM_MAXIMIZE_MODE_MAXIMIZE_MODE_EVENT_BLOCKER_H_
diff --git a/ui/aura/scoped_window_targeter.h b/ui/aura/scoped_window_targeter.h
index ce65092..f8546c5 100644
--- a/ui/aura/scoped_window_targeter.h
+++ b/ui/aura/scoped_window_targeter.h
@@ -27,6 +27,10 @@ class AURA_EXPORT ScopedWindowTargeter : public WindowObserver {
 
   virtual ~ScopedWindowTargeter();
 
+  ui::EventTargeter* old_targeter() {
+    return old_targeter_.get();
+  }
+
  private:
   // WindowObserver:
   virtual void OnWindowDestroyed(Window* window) OVERRIDE;