Convert //media/filters from scoped_ptr to std::unique_ptr

media/filters/video_cadence_estimator_unittest.cc

 // Copyright 2015 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 "media/filters/video_cadence_estimator.h"
+
 #include <stddef.h>
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
-#include "media/filters/video_cadence_estimator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // See VideoCadenceEstimator header for more details.
 const int kMinimumAcceptableTimeBetweenGlitchesSecs = 8;
 
 // Slows down the given |fps| according to NTSC field reduction standards; see
 // http://en.wikipedia.org/wiki/Frame_rate#Digital_video_and_television
 static double NTSC(double fps) {
@@ skipping 199 matching lines @@
   // Increasing the acceptable drift should be result in more permissive
   // detection of cadence.
   acceptable_drift = render_interval;
   EXPECT_TRUE(estimator.UpdateCadenceEstimate(
       render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator.has_cadence());
   EXPECT_EQ("[1:0]", estimator.GetCadenceForTesting());
 }
 
 TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableGlitchTime) {
-  scoped_ptr<VideoCadenceEstimator> estimator(new VideoCadenceEstimator(
+  std::unique_ptr<VideoCadenceEstimator> estimator(new VideoCadenceEstimator(
       base::TimeDelta::FromSeconds(kMinimumAcceptableTimeBetweenGlitchesSecs)));
   estimator->set_cadence_hysteresis_threshold_for_testing(base::TimeDelta());
 
   const base::TimeDelta render_interval = Interval(NTSC(60));
   const base::TimeDelta frame_interval = Interval(120);
   const base::TimeDelta acceptable_drift = frame_interval / 2;
 
   EXPECT_FALSE(estimator->UpdateCadenceEstimate(
       render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_FALSE(estimator->has_cadence());
 
   // Decreasing the acceptable glitch time should be result in more permissive
   // detection of cadence.
   estimator.reset(new VideoCadenceEstimator(base::TimeDelta::FromSeconds(
       kMinimumAcceptableTimeBetweenGlitchesSecs / 2)));
   estimator->set_cadence_hysteresis_threshold_for_testing(base::TimeDelta());
   EXPECT_TRUE(estimator->UpdateCadenceEstimate(
       render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator->has_cadence());
   EXPECT_EQ("[1:0]", estimator->GetCadenceForTesting());
 }
 
 TEST(VideoCadenceEstimatorTest, CadenceHystersisPreventsOscillation) {
-  scoped_ptr<VideoCadenceEstimator> estimator(new VideoCadenceEstimator(
+  std::unique_ptr<VideoCadenceEstimator> estimator(new VideoCadenceEstimator(
       base::TimeDelta::FromSeconds(kMinimumAcceptableTimeBetweenGlitchesSecs)));
 
   const base::TimeDelta render_interval = Interval(30);
   const base::TimeDelta frame_interval = Interval(60);
   const base::TimeDelta acceptable_drift = frame_interval / 2;
   estimator->set_cadence_hysteresis_threshold_for_testing(render_interval * 2);
 
   // Cadence hysteresis should prevent the cadence from taking effect yet.
   EXPECT_FALSE(estimator->UpdateCadenceEstimate(
       render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
@@ skipping 22 matching lines @@
   EXPECT_TRUE(estimator->has_cadence());
 
   // Two bad intervals should.
   EXPECT_TRUE(
       estimator->UpdateCadenceEstimate(render_interval, frame_interval * 0.75,
                                        base::TimeDelta(), acceptable_drift));
   EXPECT_FALSE(estimator->has_cadence());
 }
 
 }  // namespace media