blob: fb8d81cd8d35f0334d3963c47c0bebb8c1312920 [file] [log] [blame]
// Copyright 2018 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/renderer/input/input_event_prediction.h"
#include "base/feature_list.h"
#include "base/metrics/field_trial.h"
#include "base/metrics/field_trial_params.h"
#include "base/metrics/histogram_functions.h"
#include "content/public/common/content_features.h"
#include "ui/events/blink/prediction/empty_predictor.h"
#include "ui/events/blink/prediction/kalman_predictor.h"
#include "ui/events/blink/prediction/least_squares_predictor.h"
using blink::WebInputEvent;
using blink::WebMouseEvent;
using blink::WebPointerEvent;
using blink::WebPointerProperties;
using blink::WebTouchEvent;
namespace content {
namespace {
constexpr char kPredictor[] = "predictor";
constexpr char kInputEventPredictorTypeLsq[] = "lsq";
constexpr char kInputEventPredictorTypeKalman[] = "kalman";
constexpr uint32_t kPredictEventCount = 3;
constexpr base::TimeDelta kPredictionInterval =
base::TimeDelta::FromMilliseconds(8);
} // namespace
InputEventPrediction::InputEventPrediction(bool enable_resampling)
: enable_resampling_(enable_resampling) {
SetUpPredictorType();
}
InputEventPrediction::~InputEventPrediction() {}
void InputEventPrediction::SetUpPredictorType() {
// When resampling is enabled, set predictor type by resampling flag params;
// otherwise, get predictor type parameters from kInputPredictorTypeChoice
// flag.
std::string predictor_type =
enable_resampling_ ? GetFieldTrialParamValueByFeature(
features::kResamplingInputEvents, kPredictor)
: GetFieldTrialParamValueByFeature(
features::kInputPredictorTypeChoice, kPredictor);
if (predictor_type == kInputEventPredictorTypeLsq)
selected_predictor_type_ = PredictorType::kLsq;
else if (predictor_type == kInputEventPredictorTypeKalman)
selected_predictor_type_ = PredictorType::kKalman;
else
selected_predictor_type_ = PredictorType::kEmpty;
mouse_predictor_ = CreatePredictor();
}
void InputEventPrediction::HandleEvents(
blink::WebCoalescedInputEvent& coalesced_event,
base::TimeTicks frame_time) {
switch (coalesced_event.Event().GetType()) {
case WebInputEvent::kMouseMove:
case WebInputEvent::kTouchMove:
case WebInputEvent::kPointerMove: {
size_t coalesced_size = coalesced_event.CoalescedEventSize();
for (size_t i = 0; i < coalesced_size; i++)
ComputeAccuracy(coalesced_event.CoalescedEvent(i));
for (size_t i = 0; i < coalesced_size; i++)
UpdatePrediction(coalesced_event.CoalescedEvent(i));
if (enable_resampling_)
ApplyResampling(frame_time, coalesced_event.EventPointer());
base::TimeTicks predict_time =
enable_resampling_
? coalesced_event.EventPointer()->TimeStamp() +
kPredictionInterval
: std::max(frame_time,
coalesced_event.EventPointer()->TimeStamp());
for (uint32_t i = 0; i < kPredictEventCount; i++) {
if (!AddPredictedEvent(predict_time, coalesced_event))
break;
predict_time += kPredictionInterval;
}
break;
}
case WebInputEvent::kTouchScrollStarted:
case WebInputEvent::kPointerCausedUaAction:
pointer_id_predictor_map_.clear();
break;
default:
ResetPredictor(coalesced_event.Event());
}
}
std::unique_ptr<ui::InputPredictor> InputEventPrediction::CreatePredictor()
const {
switch (selected_predictor_type_) {
case PredictorType::kEmpty:
return std::make_unique<ui::EmptyPredictor>();
case PredictorType::kLsq:
return std::make_unique<ui::LeastSquaresPredictor>();
case PredictorType::kKalman:
return std::make_unique<ui::KalmanPredictor>();
}
}
void InputEventPrediction::UpdatePrediction(const WebInputEvent& event) {
if (WebInputEvent::IsTouchEventType(event.GetType())) {
DCHECK(event.GetType() == WebInputEvent::kTouchMove);
const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
for (unsigned i = 0; i < touch_event.touches_length; ++i) {
if (touch_event.touches[i].state == blink::WebTouchPoint::kStateMoved) {
UpdateSinglePointer(touch_event.touches[i], touch_event.TimeStamp());
}
}
} else if (WebInputEvent::IsMouseEventType(event.GetType())) {
DCHECK(event.GetType() == WebInputEvent::kMouseMove);
UpdateSinglePointer(static_cast<const WebMouseEvent&>(event),
event.TimeStamp());
} else if (WebInputEvent::IsPointerEventType(event.GetType())) {
DCHECK(event.GetType() == WebInputEvent::kPointerMove);
UpdateSinglePointer(static_cast<const WebPointerEvent&>(event),
event.TimeStamp());
}
last_event_timestamp_ = event.TimeStamp();
}
void InputEventPrediction::ApplyResampling(base::TimeTicks frame_time,
WebInputEvent* event) {
if (event->GetType() == WebInputEvent::kTouchMove) {
WebTouchEvent* touch_event = static_cast<WebTouchEvent*>(event);
for (unsigned i = 0; i < touch_event->touches_length; ++i) {
if (GetPointerPrediction(frame_time, &touch_event->touches[i]))
event->SetTimeStamp(frame_time);
}
} else if (event->GetType() == WebInputEvent::kMouseMove) {
if (GetPointerPrediction(frame_time, static_cast<WebMouseEvent*>(event)))
event->SetTimeStamp(frame_time);
} else if (event->GetType() == WebInputEvent::kPointerMove) {
if (GetPointerPrediction(frame_time, static_cast<WebPointerEvent*>(event)))
event->SetTimeStamp(frame_time);
}
}
void InputEventPrediction::ResetPredictor(const WebInputEvent& event) {
if (WebInputEvent::IsTouchEventType(event.GetType())) {
const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
for (unsigned i = 0; i < touch_event.touches_length; ++i) {
if (touch_event.touches[i].state != blink::WebTouchPoint::kStateMoved &&
touch_event.touches[i].state !=
blink::WebTouchPoint::kStateStationary)
pointer_id_predictor_map_.erase(touch_event.touches[i].id);
}
} else if (WebInputEvent::IsMouseEventType(event.GetType())) {
ResetSinglePredictor(static_cast<const WebMouseEvent&>(event));
} else if (WebInputEvent::IsPointerEventType(event.GetType())) {
ResetSinglePredictor(static_cast<const WebPointerEvent&>(event));
}
}
bool InputEventPrediction::AddPredictedEvent(
base::TimeTicks predict_time,
blink::WebCoalescedInputEvent& coalesced_event) {
ui::WebScopedInputEvent predicted_event =
ui::WebInputEventTraits::Clone(coalesced_event.Event());
bool success = false;
if (predicted_event->GetType() == WebInputEvent::kTouchMove) {
WebTouchEvent& touch_event = static_cast<WebTouchEvent&>(*predicted_event);
success = true;
for (unsigned i = 0; i < touch_event.touches_length; ++i) {
if (!GetPointerPrediction(predict_time, &touch_event.touches[i]))
success = false;
}
} else if (predicted_event->GetType() == WebInputEvent::kMouseMove) {
if (GetPointerPrediction(predict_time,
&static_cast<WebMouseEvent&>(*predicted_event)))
success = true;
} else if (predicted_event->GetType() == WebInputEvent::kPointerMove) {
if (GetPointerPrediction(predict_time,
&static_cast<WebPointerEvent&>(*predicted_event)))
success = true;
}
if (success) {
predicted_event->SetTimeStamp(predict_time);
coalesced_event.AddPredictedEvent(*predicted_event);
}
return success;
}
void InputEventPrediction::UpdateSinglePointer(
const WebPointerProperties& event,
base::TimeTicks event_time) {
ui::InputPredictor::InputData data = {event.PositionInWidget(), event_time};
if (event.pointer_type == WebPointerProperties::PointerType::kMouse)
mouse_predictor_->Update(data);
else {
auto predictor = pointer_id_predictor_map_.find(event.id);
if (predictor != pointer_id_predictor_map_.end()) {
predictor->second->Update(data);
} else {
// Workaround for GLIBC C++ < 7.3 that fails to insert with braces
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82522
auto pair = std::make_pair(event.id, CreatePredictor());
pointer_id_predictor_map_.insert(std::move(pair));
pointer_id_predictor_map_[event.id]->Update(data);
}
}
}
bool InputEventPrediction::GetPointerPrediction(base::TimeTicks predict_time,
WebPointerProperties* event) {
ui::InputPredictor::InputData predict_result;
if (event->pointer_type == WebPointerProperties::PointerType::kMouse) {
if (mouse_predictor_->HasPrediction() &&
mouse_predictor_->GeneratePrediction(predict_time, &predict_result)) {
event->SetPositionInWidget(predict_result.pos);
return true;
}
} else {
// Reset mouse predictor if pointer type is touch or stylus
mouse_predictor_->Reset();
auto predictor = pointer_id_predictor_map_.find(event->id);
if (predictor != pointer_id_predictor_map_.end() &&
predictor->second->HasPrediction() &&
predictor->second->GeneratePrediction(predict_time, &predict_result)) {
event->SetPositionInWidget(predict_result.pos);
return true;
}
}
return false;
}
void InputEventPrediction::ResetSinglePredictor(
const WebPointerProperties& event) {
if (event.pointer_type == WebPointerProperties::PointerType::kMouse)
mouse_predictor_->Reset();
else
pointer_id_predictor_map_.erase(event.id);
}
void InputEventPrediction::ComputeAccuracy(const WebInputEvent& event) const {
base::TimeDelta time_delta = event.TimeStamp() - last_event_timestamp_;
std::string suffix;
if (time_delta < base::TimeDelta::FromMilliseconds(10))
suffix = "Short";
else if (time_delta < base::TimeDelta::FromMilliseconds(20))
suffix = "Middle";
else if (time_delta < base::TimeDelta::FromMilliseconds(35))
suffix = "Long";
else
return;
ui::InputPredictor::InputData predict_result;
if (event.GetType() == WebInputEvent::kTouchMove) {
const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
for (unsigned i = 0; i < touch_event.touches_length; ++i) {
if (touch_event.touches[i].state == blink::WebTouchPoint::kStateMoved) {
auto predictor =
pointer_id_predictor_map_.find(touch_event.touches[i].id);
if (predictor != pointer_id_predictor_map_.end() &&
predictor->second->HasPrediction() &&
predictor->second->GeneratePrediction(event.TimeStamp(),
&predict_result)) {
float distance =
(predict_result.pos -
gfx::PointF(touch_event.touches[i].PositionInWidget()))
.Length();
base::UmaHistogramCounts1000(
"Event.InputEventPrediction.Accuracy.Touch." + suffix,
static_cast<int>(distance));
}
}
}
} else if (event.GetType() == WebInputEvent::kMouseMove) {
const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
if (mouse_predictor_->HasPrediction() &&
mouse_predictor_->GeneratePrediction(event.TimeStamp(),
&predict_result)) {
float distance =
(predict_result.pos - gfx::PointF(mouse_event.PositionInWidget()))
.Length();
base::UmaHistogramCounts1000(
"Event.InputEventPrediction.Accuracy.Mouse." + suffix,
static_cast<int>(distance));
}
}
}
} // namespace content