Remove base::Value::CreateNullValue

chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate_unittest.cc

 // Copyright 2014 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/safe_browsing/incident_reporting/preference_validation_delegate.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident.h"
 #include "chrome/browser/safe_browsing/incident_reporting/mock_incident_receiver.h"
 #include "components/safe_browsing/csd.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::IsNull;
 using ::testing::NiceMock;
@@ skipping 96 matching lines @@
   void SetUp() override {
     PreferenceValidationDelegateTest::SetUp();
     value_type_ = std::tr1::get<0>(GetParam());
     expected_value_ = std::tr1::get<1>(GetParam());
   }
 
   static std::unique_ptr<base::Value> MakeValue(base::Value::Type value_type) {
     using base::Value;
     switch (value_type) {
       case Value::Type::NONE:
-        return Value::CreateNullValue();
+        return base::MakeUnique<base::Value>();
       case Value::Type::BOOLEAN:
         return std::unique_ptr<Value>(new base::Value(false));
       case Value::Type::INTEGER:
         return std::unique_ptr<Value>(new base::Value(47));
       case Value::Type::DOUBLE:
         return std::unique_ptr<Value>(new base::Value(0.47));
       case Value::Type::STRING:
         return std::unique_ptr<Value>(new base::Value("i have a spleen"));
       case Value::Type::DICTIONARY: {
         std::unique_ptr<base::DictionaryValue> value(
@@ skipping 62 matching lines @@
     value_state_ = std::tr1::get<0>(GetParam());
     external_validation_value_state_ = std::tr1::get<1>(GetParam());
   }
 
   ValueState value_state_;
   ValueState external_validation_value_state_;
 };
 
 TEST_P(PreferenceValidationDelegateNoIncident, Atomic) {
   instance_->OnAtomicPreferenceValidation(
-      kPrefPath, base::Value::CreateNullValue(), value_state_,
+      kPrefPath, base::MakeUnique<base::Value>(), value_state_,
       external_validation_value_state_, false /* is_personal */);
   EXPECT_EQ(0U, incidents_.size());
 }
 
 TEST_P(PreferenceValidationDelegateNoIncident, Split) {
   instance_->OnSplitPreferenceValidation(
       kPrefPath, invalid_keys_, external_validation_invalid_keys_, value_state_,
       external_validation_value_state_, false /* is_personal */);
   EXPECT_EQ(0U, incidents_.size());
 }
@@ skipping 22 matching lines @@
     is_personal_ = std::tr1::get<2>(GetParam());
   }
 
   ValueState value_state_;
   ValueState external_validation_value_state_;
   bool is_personal_;
 };
 
 TEST_P(PreferenceValidationDelegateWithIncident, Atomic) {
   instance_->OnAtomicPreferenceValidation(
-      kPrefPath, base::Value::CreateNullValue(), value_state_,
+      kPrefPath, base::MakeUnique<base::Value>(), value_state_,
       external_validation_value_state_, is_personal_);
   ASSERT_EQ(1U, incidents_.size());
   std::unique_ptr<safe_browsing::ClientIncidentReport_IncidentData> incident(
       incidents_.back()->TakePayload());
   EXPECT_TRUE(incident->has_tracked_preference());
   const safe_browsing::
       ClientIncidentReport_IncidentData_TrackedPreferenceIncident& tp_incident =
           incident->tracked_preference();
   EXPECT_EQ(kPrefPath, tp_incident.path());
   EXPECT_EQ(0, tp_incident.split_key_size());
@@ skipping 59 matching lines @@
                      testing::Bool()));
 
 INSTANTIATE_TEST_CASE_P(
     WithIncidentIgnoreBypass,
     PreferenceValidationDelegateWithIncident,
     testing::Combine(testing::Values(ValueState::CLEARED,
                                      ValueState::CHANGED,
                                      ValueState::UNTRUSTED_UNKNOWN_VALUE),
                      testing::Values(ValueState::CHANGED, ValueState::CLEARED),
                      testing::Bool()));