root/content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.cc

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. FloorTowardZero
  2. CeilFromZero
  3. ProjectScalarOntoVector
  4. state_
  5. ForwardInputEvents
  6. ForwardTouchInputEvents
  7. ForwardMouseInputEvents
  8. ForwardTouchEvent
  9. ForwardMouseWheelEvent
  10. PressTouchPoint
  11. MoveTouchPoint
  12. ReleaseTouchPoint
  13. AddTouchSlopToFirstDistance
  14. GetPositionDeltaAtTime
  15. ComputeNextScrollSegment
  16. ClampTimestamp
  17. FinishedCurrentScrollSegment
  18. IsLastScrollSegment
  19. ScrollIsNoOp

// 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 "content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h"

#include "base/logging.h"
#include "ui/gfx/point_f.h"

namespace content {
namespace {

gfx::Vector2d FloorTowardZero(const gfx::Vector2dF& vector) {
  int x = vector.x() > 0 ? floor(vector.x()) : ceil(vector.x());
  int y = vector.y() > 0 ? floor(vector.y()) : ceil(vector.y());
  return gfx::Vector2d(x, y);
}

gfx::Vector2d CeilFromZero(const gfx::Vector2dF& vector) {
  int x = vector.x() > 0 ? ceil(vector.x()) : floor(vector.x());
  int y = vector.y() > 0 ? ceil(vector.y()) : floor(vector.y());
  return gfx::Vector2d(x, y);
}

gfx::Vector2dF ProjectScalarOntoVector(
    float scalar, const gfx::Vector2d& vector) {
  return gfx::ScaleVector2d(vector, scalar / vector.Length());
}

}  // namespace

SyntheticSmoothScrollGesture::SyntheticSmoothScrollGesture(
    const SyntheticSmoothScrollGestureParams& params)
    : params_(params),
      gesture_source_type_(SyntheticGestureParams::DEFAULT_INPUT),
      state_(SETUP) {}

SyntheticSmoothScrollGesture::~SyntheticSmoothScrollGesture() {}

SyntheticGesture::Result SyntheticSmoothScrollGesture::ForwardInputEvents(
    const base::TimeTicks& timestamp, SyntheticGestureTarget* target) {
  if (state_ == SETUP) {
    gesture_source_type_ = params_.gesture_source_type;
    if (gesture_source_type_ == SyntheticGestureParams::DEFAULT_INPUT)
      gesture_source_type_ = target->GetDefaultSyntheticGestureSourceType();

    if (!target->SupportsSyntheticGestureSourceType(gesture_source_type_))
      return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_SUPPORTED_BY_PLATFORM;

    state_ = STARTED;
    current_scroll_segment_ = -1;
    current_scroll_segment_stop_time_ = timestamp;
  }

  DCHECK_NE(gesture_source_type_, SyntheticGestureParams::DEFAULT_INPUT);
  if (gesture_source_type_ == SyntheticGestureParams::TOUCH_INPUT)
    ForwardTouchInputEvents(timestamp, target);
  else if (gesture_source_type_ == SyntheticGestureParams::MOUSE_INPUT)
    ForwardMouseInputEvents(timestamp, target);
  else
    return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_IMPLEMENTED;

  return (state_ == DONE) ? SyntheticGesture::GESTURE_FINISHED
                          : SyntheticGesture::GESTURE_RUNNING;
}

void SyntheticSmoothScrollGesture::ForwardTouchInputEvents(
    const base::TimeTicks& timestamp, SyntheticGestureTarget* target) {
  base::TimeTicks event_timestamp = timestamp;
  switch (state_) {
    case STARTED:
      if (ScrollIsNoOp()) {
        state_ = DONE;
        break;
      }
      AddTouchSlopToFirstDistance(target);
      ComputeNextScrollSegment();
      current_scroll_segment_start_position_ = params_.anchor;
      PressTouchPoint(target, event_timestamp);
      state_ = MOVING;
      break;
    case MOVING: {
      event_timestamp = ClampTimestamp(timestamp);
      gfx::Vector2dF delta = GetPositionDeltaAtTime(event_timestamp);
      MoveTouchPoint(target, delta, event_timestamp);

      if (FinishedCurrentScrollSegment(event_timestamp)) {
        if (!IsLastScrollSegment()) {
          current_scroll_segment_start_position_ +=
              params_.distances[current_scroll_segment_];
          ComputeNextScrollSegment();
          // Start the next scroll immediately.
          ForwardTouchInputEvents(timestamp, target);
        } else if (params_.prevent_fling) {
          state_ = STOPPING;
        } else {
          ReleaseTouchPoint(target, event_timestamp);
          state_ = DONE;
        }
      }
    } break;
    case STOPPING:
      if (timestamp - current_scroll_segment_stop_time_ >=
          target->PointerAssumedStoppedTime()) {
        event_timestamp = current_scroll_segment_stop_time_ +
                          target->PointerAssumedStoppedTime();
        // Send one last move event, but don't change the location. Without this
        // we'd still sometimes cause a fling on Android.

        // Required to suppress flings on Aura, see
        // |UpdateWebTouchPointFromUIEvent|, remove when crbug.com/332418
        // is fixed.
        touch_event_.touches[0].position.y += 0.001f;

        ForwardTouchEvent(target, event_timestamp);
        ReleaseTouchPoint(target, event_timestamp);
        state_ = DONE;
      }
      break;
    case SETUP:
      NOTREACHED()
          << "State STARTED invalid for synthetic scroll using touch input.";
    case DONE:
      NOTREACHED()
          << "State DONE invalid for synthetic scroll using touch input.";
  }
}

void SyntheticSmoothScrollGesture::ForwardMouseInputEvents(
    const base::TimeTicks& timestamp, SyntheticGestureTarget* target) {
  switch (state_) {
    case STARTED:
      if (ScrollIsNoOp()) {
        state_ = DONE;
        break;
      }
      ComputeNextScrollSegment();
      state_ = MOVING;
      // Fall through to forward the first event.
    case MOVING: {
      // Even though WebMouseWheelEvents take floating point deltas,
      // internally the scroll position is stored as an integer. We therefore
      // keep track of the discrete delta which is consistent with the
      // internal scrolling state. This ensures that when the gesture has
      // finished we've scrolled exactly the specified distance.
      base::TimeTicks event_timestamp = ClampTimestamp(timestamp);
      gfx::Vector2dF current_scroll_segment_total_delta =
          GetPositionDeltaAtTime(event_timestamp);
      gfx::Vector2d delta_discrete =
          FloorTowardZero(current_scroll_segment_total_delta -
                          current_scroll_segment_total_delta_discrete_);
      ForwardMouseWheelEvent(target, delta_discrete, event_timestamp);
      current_scroll_segment_total_delta_discrete_ += delta_discrete;

      if (FinishedCurrentScrollSegment(event_timestamp)) {
        if (!IsLastScrollSegment()) {
          current_scroll_segment_total_delta_discrete_ = gfx::Vector2d();
          ComputeNextScrollSegment();
          ForwardMouseInputEvents(timestamp, target);
        } else {
          state_ = DONE;
        }
      }
    } break;
    case SETUP:
      NOTREACHED()
          << "State STARTED invalid for synthetic scroll using touch input.";
    case STOPPING:
      NOTREACHED()
          << "State STOPPING invalid for synthetic scroll using touch input.";
    case DONE:
      NOTREACHED()
          << "State DONE invalid for synthetic scroll using touch input.";
  }
}

void SyntheticSmoothScrollGesture::ForwardTouchEvent(
    SyntheticGestureTarget* target, const base::TimeTicks& timestamp) {
  touch_event_.timeStampSeconds = ConvertTimestampToSeconds(timestamp);

  target->DispatchInputEventToPlatform(touch_event_);
}

void SyntheticSmoothScrollGesture::ForwardMouseWheelEvent(
    SyntheticGestureTarget* target,
    const gfx::Vector2dF& delta,
    const base::TimeTicks& timestamp) const {
  blink::WebMouseWheelEvent mouse_wheel_event =
      SyntheticWebMouseWheelEventBuilder::Build(delta.x(), delta.y(), 0, false);

  mouse_wheel_event.x = params_.anchor.x();
  mouse_wheel_event.y = params_.anchor.y();

  mouse_wheel_event.timeStampSeconds = ConvertTimestampToSeconds(timestamp);

  target->DispatchInputEventToPlatform(mouse_wheel_event);
}

void SyntheticSmoothScrollGesture::PressTouchPoint(
    SyntheticGestureTarget* target, const base::TimeTicks& timestamp) {
  DCHECK_EQ(current_scroll_segment_, 0);
  touch_event_.PressPoint(params_.anchor.x(), params_.anchor.y());
  ForwardTouchEvent(target, timestamp);
}

void SyntheticSmoothScrollGesture::MoveTouchPoint(
    SyntheticGestureTarget* target,
    const gfx::Vector2dF& delta,
    const base::TimeTicks& timestamp) {
  DCHECK_GE(current_scroll_segment_, 0);
  DCHECK_LT(current_scroll_segment_,
            static_cast<int>(params_.distances.size()));
  gfx::PointF touch_position = current_scroll_segment_start_position_ + delta;
  touch_event_.MovePoint(0, touch_position.x(), touch_position.y());
  ForwardTouchEvent(target, timestamp);
}

void SyntheticSmoothScrollGesture::ReleaseTouchPoint(
    SyntheticGestureTarget* target, const base::TimeTicks& timestamp) {
  DCHECK_EQ(current_scroll_segment_,
            static_cast<int>(params_.distances.size()) - 1);
  touch_event_.ReleasePoint(0);
  ForwardTouchEvent(target, timestamp);
}

void SyntheticSmoothScrollGesture::AddTouchSlopToFirstDistance(
    SyntheticGestureTarget* target) {
  DCHECK_GE(params_.distances.size(), 1ul);
  gfx::Vector2d& first_scroll_distance = params_.distances[0];
  DCHECK_GT(first_scroll_distance.Length(), 0);
  first_scroll_distance += CeilFromZero(ProjectScalarOntoVector(
      target->GetTouchSlopInDips(), first_scroll_distance));
}

gfx::Vector2dF SyntheticSmoothScrollGesture::GetPositionDeltaAtTime(
    const base::TimeTicks& timestamp) const {
  // Make sure the final delta is correct. Using the computation below can lead
  // to issues with floating point precision.
  if (FinishedCurrentScrollSegment(timestamp))
    return params_.distances[current_scroll_segment_];

  float delta_length =
      params_.speed_in_pixels_s *
      (timestamp - current_scroll_segment_start_time_).InSecondsF();
  return ProjectScalarOntoVector(delta_length,
                                 params_.distances[current_scroll_segment_]);
}

void SyntheticSmoothScrollGesture::ComputeNextScrollSegment() {
  current_scroll_segment_++;
  DCHECK_LT(current_scroll_segment_,
            static_cast<int>(params_.distances.size()));
  int64 total_duration_in_us = static_cast<int64>(
      1e6 * (params_.distances[current_scroll_segment_].Length() /
             params_.speed_in_pixels_s));
  DCHECK_GT(total_duration_in_us, 0);
  current_scroll_segment_start_time_ = current_scroll_segment_stop_time_;
  current_scroll_segment_stop_time_ =
      current_scroll_segment_start_time_ +
      base::TimeDelta::FromMicroseconds(total_duration_in_us);
}

base::TimeTicks SyntheticSmoothScrollGesture::ClampTimestamp(
    const base::TimeTicks& timestamp) const {
  return std::min(timestamp, current_scroll_segment_stop_time_);
}

bool SyntheticSmoothScrollGesture::FinishedCurrentScrollSegment(
    const base::TimeTicks& timestamp) const {
  return timestamp >= current_scroll_segment_stop_time_;
}

bool SyntheticSmoothScrollGesture::IsLastScrollSegment() const {
  DCHECK_LT(current_scroll_segment_,
            static_cast<int>(params_.distances.size()));
  return current_scroll_segment_ ==
         static_cast<int>(params_.distances.size()) - 1;
}

bool SyntheticSmoothScrollGesture::ScrollIsNoOp() const {
  return params_.distances.size() == 0 || params_.distances[0].IsZero();
}

}  // namespace content

/* [<][>][^][v][top][bottom][index][help] */