Split View Mode: Support for the 2-finger bezel scroll.

athena/wm/bezel_controller.cc

+// 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 "athena/wm/bezel_controller.h"
+
+#include "ui/aura/window.h"
+#include "ui/events/event_handler.h"
+
+namespace athena {
+namespace {
+
+// Using bezel swipes, the first touch that is registered is usually within
+// 5-10 pixels from the edge, but sometimes as far as 29 pixels away.
+// So setting this width fairly high for now.
+const float kBezelWidth = 20.0f;
+
+const float kScrollPositionNone = -100;
+
+bool ShouldProcessGesture(ui::EventType event_type) {
+  return event_type == ui::ET_GESTURE_SCROLL_UPDATE ||
+         event_type == ui::ET_GESTURE_SCROLL_BEGIN ||
+         event_type == ui::ET_GESTURE_BEGIN;
+}
+
+}  // namespace
+
+BezelController::BezelController(aura::Window* container)
+    : container_(container),
+      num_fingers_down_(0),
+      state_(NO_FINGERS_DOWN),
+      scroll_bezel_(BEZEL_NONE),
+      left_right_delegate_(NULL) {
+}
+
+float BezelController::GetDistance(const gfx::PointF& position,
+                                   BezelController::Bezel bezel) {
+  DCHECK(bezel == BEZEL_LEFT || bezel == BEZEL_RIGHT);
+  return bezel == BEZEL_LEFT
+             ? position.x()
+             : position.x() - container_->GetBoundsInScreen().width();
+}
+
+void BezelController::SetState(BezelController::State state,
+                               const gfx::PointF& scroll_position) {
+  if (!left_right_delegate_ || state == state_)
+    return;
+
+  if (state == BEZEL_SCROLLING_TWO_FINGERS) {
+    float delta = GetDistance(scroll_position, scroll_bezel_);
+    left_right_delegate_->ScrollBegin(scroll_bezel_, delta);
+  } else if (state_ == BEZEL_SCROLLING_TWO_FINGERS) {
+    left_right_delegate_->ScrollEnd();
+  }
+  state_ = state;
+  if (state_ == IGNORE || state == NO_FINGERS_DOWN)
+    scroll_bezel_ = BEZEL_NONE;
+}
+
+// Only implemented for LEFT and RIGHT bezels ATM.
+BezelController::Bezel BezelController::GetBezel(const gfx::PointF& location) {
+  if (location.x() < kBezelWidth) {
+    return BEZEL_LEFT;
+  } else if (location.x() >
+             container_->GetBoundsInScreen().width() - kBezelWidth) {
+    return BEZEL_RIGHT;
+  } else {
+    return BEZEL_NONE;
+  }
+}
+
+void BezelController::OnTouchEvent(ui::TouchEvent* event) {
+  if (!left_right_delegate_)
+    return;
+
+  // TODO (mfomitchev): Currently we aren't retargetting or consuming any of the
+  // touch events. This means that content can prevent the generation of gesture
+  // events and two-finger scroll won't work. Possible solution to this problem
+  // is hosting our own gesture recognizer or retargetting touch events at the
+  // bezel.
+
+  ui::EventType type = event->type();
+  if (type == ui::ET_TOUCH_PRESSED) {
+    num_fingers_down_++;
+    BezelController::Bezel event_bezel = GetBezel(event->location_f());
+
+    if (num_fingers_down_ > 2 ||
+        (event_bezel != BEZEL_LEFT && event_bezel != BEZEL_RIGHT)) {
+      SetState(IGNORE, gfx::Point(kScrollPositionNone, kScrollPositionNone));
+      return;
+    }
+
+    switch (state_) {
+      case NO_FINGERS_DOWN:
+        SetState(BEZEL_GESTURE_STARTED,
+                 gfx::Point(kScrollPositionNone, kScrollPositionNone));
+        scroll_bezel_ = event_bezel;
+        return;
+      case IGNORE:
+      case BEZEL_GESTURE_STARTED:
+        return;
+      case BEZEL_SCROLLING_ONE_FINGER:
+        if (event_bezel != scroll_bezel_)
+          SetState(IGNORE,
+                   gfx::Point(kScrollPositionNone, kScrollPositionNone));
+        return;
+      case BEZEL_SCROLLING_TWO_FINGERS:
+        // Should've exited above
+        NOTREACHED();
+        return;
+    }
+  } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    num_fingers_down_--;
+    DCHECK_NE(state_, NO_FINGERS_DOWN);
+    // The finger beeing lifted gets counted for touch_points.
+    if (num_fingers_down_ == 0) {
+      SetState(NO_FINGERS_DOWN,
+               gfx::Point(kScrollPositionNone, kScrollPositionNone));
+    } else {
+      // Lifting fingers means the user is doing a gesture other than 2-finger
+      // scrolling.
+      SetState(IGNORE,
+               gfx::Point(kScrollPositionNone, kScrollPositionNone));
+    }
+  }
+}

[sadrul, 2014/07/22 22:34:16]

Can you look into not overriding OnTouchEvent(), and use the corresponding
OnGestureEvent()s instead? For example, you can use GESTURE_BEGIN/GESTURE_END to
know when/where the touch-events are pressed/removed. I think that would make
this code easier to read. Also, GestureEvent()s include the number of active
touch-points, so you wouldn't have to maintain num_fingers_down_ yourself.

[mfomitchev, 2014/07/22 22:51:26]

I tried doing that at first, but there is a a couple of problems. 
1. The location of the gesture event is based on all the touch points, and I
didn't find a way to extract the location of each individual touch point. This
makes it tricky to determine whether the new touch point is at the bezel on the
GESTURE_BEGIN event.
2. If you are performing more than one simultaneous gesture, the touch points
are going to be split between these gestures. In order to execute the transition
from IGNORE to NO_FINGERS_DOWN, you have to keep track of all the ongoing
gestures, so you can't get rid of num_fingers_down_.

[sadrul, 2014/07/23 16:56:19]

If the location of the GESTURE_BEGIN event is not the location of the
touch-point that was pressed, then that is a bug, and we should fix that.
There can be a single gesture-sequence in an aura::Window. So you won't have to
maintain a list of ongoing gestures.

[mfomitchev, 2014/07/23 21:51:54]

Done.

+
+void BezelController::OnGestureEvent(ui::GestureEvent* event) {
+  if (!left_right_delegate_)
+    return;
+
+  ui::EventType type = event->type();
+  if (!ShouldProcessGesture(type))
+    return;
+
+  const gfx::PointF& event_location = event->location_f();
+  const ui::GestureEventDetails& event_details = event->details();
+
+  if (type == ui::ET_GESTURE_BEGIN && event_details.touch_points() == 2 &&
+      state_ == BEZEL_SCROLLING_ONE_FINGER) {
+    SetState(BEZEL_SCROLLING_TWO_FINGERS, event_location);
+  } else if (type == ui::ET_GESTURE_SCROLL_BEGIN) {
+    DCHECK(state_ == IGNORE || state_ == BEZEL_GESTURE_STARTED);
+    if (state_ != BEZEL_GESTURE_STARTED)
+      return;
+
+    if (num_fingers_down_ == 1) {
+      SetState(BEZEL_SCROLLING_ONE_FINGER, event_location);
+      return;
+    }
+
+    DCHECK_EQ(num_fingers_down_, 2);
+    SetState(BEZEL_SCROLLING_TWO_FINGERS, event_location);
+    if (left_right_delegate_->CanScroll()) {
+      event->SetHandled();
+      event->StopPropagation();
+    }
+  } else if (type == ui::ET_GESTURE_SCROLL_UPDATE) {
+    if (state_ != BEZEL_SCROLLING_TWO_FINGERS)
+      return;
+
+    float scroll_delta = GetDistance(event_location, scroll_bezel_);
+    left_right_delegate_->ScrollUpdate(scroll_delta);
+    if (left_right_delegate_->CanScroll()) {
+      event->SetHandled();
+      event->StopPropagation();
+    }
+  }
+}
+
+}  // namespace athena