Move TestingPrefService to use unique_ptr<Value>

chrome/browser/chromeos/session_length_limiter_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/session_length_limiter.h"
 
 #include <memory>
 
 #include "base/compiler_specific.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "components/prefs/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 76 matching lines @@
 }
 
 void SessionLengthLimiterTest::TearDown() {
   session_length_limiter_.reset();
   TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
 }
 
 void SessionLengthLimiterTest::SetSessionUserActivitySeenPref(
     bool user_activity_seen) {
   local_state_.SetUserPref(prefs::kSessionUserActivitySeen,
-                           new base::Value(user_activity_seen));
+                           base::MakeUnique<base::Value>(user_activity_seen));
 }
 
 void SessionLengthLimiterTest::ClearSessionUserActivitySeenPref() {
   local_state_.ClearPref(prefs::kSessionUserActivitySeen);
 }
 
 bool SessionLengthLimiterTest::IsSessionUserActivitySeenPrefSet() {
   return local_state_.HasPrefPath(prefs::kSessionUserActivitySeen);
 }
 
 bool SessionLengthLimiterTest::GetSessionUserActivitySeenPref() {
   EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
   return local_state_.GetBoolean(prefs::kSessionUserActivitySeen);
 }
 
 void SessionLengthLimiterTest::SetSessionStartTimePref(
     const base::TimeTicks& session_start_time) {
   local_state_.SetUserPref(prefs::kSessionStartTime,
-                           new base::Value(base::Int64ToString(
+                           base::MakeUnique<base::Value>(base::Int64ToString(
                                session_start_time.ToInternalValue())));
 }
 
 void SessionLengthLimiterTest::ClearSessionStartTimePref() {
   local_state_.ClearPref(prefs::kSessionStartTime);
 }
 
 bool SessionLengthLimiterTest::IsSessionStartTimePrefSet() {
   return local_state_.HasPrefPath(prefs::kSessionStartTime);
 }
 
 base::TimeTicks SessionLengthLimiterTest::GetSessionStartTimePref() {
   EXPECT_TRUE(IsSessionStartTimePrefSet());
   return base::TimeTicks::FromInternalValue(
       local_state_.GetInt64(prefs::kSessionStartTime));
 }
 
 void SessionLengthLimiterTest::SetSessionLengthLimitPref(
     const base::TimeDelta& session_length_limit) {
-  local_state_.SetUserPref(
-      prefs::kSessionLengthLimit,
-      new base::Value(static_cast<int>(session_length_limit.InMilliseconds())));
+  local_state_.SetUserPref(prefs::kSessionLengthLimit,
+                           base::MakeUnique<base::Value>(static_cast<int>(
+                               session_length_limit.InMilliseconds())));
   UpdateSessionStartTimeIfWaitingForUserActivity();
 }
 
 void SessionLengthLimiterTest::ClearSessionLengthLimitPref() {
   local_state_.RemoveUserPref(prefs::kSessionLengthLimit);
   UpdateSessionStartTimeIfWaitingForUserActivity();
 }
 
 void SessionLengthLimiterTest::SetWaitForInitialUserActivityPref(
     bool wait_for_initial_user_activity) {
   UpdateSessionStartTimeIfWaitingForUserActivity();
-  local_state_.SetUserPref(prefs::kSessionWaitForInitialUserActivity,
-                           new base::Value(wait_for_initial_user_activity));
+  local_state_.SetUserPref(
+      prefs::kSessionWaitForInitialUserActivity,
+      base::MakeUnique<base::Value>(wait_for_initial_user_activity));
 }
 
 void SessionLengthLimiterTest::SimulateUserActivity() {
   if (session_length_limiter_)
     session_length_limiter_->OnUserActivity(NULL);
   UpdateSessionStartTimeIfWaitingForUserActivity();
   user_activity_seen_ = true;
 }
 
 void SessionLengthLimiterTest::
@@ skipping 559 matching lines @@
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
 
   // Remove the session length limit.
   ClearSessionLengthLimitPref();
 
   // Verify that no timer fires to terminate the session.
   runner_->FastForwardUntilNoTasksRemain();
 }
 
 }  // namespace chromeos