Convert video capture pipline to base::TimeTicks

content/browser/renderer_host/media/video_capture_oracle_unittest.cc

 // Copyright (c) 2013 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/browser/renderer_host/media/video_capture_oracle.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
 void SteadyStateSampleAndAdvance(base::TimeDelta vsync,
-                                 SmoothEventSampler* sampler, base::Time* t) {
+                                 SmoothEventSampler* sampler,
+                                 base::TimeTicks* t) {
   ASSERT_TRUE(sampler->AddEventAndConsiderSampling(*t));
   ASSERT_TRUE(sampler->HasUnrecordedEvent());
   sampler->RecordSample();
   ASSERT_FALSE(sampler->HasUnrecordedEvent());
   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
   *t += vsync;
   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
 }
 
 void SteadyStateNoSampleAndAdvance(base::TimeDelta vsync,
-                                   SmoothEventSampler* sampler, base::Time* t) {
+                                   SmoothEventSampler* sampler,
+                                   base::TimeTicks* t) {
   ASSERT_FALSE(sampler->AddEventAndConsiderSampling(*t));
   ASSERT_TRUE(sampler->HasUnrecordedEvent());
   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
   *t += vsync;
   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
 }
 
+void TimeTicksFromString(const char* string, base::TimeTicks* t) {
+  base::Time time;
+  ASSERT_TRUE(base::Time::FromString(string, &time));
+  *t = base::TimeTicks::UnixEpoch() + (time - base::Time::UnixEpoch());
+}
+
 void TestRedundantCaptureStrategy(base::TimeDelta capture_period,
                                   int redundant_capture_goal,
-                                  SmoothEventSampler* sampler, base::Time* t) {
+                                  SmoothEventSampler* sampler,
+                                  base::TimeTicks* t) {
   // Before any events have been considered, we're overdue for sampling.
   ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t));
 
   // Consider the first event.  We want to sample that.
   ASSERT_FALSE(sampler->HasUnrecordedEvent());
   ASSERT_TRUE(sampler->AddEventAndConsiderSampling(*t));
   ASSERT_TRUE(sampler->HasUnrecordedEvent());
   sampler->RecordSample();
   ASSERT_FALSE(sampler->HasUnrecordedEvent());
 
@@ skipping 14 matching lines @@
 }
 
 // 60Hz sampled at 30Hz should produce 30Hz.  In addition, this test contains
 // much more comprehensive before/after/edge-case scenarios than the others.
 TEST(SmoothEventSamplerTest, Sample60HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
   const int redundant_capture_goal = 200;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60;
 
   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
                                &sampler, &t);
 
   // Steady state, we should capture every other vsync, indefinitely.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
@@ skipping 18 matching lines @@
   }
 }
 
 // 50Hz sampled at 30Hz should produce a sequence where some frames are skipped.
 TEST(SmoothEventSamplerTest, Sample50HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
   const int redundant_capture_goal = 2;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 50;
 
   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
                                &sampler, &t);
 
   // Steady state, we should capture 1st, 2nd and 4th frames out of every five
   // frames, indefinitely.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
@@ skipping 24 matching lines @@
   }
 }
 
 // 75Hz sampled at 30Hz should produce a sequence where some frames are skipped.
 TEST(SmoothEventSamplerTest, Sample75HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
   const int redundant_capture_goal = 32;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 75;
 
   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
                                &sampler, &t);
 
   // Steady state, we should capture 1st and 3rd frames out of every five
   // frames, indefinitely.
   SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
@@ skipping 28 matching lines @@
   }
 }
 
 // 30Hz sampled at 30Hz should produce 30Hz.
 TEST(SmoothEventSamplerTest, Sample30HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
   const int redundant_capture_goal = 1;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 30;
 
   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
                                &sampler, &t);
 
   // Steady state, we should capture every vsync, indefinitely.
   for (int i = 0; i < 200; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 
@@ skipping 14 matching lines @@
   }
 }
 
 // 24Hz sampled at 30Hz should produce 24Hz.
 TEST(SmoothEventSamplerTest, Sample24HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
   const int redundant_capture_goal = 333;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 24;
 
   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
                                &sampler, &t);
 
   // Steady state, we should capture every vsync, indefinitely.
   for (int i = 0; i < 200; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 
@@ skipping 12 matching lines @@
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
 TEST(SmoothEventSamplerTest, DoubleDrawAtOneTimeStillDirties) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
   const base::TimeDelta overdue_period = base::TimeDelta::FromSeconds(1);
 
   SmoothEventSampler sampler(capture_period, true, 1);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
   sampler.RecordSample();
   ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
       << "Sampled last event; should not be dirty.";
   t += overdue_period;
 
   // Now simulate 2 events with the same clock value.
   ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
   sampler.RecordSample();
   ASSERT_FALSE(sampler.AddEventAndConsiderSampling(t))
       << "Two events at same time -- expected second not to be sampled.";
   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t + overdue_period))
       << "Second event should dirty the capture state.";
   sampler.RecordSample();
   ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t + overdue_period));
 }
 
 TEST(SmoothEventSamplerTest, FallbackToPollingIfUpdatesUnreliable) {
   const base::TimeDelta timer_interval = base::TimeDelta::FromSeconds(1) / 30;
 
   SmoothEventSampler should_not_poll(timer_interval, true, 1);
   SmoothEventSampler should_poll(timer_interval, false, 1);
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
 
   // Do one round of the "happy case" where an event was received and
   // RecordSample() was called by the client.
   ASSERT_TRUE(should_not_poll.AddEventAndConsiderSampling(t));
   ASSERT_TRUE(should_poll.AddEventAndConsiderSampling(t));
   should_not_poll.RecordSample();
   should_poll.RecordSample();
 
   // One time period ahead, neither sampler says we're overdue.
   for (int i = 0; i < 3; i++) {
@@ skipping 34 matching lines @@
 }
 
 struct DataPoint {
   bool should_capture;
   double increment_ms;
 };
 
 void ReplayCheckingSamplerDecisions(const DataPoint* data_points,
                                     size_t num_data_points,
                                     SmoothEventSampler* sampler) {
-  base::Time t;
-  ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
+  base::TimeTicks t;
+  TimeTicksFromString("Sat, 23 Mar 2013 1:21:08 GMT", &t);
   for (size_t i = 0; i < num_data_points; ++i) {
     t += base::TimeDelta::FromMicroseconds(
         static_cast<int64>(data_points[i].increment_ms * 1000));
     ASSERT_EQ(data_points[i].should_capture,
               sampler->AddEventAndConsiderSampling(t))
         << "at data_points[" << i << ']';
     if (data_points[i].should_capture)
       sampler->RecordSample();
   }
 }
@@ skipping 99 matching lines @@
     { false, 0 }, { true, 16.72 }, { true, 33.44 }, { false, 0 },
     { true, 33.441 }, { false, 16.72 }, { true, 16.72 }, { true, 50.16 }
   };
 
   SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 3);
   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 }
 
 }  // namespace
 }  // namespace content