Correct immersive mode gestures under rotation

chrome/browser/ui/views/frame/immersive_mode_controller_ash.cc

 // Copyright 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 "chrome/browser/ui/views/frame/immersive_mode_controller_ash.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/wm/window_properties.h"
 #include "base/command_line.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
 #include "chrome/browser/ui/immersive_fullscreen_configuration.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/env.h"
+#include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
-#include "ui/aura/window_observer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
 using views::View;
 
@@ skipping 255 matching lines @@
 
   UpdateRevealedLock();
 
   std::map<views::Widget*, int>::iterator it = widgets_.find(widget);
   DCHECK(it != widgets_.end());
   UpdateWidgetBounds(it->first, it->second);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// Observer to watch for window restore. views::Widget does not provide a hook
-// to observe for window restore, so do this at the Aura level.
-class ImmersiveModeControllerAsh::WindowObserver : public aura::WindowObserver {
- public:
-  explicit WindowObserver(ImmersiveModeControllerAsh* controller)
-      : controller_(controller) {
-    controller_->native_window_->AddObserver(this);
-  }
-
-  virtual ~WindowObserver() {
-    controller_->native_window_->RemoveObserver(this);
-  }
-
-  // aura::WindowObserver overrides:
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) OVERRIDE {
-    using aura::client::kShowStateKey;
-    if (key == kShowStateKey) {
-      // Disable immersive mode when leaving the fullscreen state.
-      ui::WindowShowState show_state = static_cast<ui::WindowShowState>(
-          window->GetProperty(kShowStateKey));
-      if (controller_->IsEnabled() &&
-          show_state != ui::SHOW_STATE_FULLSCREEN &&
-          show_state != ui::SHOW_STATE_MINIMIZED) {
-        controller_->delegate_->FullscreenStateChanged();
-      }
-      return;
-    }
-  }
-
- private:
-  ImmersiveModeControllerAsh* controller_;  // Not owned.
-
-  DISALLOW_COPY_AND_ASSIGN(WindowObserver);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
 ImmersiveModeControllerAsh::ImmersiveModeControllerAsh()
     : delegate_(NULL),
       widget_(NULL),
       top_container_(NULL),
       observers_enabled_(false),
       enabled_(false),
       reveal_state_(CLOSED),
       revealed_lock_count_(0),
       tab_indicator_visibility_(TAB_INDICATORS_HIDE),
       mouse_x_when_hit_top_(-1),
@@ skipping 189 matching lines @@
   if (!enabled_)
     return;
 
   // Touch gestures should not initiate revealing the top-of-window views while
   // |native_window_| is inactive.
   if (!views::Widget::GetWidgetForNativeWindow(native_window_)->IsActive())
     return;
 
   switch (event->type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
-      if (IsNearTopContainer(event->location())) {
+      if (ShouldHandleEvent(event->location())) {
         gesture_begun_ = true;
         event->SetHandled();
       }
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE:
       if (gesture_begun_) {
         SwipeType swipe_type = GetSwipeType(event);
         if ((reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED) &&
             swipe_type == SWIPE_OPEN) {
           delegate_->FocusLocationBar();
@@ skipping 52 matching lines @@
 // Animation observer:
 
 void ImmersiveModeControllerAsh::OnImplicitAnimationsCompleted() {
   if (reveal_state_ == SLIDING_OPEN)
     OnSlideOpenAnimationCompleted();
   else if (reveal_state_ == SLIDING_CLOSED)
     OnSlideClosedAnimationCompleted();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// aura::WindowObserver overrides:
+void ImmersiveModeControllerAsh::OnWindowPropertyChanged(aura::Window* window,
+                                                         const void* key,
+                                                         intptr_t old) {
+  using aura::client::kShowStateKey;
+  if (key == kShowStateKey) {
+    // Disable immersive mode when leaving the fullscreen state.
+    ui::WindowShowState show_state = static_cast<ui::WindowShowState>(
+        window->GetProperty(kShowStateKey));
+    if (IsEnabled() &&
+        show_state != ui::SHOW_STATE_FULLSCREEN &&
+        show_state != ui::SHOW_STATE_MINIMIZED) {
+      delegate_->FullscreenStateChanged();
+    }
+  }
+}
+
+void ImmersiveModeControllerAsh::OnWindowAddedToRootWindow(
+    aura::Window* window) {
+  DCHECK_EQ(window, native_window_);
+  UpdatePreTargetHandler();
+}
+
+void ImmersiveModeControllerAsh::OnWindowRemovingFromRootWindow(
+    aura::Window* window) {
+  DCHECK_EQ(window, native_window_);
+  UpdatePreTargetHandler();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Testing interface:
 
 void ImmersiveModeControllerAsh::SetForceHideTabIndicatorsForTest(bool force) {
   if (force)
     tab_indicator_visibility_ = TAB_INDICATORS_FORCE_HIDE;
   else if (tab_indicator_visibility_ == TAB_INDICATORS_FORCE_HIDE)
     tab_indicator_visibility_ = TAB_INDICATORS_HIDE;
   UpdateUseMinimalChrome(LAYOUT_YES);
 }
 
@@ skipping 25 matching lines @@
       views::Widget::GetWidgetForNativeWindow(native_window_);
   views::FocusManager* focus_manager = widget->GetFocusManager();
   if (enable) {
     widget->AddObserver(this);
     focus_manager->AddFocusChangeListener(this);
   } else {
     widget->RemoveObserver(this);
     focus_manager->RemoveFocusChangeListener(this);
   }
 
-  if (enable)
-    native_window_->AddPreTargetHandler(this);
-  else
-    native_window_->RemovePreTargetHandler(this);
+  UpdatePreTargetHandler();
 
-  // The window observer adds and removes itself from the native window.
-  window_observer_.reset(enable ? new WindowObserver(this) : NULL);
+  if (enable) {
+    native_window_->AddObserver(this);
+  } else {
+    native_window_->RemoveObserver(this);
+  }
 
   if (enable) {
     registrar_.Add(
         this,
         chrome::NOTIFICATION_FULLSCREEN_CHANGED,
         content::Source<FullscreenController>(
             delegate_->GetFullscreenController()));
   } else {
     registrar_.Remove(
         this,
@@ skipping 339 matching lines @@
   if (abs(event->details().scroll_y()) <=
       kSwipeVerticalThresholdMultiplier * abs(event->details().scroll_x()))
     return SWIPE_NONE;
   if (event->details().scroll_y() < 0)
     return SWIPE_CLOSE;
   else if (event->details().scroll_y() > 0)
     return SWIPE_OPEN;
   return SWIPE_NONE;
 }
 
-bool ImmersiveModeControllerAsh::IsNearTopContainer(gfx::Point location) const {
+bool ImmersiveModeControllerAsh::ShouldHandleEvent(
+    const gfx::Point& location) const {
+  // All of the gestures that are of interest start in a region with left &
+  // right edges agreeing with |top_container_|. When CLOSED it is difficult to
+  // hit the bounds due to small size of the tab strip, so the hit target needs
+  // to be extended on the bottom, thus the inset call. Finally there may be a
+  // bezel sensor off screen logically above |top_container_| thus the test
+  // needs to include gestures starting above.
   gfx::Rect near_bounds = top_container_->GetTargetBoundsInScreen();
   if (reveal_state_ == CLOSED)
     near_bounds.Inset(gfx::Insets(0, 0, -kNearTopContainerDistance, 0));
-  return near_bounds.Contains(location);
+  return near_bounds.Contains(location) ||
+      ((location.y() < near_bounds.y()) &&
+       (location.x() >= near_bounds.x()) &&
+       (location.x() <= near_bounds.right()));
 }
+
+void ImmersiveModeControllerAsh::UpdatePreTargetHandler() {
+  if (!native_window_)
+    return;
+  aura::RootWindow* root_window = native_window_->GetRootWindow();
+  if (!root_window)
+    return;
+  if (observers_enabled_)
+    root_window->AddPreTargetHandler(this);
+  else
+    root_window->RemovePreTargetHandler(this);
+}