Remove base::FundamentalValue

chrome/browser/policy/policy_network_browsertest.cc

 // Copyright (c) 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
@@ skipping 109 matching lines @@
 };
 
 // Policy QuicAllowed set to false.
 class QuicAllowedPolicyIsFalse: public QuicAllowedPolicyTestBase {
  public:
   QuicAllowedPolicyIsFalse() : QuicAllowedPolicyTestBase() {}
 
  protected:
   void GetQuicAllowedPolicy(PolicyMap* values) override {
     values->Set(key::kQuicAllowed, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                POLICY_SOURCE_CLOUD,
-                base::MakeUnique<base::FundamentalValue>(false), nullptr);
+                POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false),
+                nullptr);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicAllowedPolicyIsFalse);
 };
 
 IN_PROC_BROWSER_TEST_F(QuicAllowedPolicyIsFalse, QuicDisallowed) {
   EXPECT_FALSE(IsQuicEnabled(system_request_context()));
   EXPECT_FALSE(IsQuicEnabled(safe_browsing_service_request_context()));
   EXPECT_FALSE(IsQuicEnabled(browser()->profile()->GetRequestContext()));
 }
 
 // Policy QuicAllowed set to true.
 class QuicAllowedPolicyIsTrue: public QuicAllowedPolicyTestBase {
  public:
   QuicAllowedPolicyIsTrue() : QuicAllowedPolicyTestBase() {}
 
  protected:
   void GetQuicAllowedPolicy(PolicyMap* values) override {
     values->Set(key::kQuicAllowed, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                POLICY_SOURCE_CLOUD,
-                base::MakeUnique<base::FundamentalValue>(true), nullptr);
+                POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true),
+                nullptr);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicAllowedPolicyIsTrue);
 };
 
 IN_PROC_BROWSER_TEST_F(QuicAllowedPolicyIsTrue, QuicAllowed) {
   EXPECT_TRUE(IsQuicEnabled(system_request_context()));
   EXPECT_TRUE(IsQuicEnabled(safe_browsing_service_request_context()));
   EXPECT_TRUE(IsQuicEnabled(browser()->profile()->GetRequestContext()));
@@ skipping 76 matching lines @@
     EXPECT_TRUE(profile_1() != profile_2());
   }
 
   // Sets the QuicAllowed policy for a Profile.
   // |provider| is supposed to be the MockConfigurationPolicyProvider for the
   // Profile, as returned by policy_for_profile_1() / policy_for_profile_2().
   void SetQuicAllowedPolicy(MockConfigurationPolicyProvider* provider,
                             bool value) {
     PolicyMap policy_map;
     policy_map.Set(key::kQuicAllowed, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                   POLICY_SOURCE_CLOUD,
-                   base::MakeUnique<base::FundamentalValue>(value), nullptr);
+                   POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(value),
+                   nullptr);
     provider->UpdateChromePolicy(policy_map);
     base::RunLoop().RunUntilIdle();
   }
 
   // Removes all policies for a Profile.
   // |provider| is supposed to be the MockConfigurationPolicyProvider for the
   // Profile, as returned by policy_for_profile_1() / policy_for_profile_2().
   void RemoveAllPolicies(MockConfigurationPolicyProvider* provider) {
     PolicyMap policy_map;
     provider->UpdateChromePolicy(policy_map);
@@ skipping 144 matching lines @@
 
   // Disable QUIC in second profile
   SetQuicAllowedPolicy(policy_for_profile_2(), false);
   EXPECT_FALSE(IsQuicEnabled(system_request_context()));
   EXPECT_FALSE(IsQuicEnabled(safe_browsing_service_request_context()));
   EXPECT_FALSE(IsQuicEnabled(profile_1()->GetRequestContext()));
   EXPECT_FALSE(IsQuicEnabled(profile_2()->GetRequestContext()));
 }
 
 }  // namespace policy