Allow setting different hit test bounds overrides for mouse and touch

ash/wm/frame_border_hittest_controller.cc

 // Copyright 2013 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/frame_border_hittest_controller.h"
 
 #include "ash/ash_constants.h"
 #include "ash/wm/header_painter.h"
+#include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
+#include "ash/wm/wm_types.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/non_client_view.h"
 
+namespace {
+
+// The height of the region in |frame_window_| where |frame_window_| should grab
+// touches while in immersive fullscreen. (Even if a child window overlaps this
+// region.) This region is used to allow us to intercept edge gestures to
+// reveal the top-of-window views even if |frame_window_|'s web page conumes all
+// touch events.
+const int kImmersiveFullscreenTopInnerInsetTouch = 8;

[James Cook, 2013/10/16 16:38:35]

Are you sure you want to do it this way?  We're OK with making part of the
content area un-touchable?

[pkotwicz, 2013/10/17 04:45:08]

This is not a change. This is just moving what we were doing in
ImmersiveModeControllerAsh::SetRenderWindowTopInsetsForTouch() to
FrameBorderHittestController. (In the sense that it is equivalent to what we are
already doing, I am sure). I asked sadrul@ and he did not have any suggestions
as to a better way of doing this.
The problem is that if anyone consumes touch events, ET_GESTURE_SCROLL.* is not
dispatched at all.

+
+}  // namespace
+
 namespace ash {
 
 FrameBorderHittestController::FrameBorderHittestController(views::Widget* frame)
     : frame_window_(frame->GetNativeWindow()) {
   gfx::Insets mouse_outer_insets(-kResizeOutsideBoundsSize,
                                  -kResizeOutsideBoundsSize,
                                  -kResizeOutsideBoundsSize,
                                  -kResizeOutsideBoundsSize);
   gfx::Insets touch_outer_insets = mouse_outer_insets.Scale(
       kResizeOutsideBoundsScaleForTouch);
@@ skipping 48 matching lines @@
     return frame_component;
 
   int client_component = frame->client_view()->NonClientHitTest(point);
   if (client_component != HTNOWHERE)
     return client_component;
 
   return header_painter->NonClientHitTest(point);
 }
 
 void FrameBorderHittestController::UpdateHitTestBoundsOverrideInner() {
-  // Maximized and fullscreen windows don't want resize handles overlapping the
-  // content area, because when the user moves the cursor to the right screen
-  // edge we want them to be able to hit the scroll bar.
-  if (wm::GetWindowState(frame_window_)->IsMaximizedOrFullscreen()) {
-    frame_window_->set_hit_test_bounds_override_inner(gfx::Insets());
+  if (wm::GetWindowState(frame_window_)->IsFullscreen()) {
+    // Fullscreen windows don't want resize handles when the mouse is on top of
+    // the content area, so it is unnecessary to steal events from the web
+    // contents along |frame_window_|'s edges. While in immersive fullscreen, we
+    // grab touch events along the top edge of |frame_window_| so that we can
+    // intercept edge gestures to reveal the top-of-window views even if the
+    // web contents consumes all touch events.
+    wm::FullscreenType fullscreen_type =
+        frame_window_->GetProperty(internal::kFullscreenTypeKey);
+    if (wm::IsImmersiveFullscreenType(fullscreen_type)) {
+      frame_window_->SetHitTestBoundsOverrideInner(gfx::Insets(),
+          gfx::Insets(kImmersiveFullscreenTopInnerInsetTouch, 0, 0, 0));
+    } else {
+      frame_window_->SetHitTestBoundsOverrideInner(gfx::Insets(),
+                                                   gfx::Insets());
+    }
+  } else if (wm::GetWindowState(frame_window_)->IsMaximized()) {
+    // We do not want resize handles for maximized windows either.
+    frame_window_->SetHitTestBoundsOverrideInner(gfx::Insets(),
+                                                 gfx::Insets());
   } else {
-    frame_window_->set_hit_test_bounds_override_inner(
-        gfx::Insets(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
-                    kResizeInsideBoundsSize, kResizeInsideBoundsSize));
+    gfx::Insets insets(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
+                       kResizeInsideBoundsSize, kResizeInsideBoundsSize);
+    frame_window_->SetHitTestBoundsOverrideInner(insets, insets);
   }
 }
 
 void FrameBorderHittestController::OnWindowShowTypeChanged(
     wm::WindowState* window_state,
     wm::WindowShowType old_type) {
   UpdateHitTestBoundsOverrideInner();
 }
 
+void FrameBorderHittestController::OnWindowPropertyChanged(aura::Window* window,
+                                                           const void* key,
+                                                           intptr_t old) {
+  if (key == ash::internal::kFullscreenTypeKey)
+    UpdateHitTestBoundsOverrideInner();
+}
+
 void FrameBorderHittestController::OnWindowDestroying(aura::Window* window) {
   frame_window_->RemoveObserver(this);
   ash::wm::GetWindowState(frame_window_)->RemoveObserver(this);
   frame_window_ = NULL;
 }
 
 }  // namespace ash