Remove FundamentalValue

components/cryptauth/cryptauth_enrollment_manager_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 "components/cryptauth/cryptauth_enrollment_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
@@ skipping 152 matching lines @@
     clock_->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
     enrollment_manager_.AddObserver(this);
 
     private_key_ =
         secure_message_delegate_->GetPrivateKeyForPublicKey(public_key_);
     secure_message_delegate_->set_next_public_key(public_key_);
 
     CryptAuthEnrollmentManager::RegisterPrefs(pref_service_.registry());
     pref_service_.SetUserPref(
         prefs::kCryptAuthEnrollmentIsRecoveringFromFailure,
-        new base::FundamentalValue(false));
+        new base::Value(false));
     pref_service_.SetUserPref(
         prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds,
-        new base::FundamentalValue(kLastEnrollmentTimeSeconds));
+        new base::Value(kLastEnrollmentTimeSeconds));
     pref_service_.SetUserPref(
         prefs::kCryptAuthEnrollmentReason,
-        new base::FundamentalValue(cryptauth::INVOCATION_REASON_UNKNOWN));
+        new base::Value(cryptauth::INVOCATION_REASON_UNKNOWN));
 
     std::string public_key_b64, private_key_b64;
     base::Base64UrlEncode(public_key_,
                           base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                           &public_key_b64);
     base::Base64UrlEncode(private_key_,
                           base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                           &private_key_b64);
     pref_service_.SetString(prefs::kCryptAuthEnrollmentUserPublicKey,
                             public_key_b64);
@@ skipping 139 matching lines @@
 
   enrollment_manager_.Start();
   EXPECT_TRUE(enrollment_manager_.IsEnrollmentValid());
   EXPECT_EQ(base::Time::FromDoubleT(kLastEnrollmentTimeSeconds),
             enrollment_manager_.GetLastEnrollmentTime());
 }
 
 TEST_F(CryptAuthEnrollmentManagerTest, InitWithExpiredEnrollment) {
   pref_service_.SetUserPref(
       prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds,
-      new base::FundamentalValue(kLastExpiredEnrollmentTimeSeconds));
+      new base::Value(kLastExpiredEnrollmentTimeSeconds));
 
   EXPECT_CALL(*sync_scheduler(),
               Start(clock_->Now() - base::Time::FromDoubleT(
                                         kLastExpiredEnrollmentTimeSeconds),
                     SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
 
   enrollment_manager_.Start();
   EXPECT_FALSE(enrollment_manager_.IsEnrollmentValid());
   EXPECT_EQ(base::Time::FromDoubleT(kLastExpiredEnrollmentTimeSeconds),
             enrollment_manager_.GetLastEnrollmentTime());
@@ skipping 111 matching lines @@
   // Simulate receiving a GCM push message, forcing the device to re-enroll.
   gcm_manager_.PushReenrollMessage();
   auto completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
 }
 
 }  // namespace cryptauth