add tests

Author: iskakaushik

ci/licenses_golden/licenses_flutter

@@ -44,6 +44,7 @@ FILE: ../../../flutter/flow/flow_test_utils.cc
 FILE: ../../../flutter/flow/flow_test_utils.h
 FILE: ../../../flutter/flow/frame_timings.cc
 FILE: ../../../flutter/flow/frame_timings.h
+FILE: ../../../flutter/flow/frame_timings_recorder_unittests.cc
 FILE: ../../../flutter/flow/gl_context_switch_unittests.cc
 FILE: ../../../flutter/flow/instrumentation.cc
 FILE: ../../../flutter/flow/instrumentation.h

flow/BUILD.gn

@@ -145,6 +145,7 @@ if (enable_unittests) {
       "flow_run_all_unittests.cc",
       "flow_test_utils.cc",
       "flow_test_utils.h",
+      "frame_timings_recorder_unittests.cc",
       "gl_context_switch_unittests.cc",
       "layers/backdrop_filter_layer_unittests.cc",
       "layers/checkerboard_layertree_unittests.cc",

flow/frame_timings.cc

@@ -17,79 +17,79 @@ FrameTimingsRecorder::~FrameTimingsRecorder() = default;
 
 fml::TimePoint FrameTimingsRecorder::GetVsyncStartTime() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kVsync);
+  FML_DCHECK(state_ >= State::kVsync);
   return vsync_start_;
 }
 
 fml::TimePoint FrameTimingsRecorder::GetVsyncTargetTime() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kVsync);
+  FML_DCHECK(state_ >= State::kVsync);
   return vsync_target_;
 }
 
 fml::TimePoint FrameTimingsRecorder::GetBuildStartTime() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kBuildStart);
+  FML_DCHECK(state_ >= State::kBuildStart);
   return build_start_;
 }
 
 fml::TimePoint FrameTimingsRecorder::GetBuildEndTime() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kBuildEnd);
+  FML_DCHECK(state_ >= State::kBuildEnd);
   return build_end_;
 }
 
 fml::TimePoint FrameTimingsRecorder::GetRasterStartTime() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kRasterStart);
+  FML_DCHECK(state_ >= State::kRasterStart);
   return raster_start_;
 }
 
 fml::TimePoint FrameTimingsRecorder::GetRasterEndTime() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kRasterEnd);
+  FML_DCHECK(state_ >= State::kRasterEnd);
   return raster_end_;
 }
 
 fml::TimeDelta FrameTimingsRecorder::GetBuildDuration() const {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ >= State::kBuildEnd);
+  FML_DCHECK(state_ >= State::kBuildEnd);
   return build_end_ - build_start_;
 }
 
 void FrameTimingsRecorder::RecordVsync(fml::TimePoint vsync_start,
                                        fml::TimePoint vsync_target) {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ == State::kUninitialized);
+  FML_DCHECK(state_ == State::kUninitialized);
   state_ = State::kVsync;
   vsync_start_ = vsync_start;
   vsync_target_ = vsync_target;
 }
 
 void FrameTimingsRecorder::RecordBuildStart(fml::TimePoint build_start) {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ == State::kVsync);
+  FML_DCHECK(state_ == State::kVsync);
   state_ = State::kBuildStart;
   build_start_ = build_start;
 }
 
 void FrameTimingsRecorder::RecordBuildEnd(fml::TimePoint build_end) {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ == State::kBuildStart);
+  FML_DCHECK(state_ == State::kBuildStart);
   state_ = State::kBuildEnd;
   build_end_ = build_end;
 }
 
 void FrameTimingsRecorder::RecordRasterStart(fml::TimePoint raster_start) {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ == State::kBuildEnd);
+  FML_DCHECK(state_ == State::kBuildEnd);
   state_ = State::kRasterStart;
   raster_start_ = raster_start;
 }
 
 FrameTiming FrameTimingsRecorder::RecordRasterEnd(fml::TimePoint raster_end) {
   std::scoped_lock state_lock(state_mutex_);
-  FML_CHECK(state_ == State::kRasterStart);
+  FML_DCHECK(state_ == State::kRasterStart);
   state_ = State::kRasterEnd;
   raster_end_ = raster_end;
   FrameTiming timing;

flow/frame_timings.h

@@ -17,18 +17,19 @@ namespace flutter {
 /// Records timestamps for various phases of a frame rendering process.
 ///
 /// Recorder is created on vsync and destroyed after the rasterization of the
-/// frame.
+/// frame. This class is thread safe and doesn't require additional
+/// synchronization.
 class FrameTimingsRecorder {
  public:
   /// Various states that the recorder can be in. When created the recorder is
   /// in an unitialized state and transtions in sequential order of the states.
   enum class State : uint32_t {
-    kUninitialized = 1,
-    kVsync = 2,
-    kBuildStart = 3,
-    kBuildEnd = 4,
-    kRasterStart = 5,
-    kRasterEnd = 6,
+    kUninitialized = 0,
+    kVsync = 1,
+    kBuildStart = 2,
+    kBuildEnd = 3,
+    kRasterStart = 4,
+    kRasterEnd = 5,
   };
 
   /// Default constructor, initializes the recorder with State::kUninitialized.
@@ -82,12 +83,12 @@ class FrameTimingsRecorder {
   mutable std::mutex state_mutex_;
   State state_ = State::kUninitialized;
 
-  fml::TimePoint vsync_start_ = fml::TimePoint::Min();
-  fml::TimePoint vsync_target_ = fml::TimePoint::Min();
-  fml::TimePoint build_start_ = fml::TimePoint::Min();
-  fml::TimePoint build_end_ = fml::TimePoint::Min();
-  fml::TimePoint raster_start_ = fml::TimePoint::Min();
-  fml::TimePoint raster_end_ = fml::TimePoint::Min();
+  fml::TimePoint vsync_start_;
+  fml::TimePoint vsync_target_;
+  fml::TimePoint build_start_;
+  fml::TimePoint build_end_;
+  fml::TimePoint raster_start_;
+  fml::TimePoint raster_end_;
 
   FML_DISALLOW_COPY_ASSIGN_AND_MOVE(FrameTimingsRecorder);
 };

flow/frame_timings_recorder_unittests.cc

@@ -0,0 +1,99 @@
+// Copyright 2013 The Flutter 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 "flutter/flow/frame_timings.h"
+
+#include "flutter/fml/time/time_delta.h"
+#include "flutter/fml/time/time_point.h"
+
+#include "gtest/gtest.h"
+
+namespace flutter {
+namespace testing {
+
+TEST(FrameTimingsRecorderTest, RecordVsync) {
+  auto recorder = std::make_unique<FrameTimingsRecorder>();
+  const auto st = fml::TimePoint::Now();
+  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordVsync(st, en);
+
+  ASSERT_EQ(st, recorder->GetVsyncStartTime());
+  ASSERT_EQ(en, recorder->GetVsyncTargetTime());
+}
+
+TEST(FrameTimingsRecorderTest, RecordBuildTimes) {
+  auto recorder = std::make_unique<FrameTimingsRecorder>();
+
+  const auto st = fml::TimePoint::Now();
+  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordVsync(st, en);
+
+  const auto build_start = fml::TimePoint::Now();
+  const auto build_end = build_start + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordBuildStart(build_start);
+  recorder->RecordBuildEnd(build_end);
+
+  ASSERT_EQ(build_start, recorder->GetBuildStartTime());
+  ASSERT_EQ(build_end, recorder->GetBuildEndTime());
+}
+
+TEST(FrameTimingsRecorderTest, RecordRasterTimes) {
+  auto recorder = std::make_unique<FrameTimingsRecorder>();
+
+  const auto st = fml::TimePoint::Now();
+  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordVsync(st, en);
+
+  const auto build_start = fml::TimePoint::Now();
+  const auto build_end = build_start + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordBuildStart(build_start);
+  recorder->RecordBuildEnd(build_end);
+
+  const auto raster_start = fml::TimePoint::Now();
+  const auto raster_end = raster_start + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordRasterStart(raster_start);
+  recorder->RecordRasterEnd(raster_end);
+
+  ASSERT_EQ(raster_start, recorder->GetRasterStartTime());
+  ASSERT_EQ(raster_end, recorder->GetRasterEndTime());
+}
+
+#ifndef OS_FUCHSIA
+
+// Windows doesn't allow testing with killed by signal.
+#ifdef OS_WIN
+TEST(FrameTimingsRecorderTest, DISABLED_ThrowWhenRecordBuildBeforeVsync) {
+#else
+TEST(FrameTimingsRecorderTest, ThrowWhenRecordBuildBeforeVsync) {
+#endif
+  auto recorder = std::make_unique<FrameTimingsRecorder>();
+
+  const auto build_start = fml::TimePoint::Now();
+  EXPECT_EXIT(recorder->RecordBuildStart(build_start),
+              ::testing::KilledBySignal(SIGABRT),
+              "Check failed: state_ == State::kVsync.");
+}
+
+// Windows doesn't allow testing with killed by signal.
+#ifdef OS_WIN
+TEST(FrameTimingsRecorderTest, DISABLED_ThrowWhenRecordRasterBeforeBuildEnd) {
+#else
+TEST(FrameTimingsRecorderTest, ThrowWhenRecordRasterBeforeBuildEnd) {
+#endif
+  auto recorder = std::make_unique<FrameTimingsRecorder>();
+
+  const auto st = fml::TimePoint::Now();
+  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
+  recorder->RecordVsync(st, en);
+
+  const auto raster_start = fml::TimePoint::Now();
+  EXPECT_EXIT(recorder->RecordRasterStart(raster_start),
+              ::testing::KilledBySignal(SIGABRT),
+              "Check failed: state_ == State::kBuildEnd.");
+}
+
+#endif
+
+}  // namespace testing
+}  // namespace flutter