Switch base::Value typemapping to be by value instead of by unique_ptr.

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>
@@ skipping 81 matching lines @@
   }
 
   IncidentVector incidents_;
   std::vector<std::string> invalid_keys_;
   std::vector<std::string> external_validation_invalid_keys_;
   std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate> instance_;
 };
 
 // Tests that a NULL value results in an incident with no value.
 TEST_F(PreferenceValidationDelegateTest, NullValue) {
-  instance_->OnAtomicPreferenceValidation(kPrefPath, NULL, ValueState::CLEARED,
-                                          ValueState::UNSUPPORTED,
-                                          false /* is_personal */);
+  instance_->OnAtomicPreferenceValidation(
+      kPrefPath, base::nullopt, ValueState::CLEARED, ValueState::UNSUPPORTED,
+      false /* is_personal */);
   std::unique_ptr<safe_browsing::ClientIncidentReport_IncidentData> incident(
       incidents_.back()->TakePayload());
   EXPECT_FALSE(incident->tracked_preference().has_atomic_value());
   EXPECT_EQ(
       safe_browsing::
           ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CLEARED,
       incident->tracked_preference().value_state());
 }
 
 // Tests that all supported value types can be stringified into an incident. The
@@ skipping 41 matching lines @@
     }
     return std::unique_ptr<Value>();
   }
 
   base::Value::Type value_type_;
   const char* expected_value_;
 };
 
 TEST_P(PreferenceValidationDelegateValues, Value) {
   instance_->OnAtomicPreferenceValidation(
-      kPrefPath, MakeValue(value_type_), ValueState::CLEARED,
+      kPrefPath, *MakeValue(value_type_), ValueState::CLEARED,
       ValueState::UNSUPPORTED, false /* is_personal */);
   ASSERT_EQ(1U, incidents_.size());
   std::unique_ptr<safe_browsing::ClientIncidentReport_IncidentData> incident(
       incidents_.back()->TakePayload());
   EXPECT_EQ(std::string(expected_value_),
             incident->tracked_preference().atomic_value());
 }
 
 INSTANTIATE_TEST_CASE_P(
     Values,
@@ skipping 28 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::Value::CreateNullValue(), 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::Value::CreateNullValue(), 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()));