Flutter Engine
session_connection_unittests.cc
Go to the documentation of this file.
1 // Copyright 2020 The Flutter Authors. All rights reserved.
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 <fuchsia/scenic/scheduling/cpp/fidl.h>
6 #include <fuchsia/ui/policy/cpp/fidl.h>
7 #include <fuchsia/ui/scenic/cpp/fidl.h>
8 #include <lib/async-loop/default.h>
9 #include <lib/sys/cpp/component_context.h>
10 
11 #include "flutter/shell/platform/fuchsia/flutter/logging.h"
12 #include "flutter/shell/platform/fuchsia/flutter/runner.h"
13 #include "flutter/shell/platform/fuchsia/flutter/session_connection.h"
14 #include "gtest/gtest.h"
15 
16 using namespace flutter_runner;
17 
18 namespace flutter_runner_test {
19 
20 class SessionConnectionTest : public ::testing::Test {
21  public:
22  void SetUp() override {
23  context_ = sys::ComponentContext::CreateAndServeOutgoingDirectory();
24  scenic_ = context_->svc()->Connect<fuchsia::ui::scenic::Scenic>();
25  presenter_ = context_->svc()->Connect<fuchsia::ui::policy::Presenter>();
26 
27  FML_CHECK(ZX_OK ==
28  loop_.StartThread("SessionConnectionTestThread", &fidl_thread_));
29 
30  auto session_listener_request = session_listener_.NewRequest();
31 
32  scenic_->CreateSession(session_.NewRequest(), session_listener_.Bind());
33  FML_CHECK(zx::event::create(0, &vsync_event_) == ZX_OK);
34 
35  // Ensure Scenic has had time to wake up before the test logic begins.
36  // TODO(61768) Find a better solution than sleeping periodically checking a
37  // condition.
38  int scenic_initialized = false;
39  scenic_->GetDisplayInfo(
40  [&scenic_initialized](fuchsia::ui::gfx::DisplayInfo display_info) {
41  scenic_initialized = true;
42  });
43  while (!scenic_initialized) {
44  std::this_thread::sleep_for(std::chrono::milliseconds(100));
45  }
46  }
47  // Warning: Initialization order matters here. |loop_| must be initialized
48  // before |SetUp()| so that we have a dispatcher already initialized.
49  async::Loop loop_ = async::Loop(&kAsyncLoopConfigAttachToCurrentThread);
50 
51  std::unique_ptr<sys::ComponentContext> context_;
52  fuchsia::ui::scenic::ScenicPtr scenic_;
53  fuchsia::ui::policy::PresenterPtr presenter_;
54 
55  fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session_;
56  fidl::InterfaceHandle<fuchsia::ui::scenic::SessionListener> session_listener_;
58  thrd_t fidl_thread_;
59 };
60 
61 TEST_F(SessionConnectionTest, SimplePresentTest) {
62  fml::closure on_session_error_callback = []() { FML_CHECK(false); };
63 
64  uint64_t num_presents_handled = 0;
65  on_frame_presented_event on_frame_presented_callback =
66  [&num_presents_handled](
67  fuchsia::scenic::scheduling::FramePresentedInfo info) {
68  num_presents_handled += info.presentation_infos.size();
69  };
70 
71  flutter_runner::SessionConnection session_connection(
72  "debug label", std::move(session_), on_session_error_callback,
73  on_frame_presented_callback, vsync_event_.get(), 3);
74 
75  for (int i = 0; i < 200; ++i) {
76  session_connection.Present();
77  std::this_thread::sleep_for(std::chrono::milliseconds(10));
78  }
79 
80  EXPECT_GT(num_presents_handled, 0u);
81 }
82 
83 TEST_F(SessionConnectionTest, BatchedPresentTest) {
84  fml::closure on_session_error_callback = []() { FML_CHECK(false); };
85 
86  uint64_t num_presents_handled = 0;
87  on_frame_presented_event on_frame_presented_callback =
88  [&num_presents_handled](
89  fuchsia::scenic::scheduling::FramePresentedInfo info) {
90  num_presents_handled += info.presentation_infos.size();
91  };
92 
93  flutter_runner::SessionConnection session_connection(
94  "debug label", std::move(session_), on_session_error_callback,
95  on_frame_presented_callback, vsync_event_.get(), 3);
96 
97  for (int i = 0; i < 200; ++i) {
98  session_connection.Present();
99  if (i % 10 == 9) {
100  std::this_thread::sleep_for(std::chrono::milliseconds(20));
101  }
102  }
103 
104  EXPECT_GT(num_presents_handled, 0u);
105 }
106 
109 }
112 }
113 static int TimePointToInt(fml::TimePoint time) {
114  return time.ToEpochDelta().ToNanoseconds();
115 }
116 
117 // The first set of tests has an empty |future_presentation_infos| passed in.
118 // Therefore these tests are to ensure that on startup and after not presenting
119 // for some time that we have correct, reasonable behavior.
120 TEST(CalculateNextLatchPointTest, PresentAsSoonAsPossible) {
121  fml::TimePoint present_requested_time = TimePointFromInt(0);
123  fml::TimePoint last_latch_point_targeted = TimePointFromInt(0);
124  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(0);
125  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
126  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
127  future_presentation_infos = {};
128 
129  // Assertions about given values.
130  EXPECT_GE(now, present_requested_time);
131  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
132  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
133 
134  fml::TimePoint calculated_latch_point =
136  present_requested_time, now, last_latch_point_targeted,
137  flutter_frame_build_time, vsync_interval, future_presentation_infos);
138 
139  EXPECT_GE(TimePointToInt(calculated_latch_point), TimePointToInt(now));
140  EXPECT_LE(TimePointToInt(calculated_latch_point),
141  TimePointToInt(now + vsync_interval));
142 
143  EXPECT_GE(TimePointToInt(calculated_latch_point),
144  TimePointToInt(present_requested_time + flutter_frame_build_time));
145  EXPECT_GE(TimePointToInt(calculated_latch_point),
146  TimePointToInt(last_latch_point_targeted));
147 }
148 
149 TEST(CalculateNextLatchPointTest, LongFrameBuildTime) {
150  fml::TimePoint present_requested_time = TimePointFromInt(500);
151  fml::TimePoint now = TimePointFromInt(600);
152  fml::TimePoint last_latch_point_targeted = TimePointFromInt(0);
153  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(2500);
154  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
155  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
156  future_presentation_infos = {};
157 
158  // Assertions about given values.
159  EXPECT_GE(now, present_requested_time);
160  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
161  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
162 
163  EXPECT_GT(flutter_frame_build_time, vsync_interval);
164 
165  fml::TimePoint calculated_latch_point =
167  present_requested_time, now, last_latch_point_targeted,
168  flutter_frame_build_time, vsync_interval, future_presentation_infos);
169 
170  EXPECT_GE(TimePointToInt(calculated_latch_point),
171  TimePointToInt(now + (vsync_interval * 2)));
172  EXPECT_LE(TimePointToInt(calculated_latch_point),
173  TimePointToInt(now + (vsync_interval * 3)));
174 
175  EXPECT_GE(TimePointToInt(calculated_latch_point),
176  TimePointToInt(present_requested_time + flutter_frame_build_time));
177  EXPECT_GE(TimePointToInt(calculated_latch_point),
178  TimePointToInt(last_latch_point_targeted));
179 }
180 
181 TEST(CalculateNextLatchPointTest, DelayedPresentRequestWithLongFrameBuildTime) {
182  fml::TimePoint present_requested_time = TimePointFromInt(0);
183  fml::TimePoint now = TimePointFromInt(1500);
184  fml::TimePoint last_latch_point_targeted = TimePointFromInt(0);
185  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(2000);
186  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
187  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
188  future_presentation_infos = {};
189 
190  // Assertions about given values.
191  EXPECT_GE(now, present_requested_time);
192  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
193  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
194 
195  EXPECT_GT(flutter_frame_build_time, vsync_interval);
196  EXPECT_GT(now, present_requested_time + vsync_interval);
197 
198  fml::TimePoint calculated_latch_point =
200  present_requested_time, now, last_latch_point_targeted,
201  flutter_frame_build_time, vsync_interval, future_presentation_infos);
202 
203  EXPECT_GE(TimePointToInt(calculated_latch_point), TimePointToInt(now));
204  EXPECT_LE(TimePointToInt(calculated_latch_point),
205  TimePointToInt(now + vsync_interval));
206 
207  EXPECT_GE(TimePointToInt(calculated_latch_point),
208  TimePointToInt(present_requested_time + flutter_frame_build_time));
209  EXPECT_GE(TimePointToInt(calculated_latch_point),
210  TimePointToInt(last_latch_point_targeted));
211 }
212 
213 TEST(CalculateNextLatchPointTest, LastLastPointTargetedLate) {
214  fml::TimePoint present_requested_time = TimePointFromInt(2000);
215  fml::TimePoint now = TimePointFromInt(2000);
216  fml::TimePoint last_latch_point_targeted = TimePointFromInt(2600);
217  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(1000);
218  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
219  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
220  future_presentation_infos = {};
221 
222  // Assertions about given values.
223  EXPECT_GE(now, present_requested_time);
224  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
225  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
226 
227  EXPECT_GT(last_latch_point_targeted, present_requested_time);
228 
229  fml::TimePoint calculated_latch_point =
231  present_requested_time, now, last_latch_point_targeted,
232  flutter_frame_build_time, vsync_interval, future_presentation_infos);
233 
234  EXPECT_GE(TimePointToInt(calculated_latch_point),
235  TimePointToInt(now + vsync_interval));
236  EXPECT_LE(TimePointToInt(calculated_latch_point),
237  TimePointToInt(now + (vsync_interval * 2)));
238 
239  EXPECT_GE(TimePointToInt(calculated_latch_point),
240  TimePointToInt(present_requested_time + flutter_frame_build_time));
241  EXPECT_GE(TimePointToInt(calculated_latch_point),
242  TimePointToInt(last_latch_point_targeted));
243 }
244 
245 // This set of tests provides (latch_point, vsync_time) pairs in
246 // |future_presentation_infos|. This tests steady state behavior where we're
247 // presenting frames virtually every vsync interval.
248 
249 TEST(CalculateNextLatchPointTest, SteadyState_OnTimeFrames) {
250  fml::TimePoint present_requested_time = TimePointFromInt(5000);
251  fml::TimePoint now = TimePointFromInt(5000);
252  fml::TimePoint last_latch_point_targeted = TimePointFromInt(4500);
253  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(1000);
254  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
255  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
256  future_presentation_infos = {
257  {TimePointFromInt(3500), TimePointFromInt(4000)},
258  {TimePointFromInt(4500), TimePointFromInt(5000)},
259  {TimePointFromInt(5500), TimePointFromInt(6000)},
260  {TimePointFromInt(6500), TimePointFromInt(7000)},
261  {TimePointFromInt(7500), TimePointFromInt(8000)},
262  };
263 
264  // Assertions about given values.
265  EXPECT_GE(now, present_requested_time);
266  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
267  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
268 
269  fml::TimePoint calculated_latch_point =
271  present_requested_time, now, last_latch_point_targeted,
272  flutter_frame_build_time, vsync_interval, future_presentation_infos);
273 
274  EXPECT_GE(TimePointToInt(calculated_latch_point),
275  TimePointToInt(now + vsync_interval));
276  EXPECT_LE(TimePointToInt(calculated_latch_point),
277  TimePointToInt(now + (vsync_interval * 2)));
278  EXPECT_EQ(TimePointToInt(calculated_latch_point), 6500);
279 
280  EXPECT_GE(TimePointToInt(calculated_latch_point),
281  TimePointToInt(present_requested_time + flutter_frame_build_time));
282  EXPECT_GE(TimePointToInt(calculated_latch_point),
283  TimePointToInt(last_latch_point_targeted));
284 }
285 
286 TEST(CalculateNextLatchPointTest, SteadyState_LongFrameBuildTimes) {
287  fml::TimePoint present_requested_time = TimePointFromInt(5000);
288  fml::TimePoint now = TimePointFromInt(5000);
289  fml::TimePoint last_latch_point_targeted = TimePointFromInt(4500);
290  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(2000);
291  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
292  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
293  future_presentation_infos = {
294  {TimePointFromInt(3500), TimePointFromInt(4000)},
295  {TimePointFromInt(4500), TimePointFromInt(5000)},
296  {TimePointFromInt(5500), TimePointFromInt(6000)},
297  {TimePointFromInt(6500), TimePointFromInt(7000)},
298  {TimePointFromInt(7500), TimePointFromInt(8000)},
299  };
300 
301  // Assertions about given values.
302  EXPECT_GE(now, present_requested_time);
303  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
304  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
305 
306  EXPECT_GT(flutter_frame_build_time, vsync_interval);
307 
308  fml::TimePoint calculated_latch_point =
310  present_requested_time, now, last_latch_point_targeted,
311  flutter_frame_build_time, vsync_interval, future_presentation_infos);
312 
313  EXPECT_GE(TimePointToInt(calculated_latch_point),
314  TimePointToInt(now + (vsync_interval * 2)));
315  EXPECT_LE(TimePointToInt(calculated_latch_point),
316  TimePointToInt(now + (vsync_interval * 3)));
317  EXPECT_EQ(TimePointToInt(calculated_latch_point), 7500);
318 
319  EXPECT_GE(TimePointToInt(calculated_latch_point),
320  TimePointToInt(present_requested_time + flutter_frame_build_time));
321  EXPECT_GE(TimePointToInt(calculated_latch_point),
322  TimePointToInt(last_latch_point_targeted));
323 }
324 
325 TEST(CalculateNextLatchPointTest, SteadyState_LateLastLatchPointTargeted) {
326  fml::TimePoint present_requested_time = TimePointFromInt(5000);
327  fml::TimePoint now = TimePointFromInt(5000);
328  fml::TimePoint last_latch_point_targeted = TimePointFromInt(6500);
329  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(1000);
330  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
331  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
332  future_presentation_infos = {
333  {TimePointFromInt(4500), TimePointFromInt(5000)},
334  {TimePointFromInt(5500), TimePointFromInt(6000)},
335  {TimePointFromInt(6500), TimePointFromInt(7000)},
336  {TimePointFromInt(7500), TimePointFromInt(8000)},
337  {TimePointFromInt(8500), TimePointFromInt(9000)},
338  };
339 
340  // Assertions about given values.
341  EXPECT_GE(now, present_requested_time);
342  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
343  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
344 
345  EXPECT_GT(last_latch_point_targeted, now + vsync_interval);
346 
347  fml::TimePoint calculated_latch_point =
349  present_requested_time, now, last_latch_point_targeted,
350  flutter_frame_build_time, vsync_interval, future_presentation_infos);
351 
352  EXPECT_GE(TimePointToInt(calculated_latch_point),
353  TimePointToInt(now + vsync_interval));
354  EXPECT_LE(TimePointToInt(calculated_latch_point),
355  TimePointToInt(now + (vsync_interval * 2)));
356  EXPECT_EQ(TimePointToInt(calculated_latch_point), 6500);
357 
358  EXPECT_GE(TimePointToInt(calculated_latch_point),
359  TimePointToInt(present_requested_time + flutter_frame_build_time));
360  EXPECT_GE(TimePointToInt(calculated_latch_point),
361  TimePointToInt(last_latch_point_targeted));
362 }
363 
364 TEST(CalculateNextLatchPointTest,
365  SteadyState_DelayedPresentRequestWithLongFrameBuildTime) {
366  fml::TimePoint present_requested_time = TimePointFromInt(4000);
367  fml::TimePoint now = TimePointFromInt(5500);
368  fml::TimePoint last_latch_point_targeted = TimePointFromInt(3500);
369  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(2000);
370  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
371  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
372  future_presentation_infos = {
373  {TimePointFromInt(4500), TimePointFromInt(5000)},
374  {TimePointFromInt(5500), TimePointFromInt(6000)},
375  {TimePointFromInt(6500), TimePointFromInt(7000)},
376  };
377 
378  // Assertions about given values.
379  EXPECT_GE(now, present_requested_time);
380  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
381  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
382 
383  EXPECT_GT(flutter_frame_build_time, vsync_interval);
384  EXPECT_GT(now, present_requested_time + vsync_interval);
385 
386  fml::TimePoint calculated_latch_point =
388  present_requested_time, now, last_latch_point_targeted,
389  flutter_frame_build_time, vsync_interval, future_presentation_infos);
390 
391  EXPECT_GE(TimePointToInt(calculated_latch_point),
392  TimePointToInt(now + vsync_interval));
393  EXPECT_LE(TimePointToInt(calculated_latch_point),
394  TimePointToInt(now + (vsync_interval * 2)));
395  EXPECT_EQ(TimePointToInt(calculated_latch_point), 6500);
396 
397  EXPECT_GE(TimePointToInt(calculated_latch_point),
398  TimePointToInt(present_requested_time + flutter_frame_build_time));
399  EXPECT_GE(TimePointToInt(calculated_latch_point),
400  TimePointToInt(last_latch_point_targeted));
401 }
402 
403 TEST(CalculateNextLatchPointTest, SteadyState_FuzzyLatchPointsBeforeTarget) {
404  fml::TimePoint present_requested_time = TimePointFromInt(4000);
405  fml::TimePoint now = TimePointFromInt(4000);
406  fml::TimePoint last_latch_point_targeted = TimePointFromInt(5490);
407  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(1000);
408  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
409  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
410  future_presentation_infos = {
411  {TimePointFromInt(4510), TimePointFromInt(5000)},
412  {TimePointFromInt(5557), TimePointFromInt(6000)},
413  {TimePointFromInt(6482), TimePointFromInt(7000)},
414  {TimePointFromInt(7356), TimePointFromInt(8000)},
415  };
416 
417  // Assertions about given values.
418  EXPECT_GE(now, present_requested_time);
419  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
420  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
421 
422  fml::TimePoint calculated_latch_point =
424  present_requested_time, now, last_latch_point_targeted,
425  flutter_frame_build_time, vsync_interval, future_presentation_infos);
426 
427  EXPECT_GE(TimePointToInt(calculated_latch_point),
428  TimePointToInt(now + vsync_interval));
429  EXPECT_LE(TimePointToInt(calculated_latch_point),
430  TimePointToInt(now + (vsync_interval * 2)));
431  EXPECT_EQ(TimePointToInt(calculated_latch_point), 5557);
432 
433  EXPECT_GE(TimePointToInt(calculated_latch_point),
434  TimePointToInt(present_requested_time + flutter_frame_build_time));
435  EXPECT_GE(TimePointToInt(calculated_latch_point),
436  TimePointToInt(last_latch_point_targeted));
437 }
438 
439 TEST(CalculateNextLatchPointTest, SteadyState_FuzzyLatchPointsAfterTarget) {
440  fml::TimePoint present_requested_time = TimePointFromInt(4000);
441  fml::TimePoint now = TimePointFromInt(4000);
442  fml::TimePoint last_latch_point_targeted = TimePointFromInt(5557);
443  fml::TimeDelta flutter_frame_build_time = TimeDeltaFromInt(1000);
444  fml::TimeDelta vsync_interval = TimeDeltaFromInt(1000);
445  std::deque<std::pair<fml::TimePoint, fml::TimePoint>>
446  future_presentation_infos = {
447  {TimePointFromInt(4510), TimePointFromInt(5000)},
448  {TimePointFromInt(5490), TimePointFromInt(6000)},
449  {TimePointFromInt(6482), TimePointFromInt(7000)},
450  {TimePointFromInt(7356), TimePointFromInt(8000)},
451  };
452 
453  // Assertions about given values.
454  EXPECT_GE(now, present_requested_time);
455  EXPECT_GE(flutter_frame_build_time, TimeDeltaFromInt(0));
456  EXPECT_GT(vsync_interval, TimeDeltaFromInt(0));
457 
458  fml::TimePoint calculated_latch_point =
460  present_requested_time, now, last_latch_point_targeted,
461  flutter_frame_build_time, vsync_interval, future_presentation_infos);
462 
463  EXPECT_GE(TimePointToInt(calculated_latch_point),
464  TimePointToInt(now + (vsync_interval * 2)));
465  EXPECT_LE(TimePointToInt(calculated_latch_point),
466  TimePointToInt(now + (vsync_interval * 3)));
467  EXPECT_EQ(TimePointToInt(calculated_latch_point), 6482);
468 
469  EXPECT_GE(TimePointToInt(calculated_latch_point),
470  TimePointToInt(present_requested_time + flutter_frame_build_time));
471  EXPECT_GE(TimePointToInt(calculated_latch_point),
472  TimePointToInt(last_latch_point_targeted));
473 }
474 } // namespace flutter_runner_test
static constexpr TimeDelta FromNanoseconds(int64_t nanos)
Definition: time_delta.h:40
std::unique_ptr< sys::ComponentContext > context_
TimeDelta ToEpochDelta() const
Definition: time_point.h:40
static constexpr TimePoint FromEpochDelta(TimeDelta ticks)
Definition: time_point.h:36
std::function< void()> closure
Definition: closure.h:14
static fml::TimePoint CalculateNextLatchPoint(fml::TimePoint present_requested_time, fml::TimePoint now, fml::TimePoint last_latch_point_targeted, fml::TimeDelta flutter_frame_build_time, fml::TimeDelta vsync_interval, std::deque< std::pair< fml::TimePoint, fml::TimePoint >> &future_presentation_infos)
fidl::InterfaceHandle< fuchsia::ui::scenic::SessionListener > session_listener_
static int TimePointToInt(fml::TimePoint time)
constexpr int64_t ToNanoseconds() const
Definition: time_delta.h:61
fidl::InterfaceHandle< fuchsia::ui::scenic::Session > session_
GdkEventButton * event
Definition: fl_view.cc:62
TEST_F(SessionConnectionTest, BatchedPresentTest)
static fml::TimeDelta TimeDeltaFromInt(int i)
#define FML_CHECK(condition)
Definition: logging.h:68
TEST(RunnerTZDataTest, LoadsWithoutTZDataPresent)
std::function< void(fuchsia::scenic::scheduling::FramePresentedInfo)> on_frame_presented_event
static fml::TimePoint TimePointFromInt(int i)