Add in gesture for immersive mode

ash/wm/gestures/edge_gesture_handler.cc

 // Copyright (c) 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/gestures/edge_gesture_handler.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
+#include "ash/wm/property_util.h"
+#include "ui/aura/window.h"
 #include "ui/base/events/event.h"
 #include "ui/gfx/screen.h"
 
 namespace {
 const int kBottomEdgeGestureThreshold = 10;
 const int kLeftEdgeGestureThreshold = 10;
 const int kRightEdgeGestureThreshold = 10;
 const int kTopEdgeGestureThreshold = 10;
 
 // Bit positions of edge start flags
@@ skipping 24 matching lines @@
 
 bool EdgeGestureHandler::ProcessGestureEvent(aura::Window* target,
                                              const ui::GestureEvent& event) {
   // TODO(crbug.com/222746): Rewrite this code to ignore events that are for
   // edges that a bezel is present for instead of hardcoding the layout of edge
   // v bezel.
   switch (event.type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
       return HandleEdgeGestureStart(target, event);
     case ui::ET_GESTURE_SCROLL_UPDATE:
-      if (ANY_FLAGS_SET(start_location_)) {
-        if (DetermineGestureOrientation(event)) {
+      if (ANY_FLAGS_SET(start_location_))
+        if (DetermineGestureOrientation(event))
           return HandleEdgeGestureUpdate(target, event);
-        }
-      }
       break;
     case ui::ET_GESTURE_SCROLL_END:
     case ui::ET_SCROLL_FLING_START:
       return HandleEdgeGestureEnd(target, event);
     default:
       break;
   }
   return false;
 }
 
@@ skipping 17 matching lines @@
     // screen and there are no implemented gestures for the top edge at the
     // moment.
     case SHELF_ALIGNMENT_BOTTOM:
     case SHELF_ALIGNMENT_TOP:
     default:
       break;
   }
   return false;
 }
 
+bool EdgeGestureHandler::HandleImmersiveControl(aura::Window* target,
+                                                const ui::GestureEvent& event) {
+  // If not in immersive mode let the gesture pass through
+  if (!GetRootWindowController(target->GetRootWindow())->IsImmersiveMode())
+    return false;
+
+  switch (event.type()) {
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+      return true;
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      GetRootWindowController(
+          target->GetRootWindow())->SetPendingImmersiveGesture(true);
+      break;
+    case ui::ET_GESTURE_SCROLL_END:
+    case ui::ET_SCROLL_FLING_START:
+      return true;
+      break;
+    default:
+      break;
+  }
+  return false;
+}
+
 bool EdgeGestureHandler::HandleEdgeGestureStart(
     aura::Window* target,
     const ui::GestureEvent& event) {
   gfx::Rect screen =
       Shell::GetScreen()->GetDisplayNearestWindow(target).bounds();
 
   orientation_ = EDGE_SCROLL_ORIENTATION_UNSET;
-  if (GestureStartInEdgeArea(screen, event))
-    return HandleLauncherControl(event);
+  if (GestureStartInEdgeArea(screen, event)) {
+    if (IS_FLAG_SET(start_location_, EDGE_START_TOP))
+      return HandleImmersiveControl(target, event);
+    else
+      return HandleLauncherControl(event);
+  }
   return false;
 }
 
 bool EdgeGestureHandler::DetermineGestureOrientation(
     const ui::GestureEvent& event) {
   if (orientation_ == EDGE_SCROLL_ORIENTATION_UNSET) {
     if (!event.details().scroll_x() && !event.details().scroll_y())
       return false;
     orientation_ = abs(event.details().scroll_y()) >
         abs(event.details().scroll_x()) ?
         EDGE_SCROLL_ORIENTATION_VERTICAL : EDGE_SCROLL_ORIENTATION_HORIZONTAL;
   }
   return true;
 }
 
 bool EdgeGestureHandler::HandleEdgeGestureUpdate(
     aura::Window* target,
     const ui::GestureEvent& event) {
+  if (IsGestureInImmersiveOrientation(event))
+    return HandleImmersiveControl(target, event);
+
   if (IsGestureInLauncherOrientation(event))
     return HandleLauncherControl(event);
   return false;
 }
 
 bool EdgeGestureHandler::HandleEdgeGestureEnd(aura::Window* target,
                                               const ui::GestureEvent& event) {
   bool ret_val = HandleLauncherControl(event);
   CLEAR_FLAGS(start_location_);
   return ret_val;
@@ skipping 24 matching lines @@
   EdgeScrollOrientation  new_orientation = abs(event.details().scroll_y()) >
       abs(event.details().scroll_x()) ?
       EDGE_SCROLL_ORIENTATION_VERTICAL : EDGE_SCROLL_ORIENTATION_HORIZONTAL;
 
   if (new_orientation != orientation_)
     return false;
 
   ShelfLayoutManager* shelf =
       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
   switch (shelf->GetAlignment()) {
-    case SHELF_ALIGNMENT_BOTTOM:
-      if (orientation_ == EDGE_SCROLL_ORIENTATION_VERTICAL)
-        return true;
-      break;
     case SHELF_ALIGNMENT_LEFT:
       if (orientation_ == EDGE_SCROLL_ORIENTATION_HORIZONTAL)
         return true;
       break;
     case SHELF_ALIGNMENT_RIGHT:
       if (orientation_ == EDGE_SCROLL_ORIENTATION_HORIZONTAL)
         return true;
       break;
-    case SHELF_ALIGNMENT_TOP:
-      if (orientation_ == EDGE_SCROLL_ORIENTATION_VERTICAL)
-        return true;
-      break;
     default:
       break;
   }
   return false;
 }
 
+bool EdgeGestureHandler::IsGestureInImmersiveOrientation(
+    const ui::GestureEvent& event) {
+  if (IS_FLAG_SET(start_location_, EDGE_START_TOP) &&
+      (orientation_ == EDGE_SCROLL_ORIENTATION_VERTICAL))
+    return true;
+  return false;
+}
+
 }  // namespace internal
 }  // namespace ash