0

Fix flaky FlingController unittests on Fuchsia.

The fling unittests are using mock clock to make sure that the tests are
stable.

Bug: 868381
Change-Id: I4bafbb71edd668ea553507c00a8784c994f49597
Reviewed-on: https://chromium-review.googlesource.com/1157291
Reviewed-by: Jonathan Ross <jonross@chromium.org>
Reviewed-by: Navid Zolghadr <nzolghadr@chromium.org>
Commit-Queue: Sahel Sharify <sahel@chromium.org>
Cr-Commit-Position: refs/heads/master@{#593214}
This commit is contained in:
Sahel Sharify
2018-09-21 16:30:11 +00:00
committed by Commit Bot
parent 83187183a4
commit 2d2d28fc02
4 changed files with 95 additions and 99 deletions

@ -4,6 +4,7 @@
#include "content/browser/renderer_host/input/fling_controller.h"
#include "base/time/default_tick_clock.h"
#include "base/trace_event/trace_event.h"
#include "content/browser/renderer_host/input/gesture_event_queue.h"
#include "content/public/browser/content_browser_client.h"
@ -54,6 +55,7 @@ FlingController::FlingController(
touchscreen_tap_suppression_controller_(
config.touchscreen_tap_suppression_config),
fling_in_progress_(false),
clock_(base::DefaultTickClock::GetInstance()),
weak_ptr_factory_(this) {
DCHECK(gesture_event_queue);
DCHECK(event_sender_client);
@ -188,14 +190,13 @@ void FlingController::ProcessGestureFlingStart(
current_fling_parameters_.velocity,
current_fling_parameters_.source_device,
current_fling_parameters_.modifiers);
// Wait for BeginFrame to call ProgressFling when
// SetNeedsBeginFrameForFlingProgress is used to progress flings instead of
// compositor animation observer (happens on Android WebView).
if (scheduler_client_->NeedsBeginFrameForFlingProgress())
ScheduleFlingProgress();
else
ProgressFling(base::TimeTicks::Now());
ProgressFling(clock_->NowTicks());
}
void FlingController::ScheduleFlingProgress() {
@ -288,7 +289,7 @@ void FlingController::GenerateAndSendWheelEvents(
blink::WebMouseWheelEvent::Phase phase) {
MouseWheelEventWithLatencyInfo synthetic_wheel(
WebInputEvent::kMouseWheel, current_fling_parameters_.modifiers,
base::TimeTicks::Now(), ui::LatencyInfo(ui::SourceEventType::WHEEL));
clock_->NowTicks(), ui::LatencyInfo(ui::SourceEventType::WHEEL));
synthetic_wheel.event.delta_x = delta.x();
synthetic_wheel.event.delta_y = delta.y();
synthetic_wheel.event.has_precise_scrolling_deltas = true;
@ -307,7 +308,7 @@ void FlingController::GenerateAndSendGestureScrollEvents(
WebInputEvent::Type type,
const gfx::Vector2dF& delta /* = gfx::Vector2dF() */) {
GestureEventWithLatencyInfo synthetic_gesture(
type, current_fling_parameters_.modifiers, base::TimeTicks::Now(),
type, current_fling_parameters_.modifiers, clock_->NowTicks(),
ui::LatencyInfo(ui::SourceEventType::INERTIAL));
synthetic_gesture.event.SetPositionInWidget(current_fling_parameters_.point);
synthetic_gesture.event.SetPositionInScreen(

@ -106,6 +106,8 @@ class CONTENT_EXPORT FlingController {
// Returns the |TouchpadTapSuppressionController| instance.
TouchpadTapSuppressionController* GetTouchpadTapSuppressionController();
void set_clock_for_testing(const base::TickClock* clock) { clock_ = clock; }
protected:
std::unique_ptr<ui::FlingBooster> fling_booster_;
@ -178,6 +180,9 @@ class CONTENT_EXPORT FlingController {
// for determining if the fling start time should be re-initialized.
bool has_fling_animation_started_;
// The clock used; overridable for tests.
const base::TickClock* clock_;
base::WeakPtrFactory<FlingController> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(FlingController);

@ -4,8 +4,10 @@
#include "content/browser/renderer_host/input/fling_controller.h"
#include "base/rand_util.h"
#include "base/run_loop.h"
#include "base/test/scoped_task_environment.h"
#include "base/test/simple_test_tick_clock.h"
#include "build/build_config.h"
#include "content/browser/renderer_host/input/gesture_event_queue.h"
#include "testing/gtest/include/gtest/gtest.h"
@ -16,6 +18,10 @@ using blink::WebGestureEvent;
using blink::WebInputEvent;
using blink::WebMouseWheelEvent;
namespace {
constexpr double kFrameDelta = 1000.0 / 60.0;
} // namespace
namespace content {
class FakeFlingController : public FlingController {
@ -51,6 +57,8 @@ class FlingControllerTest : public GestureEventQueueClient,
GestureEventQueue::Config());
fling_controller_ = std::make_unique<FakeFlingController>(
queue_.get(), this, this, FlingController::Config());
fling_controller_->set_clock_for_testing(&mock_clock_);
AdvanceTime();
}
// GestureEventQueueClient
@ -90,14 +98,19 @@ class FlingControllerTest : public GestureEventQueueClient,
}
void SimulateFlingStart(blink::WebGestureDevice source_device,
const gfx::Vector2dF& velocity) {
const gfx::Vector2dF& velocity,
bool wait_before_processing = true) {
scheduled_next_fling_progress_ = false;
sent_scroll_gesture_count_ = 0;
WebGestureEvent fling_start(WebInputEvent::kGestureFlingStart, 0,
base::TimeTicks::Now(), source_device);
NowTicks(), source_device);
fling_start.data.fling_start.velocity_x = velocity.x();
fling_start.data.fling_start.velocity_y = velocity.y();
GestureEventWithLatencyInfo fling_start_with_latency(fling_start);
if (wait_before_processing) {
// Wait for up to one frame before processing the event.
AdvanceTime(base::RandInt(0, static_cast<int>(kFrameDelta)));
}
if (!fling_controller_->FilterGestureEvent(fling_start_with_latency))
fling_controller_->ProcessGestureFlingStart(fling_start_with_latency);
}
@ -105,7 +118,7 @@ class FlingControllerTest : public GestureEventQueueClient,
void SimulateFlingCancel(blink::WebGestureDevice source_device) {
notified_client_after_fling_stop_ = false;
WebGestureEvent fling_cancel(WebInputEvent::kGestureFlingCancel, 0,
base::TimeTicks::Now(), source_device);
NowTicks(), source_device);
// autoscroll fling cancel doesn't allow fling boosting.
if (source_device == blink::kWebGestureDeviceSyntheticAutoscroll)
fling_cancel.data.fling_cancel.prevent_boosting = true;
@ -125,6 +138,12 @@ class FlingControllerTest : public GestureEventQueueClient,
bool FlingInProgress() { return fling_controller_->fling_in_progress(); }
bool FlingBoosted() { return fling_controller_->FlingBoosted(); }
void AdvanceTime(double time_delta_ms = kFrameDelta) {
mock_clock_.Advance(base::TimeDelta::FromMillisecondsD(time_delta_ms));
}
base::TimeTicks NowTicks() const { return mock_clock_.NowTicks(); }
protected:
std::unique_ptr<FakeFlingController> fling_controller_;
WebMouseWheelEvent last_sent_wheel_;
@ -136,6 +155,8 @@ class FlingControllerTest : public GestureEventQueueClient,
int sent_scroll_gesture_count_ = 0;
private:
base::SimpleTestTickClock mock_clock_;
bool needs_begin_frame_for_fling_progress_;
base::test::ScopedTaskEnvironment scoped_task_environment_;
std::unique_ptr<GestureEventQueue> queue_;
@ -163,9 +184,7 @@ TEST_P(FlingControllerTest,
EXPECT_EQ(WebInputEvent::kGestureScrollEnd, last_sent_gesture_.GetType());
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest, DISABLED_ControllerHandlesTouchpadGestureFling) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, ControllerHandlesTouchpadGestureFling) {
SimulateFlingStart(blink::kWebGestureDeviceTouchpad, gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// Processing GFS will send the first fling prgoress event if the time delta
@ -173,8 +192,8 @@ TEST_P(FlingControllerTest, DISABLED_ControllerHandlesTouchpadGestureFling) {
// is called is large enough.
bool process_GFS_sent_first_event = first_wheel_event_sent_;
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
if (!process_GFS_sent_first_event) {
EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, last_sent_wheel_.momentum_phase);
@ -185,8 +204,8 @@ TEST_P(FlingControllerTest, DISABLED_ControllerHandlesTouchpadGestureFling) {
EXPECT_GT(last_sent_wheel_.delta_x, 0.f);
// The rest of the wheel events must have momentum_phase == KPhaseChanged.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged, last_sent_wheel_.momentum_phase);
EXPECT_GT(last_sent_wheel_.delta_x, 0.f);
@ -196,24 +215,22 @@ TEST_P(FlingControllerTest, DISABLED_ControllerHandlesTouchpadGestureFling) {
EXPECT_TRUE(FlingInProgress());
// Wait for the boosting timer to expire. The delayed cancelation must work.
progress_time += base::TimeDelta::FromMilliseconds(500);
ProgressFling(progress_time);
AdvanceTime(500);
ProgressFling(NowTicks());
EXPECT_FALSE(FlingInProgress());
EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, last_sent_wheel_.momentum_phase);
EXPECT_EQ(0.f, last_sent_wheel_.delta_x);
EXPECT_EQ(0.f, last_sent_wheel_.delta_y);
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest, DISABLED_ControllerHandlesTouchscreenGestureFling) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, ControllerHandlesTouchscreenGestureFling) {
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// The fling progress will generate and send GSU events with inertial state.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
EXPECT_EQ(WebGestureEvent::kMomentumPhase,
last_sent_gesture_.data.scroll_update.inertial_phase);
@ -225,16 +242,13 @@ TEST_P(FlingControllerTest, DISABLED_ControllerHandlesTouchscreenGestureFling) {
EXPECT_TRUE(FlingInProgress());
// Wait for the boosting timer to expire. The delayed cancelation must work.
progress_time += base::TimeDelta::FromMilliseconds(500);
ProgressFling(progress_time);
AdvanceTime(500);
ProgressFling(NowTicks());
EXPECT_FALSE(FlingInProgress());
EXPECT_EQ(WebInputEvent::kGestureScrollEnd, last_sent_gesture_.GetType());
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest,
DISABLED_ControllerSendsWheelEndWhenTouchpadFlingIsOver) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, ControllerSendsWheelEndWhenTouchpadFlingIsOver) {
SimulateFlingStart(blink::kWebGestureDeviceTouchpad, gfx::Vector2dF(100, 0));
EXPECT_TRUE(FlingInProgress());
// Processing GFS will send the first fling prgoress event if the time delta
@ -242,8 +256,8 @@ TEST_P(FlingControllerTest,
// is called is large enough.
bool process_GFS_sent_first_event = first_wheel_event_sent_;
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
if (!process_GFS_sent_first_event) {
EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, last_sent_wheel_.momentum_phase);
} else {
@ -252,14 +266,14 @@ TEST_P(FlingControllerTest,
}
EXPECT_GT(last_sent_wheel_.delta_x, 0.f);
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
while (FlingInProgress()) {
EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged,
last_sent_wheel_.momentum_phase);
EXPECT_GT(last_sent_wheel_.delta_x, 0.f);
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
}
EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, last_sent_wheel_.momentum_phase);
@ -267,33 +281,28 @@ TEST_P(FlingControllerTest,
EXPECT_EQ(0.f, last_sent_wheel_.delta_y);
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest,
DISABLED_ControllerSendsGSEWhenTouchscreenFlingIsOver) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, ControllerSendsGSEWhenTouchscreenFlingIsOver) {
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(100, 0));
EXPECT_TRUE(FlingInProgress());
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
while (FlingInProgress()) {
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate,
last_sent_gesture_.GetType());
EXPECT_EQ(WebGestureEvent::kMomentumPhase,
last_sent_gesture_.data.scroll_update.inertial_phase);
EXPECT_GT(last_sent_gesture_.data.scroll_update.delta_x, 0.f);
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
}
EXPECT_EQ(WebInputEvent::kGestureScrollEnd, last_sent_gesture_.GetType());
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest,
DISABLED_EarlyTouchpadFlingCancelationOnInertialGSUAckNotConsumed) {
base::TimeTicks progress_time = base::TimeTicks::Now();
EarlyTouchpadFlingCancelationOnInertialGSUAckNotConsumed) {
SimulateFlingStart(blink::kWebGestureDeviceTouchpad, gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// Processing GFS will send the first fling prgoress event if the time delta
@ -301,8 +310,8 @@ TEST_P(FlingControllerTest,
// is called is large enough.
bool process_GFS_sent_first_event = first_wheel_event_sent_;
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
if (!process_GFS_sent_first_event) {
EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, last_sent_wheel_.momentum_phase);
} else {
@ -313,7 +322,7 @@ TEST_P(FlingControllerTest,
// A non-consumed GSU ack in inertial state cancels out the rest of the fling.
WebGestureEvent scroll_update(WebInputEvent::kGestureScrollUpdate, 0,
base::TimeTicks::Now());
NowTicks());
scroll_update.data.scroll_update.inertial_phase =
WebGestureEvent::kMomentumPhase;
@ -326,15 +335,13 @@ TEST_P(FlingControllerTest,
EXPECT_EQ(0.f, last_sent_wheel_.delta_y);
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest,
DISABLED_EarlyTouchscreenFlingCancelationOnInertialGSUAckNotConsumed) {
base::TimeTicks progress_time = base::TimeTicks::Now();
EarlyTouchscreenFlingCancelationOnInertialGSUAckNotConsumed) {
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
EXPECT_EQ(WebGestureEvent::kMomentumPhase,
last_sent_gesture_.data.scroll_update.inertial_phase);
@ -342,7 +349,7 @@ TEST_P(FlingControllerTest,
// A non-consumed GSU ack in inertial state cancels out the rest of the fling.
WebGestureEvent scroll_update(WebInputEvent::kGestureScrollUpdate, 0,
base::TimeTicks::Now());
NowTicks());
scroll_update.data.scroll_update.inertial_phase =
WebGestureEvent::kMomentumPhase;
@ -353,9 +360,7 @@ TEST_P(FlingControllerTest,
EXPECT_EQ(WebInputEvent::kGestureScrollEnd, last_sent_gesture_.GetType());
}
// Flaky. https://crbug.com/836996.
TEST_P(FlingControllerTest, DISABLED_EarlyTouchpadFlingCancelationOnFlingStop) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, EarlyTouchpadFlingCancelationOnFlingStop) {
SimulateFlingStart(blink::kWebGestureDeviceTouchpad, gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// Processing GFS will send the first fling prgoress event if the time delta
@ -363,8 +368,8 @@ TEST_P(FlingControllerTest, DISABLED_EarlyTouchpadFlingCancelationOnFlingStop) {
// is called is large enough.
bool process_GFS_sent_first_event = first_wheel_event_sent_;
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
if (!process_GFS_sent_first_event) {
EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, last_sent_wheel_.momentum_phase);
} else {
@ -380,17 +385,14 @@ TEST_P(FlingControllerTest, DISABLED_EarlyTouchpadFlingCancelationOnFlingStop) {
EXPECT_EQ(0.f, last_sent_wheel_.delta_y);
}
// Flaky. https://crbug.com/886992
TEST_P(FlingControllerTest,
DISABLED_EarlyTouchscreenFlingCancelationOnFlingStop) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, EarlyTouchscreenFlingCancelationOnFlingStop) {
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// progress fling must send GSU events.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
EXPECT_EQ(WebGestureEvent::kMomentumPhase,
last_sent_gesture_.data.scroll_update.inertial_phase);
@ -419,24 +421,21 @@ TEST_P(FlingControllerTest, GestureFlingCancelsFiltered) {
EXPECT_TRUE(last_fling_cancel_filtered_);
}
// Flaky. https://crbug.com/836996.
TEST_P(FlingControllerTest, DISABLED_GestureFlingNotCancelledBySmallTimeDelta) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, GestureFlingNotCancelledBySmallTimeDelta) {
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
gfx::Vector2dF(1000, 0), false);
EXPECT_TRUE(FlingInProgress());
int current_sent_scroll_gesture_count = sent_scroll_gesture_count_;
// If we the first progress tick happens too close to the fling_start time,
// the controller won't send any GSU events, but the fling is still active.
// progress_time += base::TimeDelta::FromMilliseconds(1);
ProgressFling(progress_time);
EXPECT_EQ(blink::kWebGestureDeviceUninitialized,
last_sent_gesture_.SourceDevice());
ProgressFling(NowTicks());
EXPECT_EQ(current_sent_scroll_gesture_count, sent_scroll_gesture_count_);
EXPECT_TRUE(FlingInProgress());
// The rest of the progress flings must advance the fling normally.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
EXPECT_EQ(blink::kWebGestureDeviceTouchscreen,
last_sent_gesture_.SourceDevice());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
@ -445,9 +444,9 @@ TEST_P(FlingControllerTest, DISABLED_GestureFlingNotCancelledBySmallTimeDelta) {
EXPECT_GT(last_sent_gesture_.data.scroll_update.delta_x, 0.f);
}
// TODO(https://crbug.com/836996): Timing-dependent flakes on some platforms.
TEST_P(FlingControllerTest, DISABLED_GestureFlingWithNegativeTimeDelta) {
base::TimeTicks progress_time = base::TimeTicks::Now();
TEST_P(FlingControllerTest, GestureFlingWithNegativeTimeDelta) {
base::TimeTicks initial_time = NowTicks();
AdvanceTime();
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
@ -456,13 +455,12 @@ TEST_P(FlingControllerTest, DISABLED_GestureFlingWithNegativeTimeDelta) {
// If we get a negative time delta, that is, the Progress tick time happens
// before the fling's start time then we should *not* try progressing the
// fling.
progress_time -= base::TimeDelta::FromMilliseconds(5);
ProgressFling(progress_time);
ProgressFling(initial_time);
EXPECT_EQ(current_sent_scroll_gesture_count, sent_scroll_gesture_count_);
// The rest of the progress flings must advance the fling normally.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
EXPECT_EQ(blink::kWebGestureDeviceTouchscreen,
last_sent_gesture_.SourceDevice());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
@ -478,7 +476,6 @@ TEST_P(FlingControllerTest, DISABLED_GestureFlingWithNegativeTimeDelta) {
#define MAYBE_ControllerBoostsTouchpadFling ControllerBoostsTouchpadFling
#endif
TEST_P(FlingControllerTest, MAYBE_ControllerBoostsTouchpadFling) {
base::TimeTicks progress_time = base::TimeTicks::Now();
SimulateFlingStart(blink::kWebGestureDeviceTouchpad, gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// Processing GFS will send the first fling prgoress event if the time delta
@ -486,8 +483,8 @@ TEST_P(FlingControllerTest, MAYBE_ControllerBoostsTouchpadFling) {
// is called is large enough.
bool process_GFS_sent_first_event = first_wheel_event_sent_;
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
if (!process_GFS_sent_first_event) {
EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, last_sent_wheel_.momentum_phase);
} else {
@ -497,8 +494,8 @@ TEST_P(FlingControllerTest, MAYBE_ControllerBoostsTouchpadFling) {
EXPECT_GT(last_sent_wheel_.delta_x, 0.f);
// The rest of the wheel events must have momentum_phase == KPhaseChanged.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged, last_sent_wheel_.momentum_phase);
EXPECT_GT(last_sent_wheel_.delta_x, 0.f);
@ -514,14 +511,12 @@ TEST_P(FlingControllerTest, MAYBE_ControllerBoostsTouchpadFling) {
}
TEST_P(FlingControllerTest, ControllerBoostsTouchscreenFling) {
base::TimeTicks progress_time = base::TimeTicks::Now();
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
// Fling progress must send GSU events.
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
EXPECT_EQ(WebGestureEvent::kMomentumPhase,
last_sent_gesture_.data.scroll_update.inertial_phase);
@ -540,7 +535,6 @@ TEST_P(FlingControllerTest, ControllerBoostsTouchscreenFling) {
}
TEST_P(FlingControllerTest, ControllerNotifiesTheClientAfterFlingStart) {
base::TimeTicks progress_time = base::TimeTicks::Now();
SimulateFlingStart(blink::kWebGestureDeviceTouchscreen,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
@ -552,21 +546,20 @@ TEST_P(FlingControllerTest, ControllerNotifiesTheClientAfterFlingStart) {
// Wait for the boosting timer to expire. The delayed cancelation must work
// and the client must be notified after fling cancelation.
progress_time += base::TimeDelta::FromMilliseconds(500);
ProgressFling(progress_time);
AdvanceTime(500);
ProgressFling(NowTicks());
EXPECT_FALSE(FlingInProgress());
EXPECT_EQ(WebInputEvent::kGestureScrollEnd, last_sent_gesture_.GetType());
EXPECT_TRUE(notified_client_after_fling_stop_);
}
TEST_P(FlingControllerTest, MiddleClickAutoScrollFling) {
base::TimeTicks progress_time = base::TimeTicks::Now();
SimulateFlingStart(blink::kWebGestureDeviceSyntheticAutoscroll,
gfx::Vector2dF(1000, 0));
EXPECT_TRUE(FlingInProgress());
progress_time += base::TimeDelta::FromMilliseconds(17);
ProgressFling(progress_time);
AdvanceTime();
ProgressFling(NowTicks());
ASSERT_EQ(WebInputEvent::kGestureScrollUpdate, last_sent_gesture_.GetType());
EXPECT_EQ(WebGestureEvent::kMomentumPhase,
last_sent_gesture_.data.scroll_update.inertial_phase);

@ -33,9 +33,6 @@
namespace content {
using base::Time;
using base::TimeDelta;
using base::TimeTicks;
using blink::WebGestureEvent;
using blink::WebInputEvent;
using blink::WebKeyboardEvent;