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 {
+
+// static

[oshima, 2014/07/22 21:30:46]

remove this

[oshima, 2014/07/22 21:32:03]

Sorry for incomplete comments. What I meant is that if you move static consts to
anonymous namespace, you can remove this.

[mfomitchev, 2014/07/22 22:22:01]

Done.

[mfomitchev, 2014/07/22 22:22:01]

Done.

+// 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 BezelController::kBezelWidth = 20.0f;
+
+const float BezelController::kScrollPositionNone = -100;
+
+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_) {
+    if (state != state_) {

[sadrul, 2014/07/22 21:53:19]

early outing here if state_ == state would make this less nested.

[mfomitchev, 2014/07/22 22:22:01]

Done.

+      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;
+  }
+}
+
+bool BezelController::ShouldProcessGesture(ui::EventType event_type) {

[oshima, 2014/07/22 21:30:46]

Move this to anonymouse namespace as it doesn't depend on BezelCOntroller

[mfomitchev, 2014/07/22 22:22:01]

Done.

+  return event_type == ui::ET_GESTURE_SCROLL_UPDATE ||
+         event_type == ui::ET_GESTURE_SCROLL_BEGIN ||
+         event_type == ui::ET_GESTURE_BEGIN;
+}
+
+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.

[sadrul, 2014/07/22 21:53:19]

On chromeos/x11, we do this by using a --touch-calibration command-line flag.
Have you considered using that for this too?

[mfomitchev, 2014/07/22 22:22:01]

Thanks for the pointer. Discussed offline: Ideally we'd want to make this
conditional on left_right_delegate_->CanScroll() so that we don't steal events
in full screen mode, etc... so this is probably not the best option.

+
+  ui::EventType type = event->type();
+  if (type == ui::ET_TOUCH_PRESSED) {
+    num_fingers_down_++;

[oshima, 2014/07/22 21:30:46]

shouldn't you use event->finger_count() instead?

[mfomitchev, 2014/07/22 22:22:01]

finger_count() is defined for ScrollEvent, not for TouchEvent. I didn't find
this in TouchEvent. 

[oshima, 2014/07/22 23:26:47]

I see. sadrul@, does it make sense to have a finger count in TouchEvent?
I'm worrying about relying on pressed/release event to count fingers as it's
possible to lose it.

+    BezelController::Bezel event_bezel =
+        GetBezel(gfx::PointF(event->x(), event->y()));

[oshima, 2014/07/22 21:30:46]

event->location()

[mfomitchev, 2014/07/22 22:22:01]

Done.

+
+    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;
+    };

[sadrul, 2014/07/22 21:53:19]

Remove ;

[mfomitchev, 2014/07/22 22:22:01]

Done.

+  } 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));
+    }
+  }
+}
+
+void BezelController::OnGestureEvent(ui::GestureEvent* event) {
+  if (!left_right_delegate_)
+    return;
+
+  ui::EventType type = event->type();
+  if (!ShouldProcessGesture(type))
+    return;
+
+  gfx::PointF event_location = event->location_f();

[oshima, 2014/07/22 21:30:46]

const gfx::PointF&

[mfomitchev, 2014/07/22 22:22:01]

Done.

+  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) {
+      if (num_fingers_down_ == 1) {
+        SetState(BEZEL_SCROLLING_ONE_FINGER, event_location);
+      } else {
+        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) {
+      float scroll_delta = GetDistance(event_location, scroll_bezel_);
+      left_right_delegate_->ScrollUpdate(scroll_delta);
+      if (left_right_delegate_->CanScroll()) {
+        event->SetHandled();
+        event->StopPropagation();
+      }
+    }
+  }

[sadrul, 2014/07/22 21:53:18]

Prefer early-outs where possible.

[mfomitchev, 2014/07/22 22:22:01]

Done.

+}
+
+}  // namespace athena