Allow setting different hit test bounds overrides for mouse and touch

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 <set>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
-#include "ash/wm/window_properties.h"
-#include "base/command_line.h"
+#include "ash/wm/window_state.h"
 #include "chrome/browser/chrome_notification_types.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 "content/public/browser/notification_service.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/browser/web_contents_view.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/client/cursor_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/views/bubble/bubble_delegate.h"
@@ skipping 228 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 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_in_screen_(-1),
       gesture_begun_(false),
       native_window_(NULL),
       animation_(new gfx::SlideAnimation(this)),
       animations_disabled_for_test_(false),
       weak_ptr_factory_(this) {
 }
 
 ImmersiveModeControllerAsh::~ImmersiveModeControllerAsh() {
   // The browser view is being destroyed so there's no need to update its
@@ skipping 27 matching lines @@
 void ImmersiveModeControllerAsh::Init(
     Delegate* delegate,
     views::Widget* widget,
     views::View* top_container) {
   delegate_ = delegate;
   widget_ = widget;
   // Browser view is detached from its widget during destruction. Cache the
   // window pointer so |this| can stop observing during destruction.
   native_window_ = widget_->GetNativeWindow();
   top_container_ = top_container;
-
-  // Optionally allow the tab indicators to be hidden.
-  if (CommandLine::ForCurrentProcess()->
-          HasSwitch(ash::switches::kAshImmersiveHideTabIndicators)) {
-    tab_indicator_visibility_ = TAB_INDICATORS_FORCE_HIDE;
-  }
 }
 
 void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
   DCHECK(native_window_) << "Must initialize before enabling";
   if (enabled_ == enabled)
     return;
   enabled_ = enabled;
 
   EnableWindowObservers(enabled_);
 
-  UpdateUseMinimalChrome(LAYOUT_NO);
+  if (enabled_) {
+    UpdateUseMinimalChrome(LAYOUT_NO);
 
-  if (enabled_) {
     // Animate enabling immersive mode by sliding out the top-of-window views.
     // No animation occurs if a lock is holding the top-of-window views open.
 
     // Do a reveal to set the initial state for the animation. (And any
     // required state in case the animation cannot run because of a lock holding
     // the top-of-window views open.) This call has the side effect of relaying
     // out |browser_view_|'s root view.
     MaybeStartReveal(ANIMATE_NO);
 
     // Reset the located event and the focus revealed locks so that they do not
     // affect whether the top-of-window views are hidden.
     located_event_revealed_lock_.reset();
     focus_revealed_lock_.reset();
 
     // Try doing the animation.
     MaybeEndReveal(ANIMATE_SLOW);
 
     if (reveal_state_ == REVEALED) {
       // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
       UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
       UpdateFocusRevealedLock();
     }
   } else {
     // Stop cursor-at-top tracking.
     top_edge_hover_timer_.Stop();
     // Snap immediately to the closed state.
     reveal_state_ = CLOSED;
     EnablePaintToLayer(false);
     delegate_->SetImmersiveStyle(false);
-    SetRenderWindowTopInsetsForTouch(0);
 
     // Layout the root view so that incognito avatar icon, if any, gets laid
     // out.
     LayoutBrowserRootView();
   }
 }
 
 bool ImmersiveModeControllerAsh::IsEnabled() const {
   return enabled_;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTabIndicators() const {
-  return tab_indicator_visibility_ != TAB_INDICATORS_SHOW;
+  return ash::wm::GetWindowState(native_window_)->fullscreen_type() !=
+      ash::wm::FULLSCREEN_TYPE_IMMERSIVE_MINIMAL_CHROME;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTopViews() const {
   return enabled_ && reveal_state_ == CLOSED;
 }
 
 bool ImmersiveModeControllerAsh::IsRevealed() const {
   return enabled_ && reveal_state_ != CLOSED;
 }
 
@@ skipping 207 matching lines @@
 
 void ImmersiveModeControllerAsh::OnRemoveTransientChild(
     aura::Window* window,
     aura::Window* transient) {
   bubble_manager_->StopObserving(transient);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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);
-}
-
 void ImmersiveModeControllerAsh::StartRevealForTest(bool hovered) {
   MaybeStartReveal(ANIMATE_NO);
   MoveMouse(top_container_, hovered);
   UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
 }
 
 void ImmersiveModeControllerAsh::SetMouseHoveredForTest(bool hovered) {
   MoveMouse(top_container_, hovered);
   UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
 }
@@ skipping 270 matching lines @@
 
       // Ending the reveal was unsuccessful. Reaquire the locks if appropriate.
       UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
       UpdateFocusRevealedLock();
     }
   }
   return false;
 }
 
 void ImmersiveModeControllerAsh::UpdateUseMinimalChrome(Layout layout) {
+  if (!enabled_)
+    return;
+
+  ash::wm::FullscreenType previous_fullscreen_type =
+      ash::wm::GetWindowState(native_window_)->fullscreen_type();
+
   // May be NULL in tests.
   FullscreenController* fullscreen_controller =
       delegate_->GetFullscreenController();
   bool in_tab_fullscreen = fullscreen_controller ?
       fullscreen_controller->IsFullscreenForTabOrPending() : false;
-  bool use_minimal_chrome = !in_tab_fullscreen && enabled_;
-  native_window_->SetProperty(ash::internal::kFullscreenUsesMinimalChromeKey,
-                              use_minimal_chrome);
+  ash::wm::FullscreenType fullscreen_type = in_tab_fullscreen ?
+      ash::wm::FULLSCREEN_TYPE_IMMERSIVE_NO_CHROME :
+      ash::wm::FULLSCREEN_TYPE_IMMERSIVE_MINIMAL_CHROME;
 
-  TabIndicatorVisibility previous_tab_indicator_visibility =
-      tab_indicator_visibility_;
-  if (tab_indicator_visibility_ != TAB_INDICATORS_FORCE_HIDE) {
-    tab_indicator_visibility_ = use_minimal_chrome ?
-        TAB_INDICATORS_SHOW : TAB_INDICATORS_HIDE;
-  }
+  if (fullscreen_type == previous_fullscreen_type)
+    return;
+  ash::wm::GetWindowState(native_window_)->SetFullscreenType(fullscreen_type);
 
   // Ash on Windows may not have a shell.
   if (ash::Shell::HasInstance()) {
     // When using minimal chrome, the shelf is auto-hidden. The auto-hidden
     // shelf displays a 3px 'light bar' when it is closed.
     ash::Shell::GetInstance()->UpdateShelfVisibility();
   }
 
-  if (tab_indicator_visibility_ != previous_tab_indicator_visibility) {
-    // If the top-of-window views are revealed or animating, the change will
-    // take effect with the layout once the top-of-window views are closed.
-    if (layout == LAYOUT_YES && reveal_state_ == CLOSED)
-      LayoutBrowserRootView();
-  }
+  // If the top-of-window views are revealed or animating, the change will take
+  // effect with the layout once the top-of-window views are closed.
+  if (layout == LAYOUT_YES && reveal_state_ == CLOSED)
+    LayoutBrowserRootView();
 }
 
 int ImmersiveModeControllerAsh::GetAnimationDuration(Animate animate) const {
   switch (animate) {
     case ANIMATE_NO:
       return 0;
     case ANIMATE_SLOW:
       return kRevealSlowAnimationDurationMs;
     case ANIMATE_FAST:
       return kRevealFastAnimationDurationMs;
@@ skipping 20 matching lines @@
   reveal_state_ = SLIDING_OPEN;
   if (previous_reveal_state == CLOSED) {
     // Turn on layer painting so that we can overlap the web contents.
     EnablePaintToLayer(true);
 
     // Ensure window caption buttons are updated and the view bounds are
     // computed at normal (non-immersive-style) size. The layout call moves the
     // top-of-window views to their initial offscreen position for the
     // animation.
     delegate_->SetImmersiveStyle(false);
-    SetRenderWindowTopInsetsForTouch(0);
     LayoutBrowserRootView();
 
     // Do not do any more processing if LayoutBrowserView() changed
     // |reveal_state_|.
     if (reveal_state_ != SLIDING_OPEN) {
       if (reveal_state_ == REVEALED)
         FOR_EACH_OBSERVER(Observer, observers_, OnImmersiveRevealStarted());
       return;
     }
   }
@@ skipping 77 matching lines @@
   }
 }
 
 void ImmersiveModeControllerAsh::OnSlideClosedAnimationCompleted() {
   DCHECK_EQ(SLIDING_CLOSED, reveal_state_);
   reveal_state_ = CLOSED;
   // Layers aren't needed after animation completes.
   EnablePaintToLayer(false);
   // Update tabstrip for closed state.
   delegate_->SetImmersiveStyle(true);
-  SetRenderWindowTopInsetsForTouch(kNearTopContainerDistance);
   LayoutBrowserRootView();
 }
 
 bool ImmersiveModeControllerAsh::ShouldExitImmersiveFullscreen() const {
   if (!native_window_)
     return false;
 
   ui::WindowShowState show_state = static_cast<ui::WindowShowState>(
       native_window_->GetProperty(aura::client::kShowStateKey));
   return IsEnabled() &&
@@ skipping 59 matching lines @@
   // the closest screen ensures that the event is from a valid bezel and can be
   // interpreted as such.
   gfx::Rect screen_bounds =
       ash::Shell::GetScreen()->GetDisplayNearestPoint(location).bounds();
   return (!screen_bounds.Contains(location) &&
           location.y() < top_container_bounds_in_screen.y() &&
           location.x() >= top_container_bounds_in_screen.x() &&
           location.x() < top_container_bounds_in_screen.right());
 }
 
-void ImmersiveModeControllerAsh::SetRenderWindowTopInsetsForTouch(
-    int top_inset) {
-  content::WebContents* contents = delegate_->GetWebContents();
-  if (contents) {
-    aura::Window* window = contents->GetView()->GetContentNativeView();
-    // |window| is NULL if the renderer crashed.
-    if (window) {
-      gfx::Insets inset(top_inset, 0, 0, 0);
-      window->SetHitTestBoundsOverrideOuter(
-          window->hit_test_bounds_override_outer_mouse(),
-          inset);
-    }
-  }
-}
-
 void ImmersiveModeControllerAsh::RecreateBubbleManager() {
   bubble_manager_.reset(new BubbleManager(this));
   const std::vector<aura::Window*> transient_children =
       native_window_->transient_children();
   for (size_t i = 0; i < transient_children.size(); ++i) {
     aura::Window* transient_child = transient_children[i];
     views::BubbleDelegateView* bubble_delegate =
         AsBubbleDelegate(transient_child);
     if (bubble_delegate &&
         bubble_delegate->GetAnchorView() &&
         top_container_->Contains(bubble_delegate->GetAnchorView())) {
       bubble_manager_->StartObserving(transient_child);
     }
   }
 }