Blame - ui/latency/average_lag_tracker_unittest.cc - chromium/src

2019-04-05 17:32:15

[diff] [blame]

1

2

// Use of this source code is governed by a BSD-style license that can be

3

// found in the LICENSE file.

4

5

#include "ui/latency/average_lag_tracker.h"

6

7

#include "base/test/metrics/histogram_tester.h"

8

#include "testing/gmock/include/gmock/gmock.h"

9

#include "testing/gtest/include/gtest/gtest.h"

10

11

using base::Bucket;

12

using testing::ElementsAre;

namespace ui {

namespace {

class AverageLagTrackerTest : public testing::Test {

18

public:

19

AverageLagTrackerTest() { ResetHistograms(); }

20

21

void ResetHistograms() {

Peter Boström

f238104

2019-08-27 00:25:03

[diff] [blame^]

22

histogram_tester_ = std::make_unique<base::HistogramTester>();

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

23

}

24

25

const base::HistogramTester& histogram_tester() { return *histogram_tester_; }

26

27

void SetUp() override {

28

average_lag_tracker_ = std::make_unique<AverageLagTracker>();

29

}

30

31

void SyntheticTouchScrollBeginLatencyInfo(base::TimeTicks event_time,

32

base::TimeTicks frame_time,

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

33

float delta,

34

float predicted_delta = 0) {

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

35

ui::LatencyInfo touch_latency(ui::SourceEventType::TOUCH);

36

touch_latency.set_scroll_update_delta(delta);

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

37

touch_latency.set_predicted_scroll_update_delta(

38

predicted_delta != 0 ? predicted_delta : delta);

39

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

40

touch_latency.AddLatencyNumberWithTimestamp(

41

ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT,

Sadrul Habib Chowdhury

2019-07-08 22:48:00

[diff] [blame]

42

event_time);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

43

touch_latency.AddLatencyNumberWithTimestamp(

Sadrul Habib Chowdhury

2019-07-08 22:48:00

[diff] [blame]

44

ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT_COMPONENT, event_time);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

45

average_lag_tracker_->AddLatencyInFrame(touch_latency, frame_time,

"ScrollBegin");

}

void SyntheticTouchScrollUpdateLatencyInfo(base::TimeTicks event_time,

50

base::TimeTicks frame_time,

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

51

float delta,

52

float predicted_delta = 0) {

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

53

ui::LatencyInfo touch_latency(ui::SourceEventType::TOUCH);

54

touch_latency.set_scroll_update_delta(delta);

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

55

touch_latency.set_predicted_scroll_update_delta(

56

predicted_delta != 0 ? predicted_delta : delta);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

57

touch_latency.AddLatencyNumberWithTimestamp(

Sadrul Habib Chowdhury

2019-07-08 22:48:00

[diff] [blame]

58

ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT, event_time);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

59

touch_latency.AddLatencyNumberWithTimestamp(

Sadrul Habib Chowdhury

2019-07-08 22:48:00

[diff] [blame]

60

ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT_COMPONENT, event_time);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

61

average_lag_tracker_->AddLatencyInFrame(touch_latency, frame_time,

"ScrollUpdate");

}

protected:

std::unique_ptr<AverageLagTracker> average_lag_tracker_;

67

68

std::unique_ptr<base::HistogramTester> histogram_tester_;

69

};

70

71

base::TimeTicks MillisecondsToTimeTicks(float t_ms) {

72

return base::TimeTicks() + base::TimeDelta::FromMilliseconds(t_ms);

73

}

74

75

// Simulate a simple situation that events at every 10ms and start at t=15ms,

76

// frame swaps at every 10ms too and start at t=20ms and test we record one

77

// UMA for ScrollUpdate in one second.

78

TEST_F(AverageLagTrackerTest, OneSecondInterval) {

79

base::TimeTicks event_time =

80

base::TimeTicks() + base::TimeDelta::FromMilliseconds(5);

81

base::TimeTicks frame_time =

82

base::TimeTicks() + base::TimeDelta::FromMilliseconds(10);

83

float scroll_delta = 10;

84

85

// ScrollBegin

86

event_time += base::TimeDelta::FromMilliseconds(10); // 15ms

87

frame_time += base::TimeDelta::FromMilliseconds(10); // 20ms

88

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, scroll_delta);

89

90

// Send 101 ScrollUpdate events to verify that there is 1 AverageLag record

91

// per 1 second.

92

const int kUpdates = 101;

93

for (int i = 0; i < kUpdates; i++) {

94

event_time += base::TimeDelta::FromMilliseconds(10);

95

frame_time += base::TimeDelta::FromMilliseconds(10);

96

// First 50 has positive delta, others negetive delta.

97

const int sign = (i < kUpdates / 2) ? 1 : -1;

98

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

99

sign * scroll_delta);

100

}

101

102

// ScrollBegin report_time is at 20ms, so the next ScrollUpdate report_time is

103

// at 1020ms. The last event_time that finish this report should be later than

104

// 1020ms.

105

EXPECT_EQ(event_time,

106

base::TimeTicks() + base::TimeDelta::FromMilliseconds(1025));

107

EXPECT_EQ(frame_time,

108

base::TimeTicks() + base::TimeDelta::FromMilliseconds(1030));

109

110

// ScrollBegin AverageLag are the area between the event original component

111

// (time=15ms, delta=10px) to the frame swap time (time=20ms, expect finger

112

// position at delta=15px). The AverageLag scaled to 1 second is

113

// (0.5*(10px+15px)*5ms)/5ms = 12.5px.

114

EXPECT_THAT(histogram_tester().GetAllSamples(

115

"Event.Latency.ScrollBegin.Touch.AverageLag"),

116

ElementsAre(Bucket(12, 1)));

117

// This ScrollUpdate AverageLag are calculated as the finger uniformly scroll

118

// 10px each frame. For scroll up/down frame, the Lag at the last frame swap

119

// is 5px, and Lag at this frame swap is 15px. For the one changing direction,

120

// the Lag is from 5 to 10 and down to 5 again. So total LagArea is 99 * 100,

121

// plus 75. the AverageLag in 1 second is 9.975px.

122

EXPECT_THAT(histogram_tester().GetAllSamples(

123

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

124

ElementsAre(Bucket(9, 1)));

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

125

EXPECT_THAT(

126

histogram_tester().GetAllSamples(

127

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionPositive"),

128

ElementsAre(Bucket(0, 1)));

129

histogram_tester().ExpectTotalCount(

130

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionNegative", 0);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

131

ResetHistograms();

132

133

// Send another ScrollBegin to end the unfinished ScrollUpdate report.

134

event_time += base::TimeDelta::FromMilliseconds(10);

135

frame_time += base::TimeDelta::FromMilliseconds(10);

136

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, scroll_delta);

137

138

// The last ScrollUpdate's lag is 8.75px and truncated to 8.

139

EXPECT_THAT(histogram_tester().GetAllSamples(

140

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

141

ElementsAre(Bucket(8, 1)));

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

142

EXPECT_THAT(

143

histogram_tester().GetAllSamples(

144

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionPositive"),

145

ElementsAre(Bucket(0, 1)));

146

histogram_tester().ExpectTotalCount(

147

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionNegative", 0);

Ella Ge

2019-04-05 17:32:15

[diff] [blame]

148

}

149

150

// Test the case that event's frame swap time is later than next event's

151

// creation time. (i.e, event at t=10ms will be dispatch at t=30ms, while next

152

// event is at t=20ms).

153

TEST_F(AverageLagTrackerTest, LargerLatency) {

154

base::TimeTicks event_time = MillisecondsToTimeTicks(10);

155

base::TimeTicks frame_time =

156

event_time + base::TimeDelta::FromMilliseconds(20);

157

float scroll_delta = 10;

158

159

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, scroll_delta);

160

161

// Send 2 ScrollUpdate. The second one will record AverageLag.ScrollBegin as

162

// it's event_time is larger or equal to ScrollBegin's frame_time.

163

for (int i = 0; i < 2; i++) {

164

event_time += base::TimeDelta::FromMilliseconds(10);

165

frame_time = event_time + base::TimeDelta::FromMilliseconds(20);

166

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time, scroll_delta);

167

}

168

169

// ScrollBegin AveragLag are from t=10ms to t=30ms, with absolute scroll

170

// position from 10 to 30. The AverageLag should be:

171

// (0.5*(10px + 30px)*20ms/20ms) = 20px.

172

EXPECT_THAT(histogram_tester().GetAllSamples(

173

"Event.Latency.ScrollBegin.Touch.AverageLag"),

174

ElementsAre(Bucket(20, 1)));

175

176

// Another ScrollBegin to flush unfinished frames.

177

// event_time doesn't matter here because the previous frames' lag are

178

// compute from their frame_time.

179

event_time = MillisecondsToTimeTicks(1000);

180

frame_time = MillisecondsToTimeTicks(1000);

181

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, scroll_delta);

182

// The to unfinished frames' lag are (finger_positon-rendered_position)*time,

183

// AverageLag is ((30px-10px)*10ms+(30px-20px)*10ms)/20ms = 15px.

184

EXPECT_THAT(histogram_tester().GetAllSamples(

185

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

186

ElementsAre(Bucket(14, 1)));

187

}

188

189

// Test that multiple latency being flush in the same frame swap.

190

TEST_F(AverageLagTrackerTest, TwoLatencyInfoInSameFrame) {

191

// ScrollBegin

192

base::TimeTicks event_time = MillisecondsToTimeTicks(10);

193

base::TimeTicks frame_time = MillisecondsToTimeTicks(20);

194

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time,

195

-10 /* scroll_delta */);

196

197

// ScrollUpdate with event_time >= ScrollBegin frame_time will generate

198

// a histogram for AverageLag.ScrollBegin.

199

event_time = MillisecondsToTimeTicks(20);

200

frame_time = MillisecondsToTimeTicks(30);

201

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

202

-10 /* scroll_delta */);

203

204

// Absolute position from -10 to -20. The AverageLag should be:

205

// (0.5*(10px + 20px)*10ms/10ms) = 15px.

206

EXPECT_THAT(histogram_tester().GetAllSamples(

207

"Event.Latency.ScrollBegin.Touch.AverageLag"),

208

ElementsAre(Bucket(14, 1)));

209

210

event_time = MillisecondsToTimeTicks(25);

211

frame_time = MillisecondsToTimeTicks(30);

212

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

213

5 /* scroll_delta */);

214

215

// Another ScrollBegin to flush unfinished frames.

216

event_time = MillisecondsToTimeTicks(1000);

217

frame_time = MillisecondsToTimeTicks(1000);

218

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

219

220

// The ScrollUpdates are at t=20ms, finger_pos=-20px, rendered_pos=-10px,

221

// at t=25ms, finger_pos=-15px, rendered_pos=-10px;

222

// To t=30ms both events get flush.

223

// AverageLag is (0.5*(10px+5px)*5ms + 5px*5ms)/10ms = 6.25px

224

EXPECT_THAT(histogram_tester().GetAllSamples(

225

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

226

ElementsAre(Bucket(6, 1)));

227

}

228

229

// Test the case that switching direction causes lag at current frame

230

// time and previous frame time are in different direction.

231

TEST_F(AverageLagTrackerTest, ChangeDirectionInFrame) {

232

// ScrollBegin

233

base::TimeTicks event_time = MillisecondsToTimeTicks(10);

234

base::TimeTicks frame_time = MillisecondsToTimeTicks(20);

235

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time,

236

10 /* scroll_delta */);

237

238

// At t=20, lag = 10px.

239

event_time = MillisecondsToTimeTicks(20);

240

frame_time = MillisecondsToTimeTicks(30);

241

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

242

10 /* scroll_delta */);

243

244

// At t=30, lag = -10px.

245

event_time = MillisecondsToTimeTicks(30);

246

frame_time = MillisecondsToTimeTicks(40);

247

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

248

-20 /* scroll_delta */);

249

250

// Another ScrollBegin to flush unfinished frames.

251

event_time = MillisecondsToTimeTicks(1000);

252

frame_time = MillisecondsToTimeTicks(1000);

253

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

254

255

// From t=20 to t=30, lag_area=2*(0.5*10px*5ms)=50px*ms.

256

// From t=30 to t=40, lag_area=20px*10ms=200px*ms

257

// AverageLag = (50+200)/20 = 12.5px.

258

EXPECT_THAT(histogram_tester().GetAllSamples(

259

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

260

ElementsAre(Bucket(12, 1)));

261

}

262

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

263

// A simple case without scroll prediction to compare with the two with

264

// prediction cases below.

265

TEST_F(AverageLagTrackerTest, NoScrollPrediction) {

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

266

// ScrollBegin, at t=5, finger_pos=5px.

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

267

base::TimeTicks event_time = MillisecondsToTimeTicks(5);

268

base::TimeTicks frame_time = MillisecondsToTimeTicks(10);

269

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time,

270

5 /* scroll_delta */);

271

272

// ScrollUpdate, at t=15, finger_pos=15px.

273

event_time = MillisecondsToTimeTicks(15);

274

frame_time = MillisecondsToTimeTicks(20);

275

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

276

10 /* scroll_delta */);

277

278

// ScrollUpdate, at t=25, finger_pos=25px.

279

event_time = MillisecondsToTimeTicks(25);

280

frame_time = MillisecondsToTimeTicks(30);

281

SyntheticTouchScrollUpdateLatencyInfo(event_time, frame_time,

282

10 /* scroll_delta */);

283

284

// Another ScrollBegin to flush unfinished frames.

285

event_time = MillisecondsToTimeTicks(1000);

286

frame_time = MillisecondsToTimeTicks(1000);

287

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

288

289

// Prediction hasn't take affect on ScrollBegin so it'll stay the same.

290

EXPECT_THAT(histogram_tester().GetAllSamples(

291

"Event.Latency.ScrollBegin.Touch.AverageLag"),

292

ElementsAre(Bucket(7, 1)));

293

// At t=10, finger_pos = 10px, rendered_pos = 5px.

294

// At t=20, finger_pos = 20px, rendered_pos = 15px.

295

// At t=30, finger_pos = 25px, rendered_pos = 25px.

296

// AverageLag = ((5px+15px)*10ms/2 + (5px+10px)*5ms/2 + 10px*5ms)/20ms

297

// = 9.375

298

EXPECT_THAT(histogram_tester().GetAllSamples(

299

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

300

ElementsAre(Bucket(9, 1)));

301

}

302

303

// Test AverageLag with perfect scroll prediction.

304

TEST_F(AverageLagTrackerTest, ScrollPrediction) {

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

305

// ScrollBegin, at t=5, finger_pos=5px.

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

306

// Predict frame_time=10, predicted_pos = 10px.

307

base::TimeTicks event_time = MillisecondsToTimeTicks(5);

308

base::TimeTicks frame_time = MillisecondsToTimeTicks(10);

309

SyntheticTouchScrollBeginLatencyInfo(

310

event_time, frame_time, 5 /* scroll_delta */, 10 /* predicted_delta */);

311

312

// ScrollUpdate, at t=15, finger_pos=15px.

313

// Predict frame_time=20, predicted_pos = 20px.

314

event_time = MillisecondsToTimeTicks(15);

315

frame_time = MillisecondsToTimeTicks(20);

316

SyntheticTouchScrollUpdateLatencyInfo(

317

event_time, frame_time, 10 /* scroll_delta */, 10 /* predicted_delta */);

318

319

// ScrollUpdate, at t=25, finger_pos=25px.

320

// Predict frame_time=30, predicted_pos = 30px.

321

event_time = MillisecondsToTimeTicks(25);

322

frame_time = MillisecondsToTimeTicks(30);

323

SyntheticTouchScrollUpdateLatencyInfo(

324

event_time, frame_time, 10 /* scroll_delta */, 10 /* predicted_delta */);

325

326

// Another ScrollBegin to flush unfinished frames.

327

event_time = MillisecondsToTimeTicks(1000);

328

frame_time = MillisecondsToTimeTicks(1000);

329

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

330

331

// Prediction hasn't take affect on ScrollBegin so it'll stay the same.

332

EXPECT_THAT(histogram_tester().GetAllSamples(

333

"Event.Latency.ScrollBegin.Touch.AverageLag"),

334

ElementsAre(Bucket(7, 1)));

335

// At t=10, finger_pos = 10px, rendered_pos = 10px.

336

// At t=20, finger_pos = 20px, rendered_pos = 20px.

337

// At t=30, finger_pos = 25px, rendered_pos = 30px.

338

// AverageLag = ((0px+10px)*10ms/2 + (0px+5px)*10ms/2 + 5px*5ms)/20ms

339

// = 4.375px

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

340

// AverageLag (w/o prediction)

341

// ((5px+15px)*10ms/2 + (5px+10px)*5ms/2 + 10px*5ms)/20ms

342

// = 9.375px

343

// Positive effect of prediction = 5px

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

344

EXPECT_THAT(histogram_tester().GetAllSamples(

345

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

346

ElementsAre(Bucket(4, 1)));

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

347

EXPECT_THAT(

348

histogram_tester().GetAllSamples(

349

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionPositive"),

350

ElementsAre(Bucket(5, 1)));

351

histogram_tester().ExpectTotalCount(

352

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionNegative", 0);

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

353

}

354

355

// Test AverageLag with imperfect scroll prediction.

356

TEST_F(AverageLagTrackerTest, ImperfectScrollPrediction) {

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

357

// ScrollBegin, at t=5, finger_pos=5px.

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

358

// Predict frame_time=10, predicted_pos(over) = 12px.

359

base::TimeTicks event_time = MillisecondsToTimeTicks(5);

360

base::TimeTicks frame_time = MillisecondsToTimeTicks(10);

361

SyntheticTouchScrollBeginLatencyInfo(

362

event_time, frame_time, 5 /* scroll_delta */, 12 /* predicted_delta */);

363

364

// ScrollUpdate, at t=15, finger_pos=15px.

365

// Predict frame_time=20, predicted_pos(under) = 17px.

366

event_time = MillisecondsToTimeTicks(15);

367

frame_time = MillisecondsToTimeTicks(20);

368

SyntheticTouchScrollUpdateLatencyInfo(

369

event_time, frame_time, 10 /* scroll_delta */, 5 /* predicted_delta */);

370

371

// ScrollUpdate, at t=25, finger_pos=25px.

372

// Predict frame_time=30, predicted_pos(over) = 31px.

373

event_time = MillisecondsToTimeTicks(25);

374

frame_time = MillisecondsToTimeTicks(30);

375

SyntheticTouchScrollUpdateLatencyInfo(

376

event_time, frame_time, 10 /* scroll_delta */, 14 /* predicted_delta */);

377

378

// Another ScrollBegin to flush unfinished frames.

379

event_time = MillisecondsToTimeTicks(1000);

380

frame_time = MillisecondsToTimeTicks(1000);

381

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

382

383

EXPECT_THAT(histogram_tester().GetAllSamples(

384

"Event.Latency.ScrollBegin.Touch.AverageLag"),

385

ElementsAre(Bucket(7, 1)));

386

// AverageLag = ((2px*2ms/2+8px*8ms/2)+ ((3px+8px)*5ms/2+8px*5ms))/20ms

387

// = 5.075px

388

EXPECT_THAT(histogram_tester().GetAllSamples(

389

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

390

ElementsAre(Bucket(5, 1)));

Daniel Libby

2019-05-06 19:23:44

[diff] [blame]

391

// AverageLag (w/o prediction =

392

// ((5px+15px)*10ms/2 + (5px+10px)*5ms/2 + 10px*5ms)/20ms

393

// = 9.375px

394

// Positive effect of prediction = 4.3px

395

EXPECT_THAT(

396

histogram_tester().GetAllSamples(

397

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionPositive"),

398

ElementsAre(Bucket(4, 1)));

399

histogram_tester().ExpectTotalCount(

400

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionNegative", 0);

401

}

402

403

TEST_F(AverageLagTrackerTest, NegativePredictionEffect) {

404

// ScrollBegin, at t=5, finger_pos=5px.

405

// Predict frame_time=10, predicted_pos(over) = 20px.

406

base::TimeTicks event_time = MillisecondsToTimeTicks(5);

407

base::TimeTicks frame_time = MillisecondsToTimeTicks(10);

408

SyntheticTouchScrollBeginLatencyInfo(

409

event_time, frame_time, 5 /* scroll_delta */, 20 /* predicted_delta */);

410

411

// ScrollUpdate, at t=15, finger_pos=15px.

412

// Predict frame_time=20, predicted_pos(over) = 60px.

413

event_time = MillisecondsToTimeTicks(15);

414

frame_time = MillisecondsToTimeTicks(20);

415

SyntheticTouchScrollUpdateLatencyInfo(

416

event_time, frame_time, 10 /* scroll_delta */, 40 /* predicted_delta */);

417

418

// ScrollUpdate, at t=25, finger_pos=25px.

419

// Predict frame_time=30, predicted_pos(over) = 60px.

420

event_time = MillisecondsToTimeTicks(25);

421

frame_time = MillisecondsToTimeTicks(30);

422

SyntheticTouchScrollUpdateLatencyInfo(

423

event_time, frame_time, 10 /* scroll_delta */, 0 /* predicted_delta */);

424

425

// Another ScrollBegin to flush unfinished frames.

426

event_time = MillisecondsToTimeTicks(1000);

427

frame_time = MillisecondsToTimeTicks(1000);

428

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

429

430

EXPECT_THAT(histogram_tester().GetAllSamples(

431

"Event.Latency.ScrollBegin.Touch.AverageLag"),

432

ElementsAre(Bucket(7, 1)));

433

// AverageLag = ((10px+0px)*10ms/2)+ ((40px+35px)*5ms/2+35px*5ms))/20ms

434

// = 20.625px

435

EXPECT_THAT(histogram_tester().GetAllSamples(

436

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

437

ElementsAre(Bucket(20, 1)));

438

// AverageLag (w/o prediction =

439

// ((5px+15px)*10ms/2 + (5px+10px)*5ms/2 + 10px*5ms)/20ms

440

// = 9.375px

441

// Negative effect of prediction = 11.25

442

histogram_tester().ExpectTotalCount(

443

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionPositive", 0);

444

EXPECT_THAT(

445

histogram_tester().GetAllSamples(

446

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionNegative"),

447

ElementsAre(Bucket(11, 1)));

448

}

449

450

TEST_F(AverageLagTrackerTest, NoPredictionEffect) {

451

// ScrollBegin, at t=5, finger_pos=5px.

452

// Predict frame_time=10, predicted_pos(over) = 25px.

453

base::TimeTicks event_time = MillisecondsToTimeTicks(5);

454

base::TimeTicks frame_time = MillisecondsToTimeTicks(10);

455

SyntheticTouchScrollBeginLatencyInfo(

456

event_time, frame_time, 5 /* scroll_delta */, 25 /* predicted_delta */);

457

458

// ScrollUpdate, at t=15, finger_pos=15px.

459

// Predict frame_time=20, predicted_pos(over) = 32px.

460

event_time = MillisecondsToTimeTicks(15);

461

frame_time = MillisecondsToTimeTicks(20);

462

SyntheticTouchScrollUpdateLatencyInfo(

463

event_time, frame_time, 10 /* scroll_delta */, 7 /* predicted_delta */);

464

465

// ScrollUpdate, at t=25, finger_pos=25px.

466

// Predict frame_time=30, predicted_pos(over) = 37px.

467

event_time = MillisecondsToTimeTicks(25);

468

frame_time = MillisecondsToTimeTicks(30);

469

SyntheticTouchScrollUpdateLatencyInfo(

470

event_time, frame_time, 10 /* scroll_delta */, 5 /* predicted_delta */);

471

472

// Another ScrollBegin to flush unfinished frames.

473

event_time = MillisecondsToTimeTicks(1000);

474

frame_time = MillisecondsToTimeTicks(1000);

475

SyntheticTouchScrollBeginLatencyInfo(event_time, frame_time, 0);

476

477

EXPECT_THAT(histogram_tester().GetAllSamples(

478

"Event.Latency.ScrollBegin.Touch.AverageLag"),

479

ElementsAre(Bucket(7, 1)));

480

// AverageLag = ((15px+5px)*10ms/2 + (12px+7px)*5ms/2 + 7px*5ms)/20ms

481

// = 9.125px

482

EXPECT_THAT(histogram_tester().GetAllSamples(

483

"Event.Latency.ScrollUpdate.Touch.AverageLag"),

484

ElementsAre(Bucket(9, 1)));

485

// AverageLag (w/o prediction) =

486

// ((5px+15px)*10ms/2 + (5px+10px)*5ms/2 + 10px*5ms)/20ms

487

// = 9.375px

488

// Prediction slightly positive, we should see a 0 bucket in

489

// PredictionPositive UMA

490

EXPECT_THAT(

491

histogram_tester().GetAllSamples(

492

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionPositive"),

493

ElementsAre(Bucket(0, 1)));

494

histogram_tester().ExpectTotalCount(

495

"Event.Latency.ScrollUpdate.Touch.AverageLag.PredictionNegative", 0);

Ella Ge

2019-04-08 16:47:59

[diff] [blame]

496

}

497

Ella Ge