Stop passing raw pointers to DictionaryValue::Set, part 2

chrome/browser/chromeos/policy/auto_enrollment_client.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/policy/auto_enrollment_client.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/guid.h"
@@ skipping 37 matching lines @@
       return i;
   }
   // No other value can be represented in an int64_t.
   return AutoEnrollmentClient::kMaximumPower + 1;
 }
 
 // Sets or clears a value in a dictionary.
 void UpdateDict(base::DictionaryValue* dict,
                 const char* pref_path,
                 bool set_or_clear,
-                base::Value* value) {
-  std::unique_ptr<base::Value> scoped_value(value);
+                std::unique_ptr<base::Value> value) {
   if (set_or_clear)
-    dict->Set(pref_path, scoped_value.release());
+    dict->Set(pref_path, std::move(value));
   else
     dict->Remove(pref_path, NULL);
 }
 
 // Converts a restore mode enum value from the DM protocol into the
 // corresponding prefs string constant.
 std::string ConvertRestoreMode(
     em::DeviceStateRetrievalResponse::RestoreMode restore_mode) {
   switch (restore_mode) {
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_NONE:
@@ skipping 297 matching lines @@
     int net_error,
     const enterprise_management::DeviceManagementResponse& response) {
   bool progress = false;
   if (!response.has_device_state_retrieval_response()) {
     LOG(ERROR) << "Server failed to provide auto-enrollment response.";
   } else {
     const em::DeviceStateRetrievalResponse& state_response =
         response.device_state_retrieval_response();
     {
       DictionaryPrefUpdate dict(local_state_, prefs::kServerBackedDeviceState);
-      UpdateDict(dict.Get(), kDeviceStateManagementDomain,
-                 state_response.has_management_domain(),
-                 new base::Value(state_response.management_domain()));
+      UpdateDict(
+          dict.Get(), kDeviceStateManagementDomain,
+          state_response.has_management_domain(),
+          base::MakeUnique<base::Value>(state_response.management_domain()));
 
       std::string restore_mode =
           ConvertRestoreMode(state_response.restore_mode());
       UpdateDict(dict.Get(), kDeviceStateRestoreMode, !restore_mode.empty(),
-                 new base::Value(restore_mode));
+                 base::MakeUnique<base::Value>(restore_mode));
 
       UpdateDict(dict.Get(), kDeviceStateDisabledMessage,
                  state_response.has_disabled_state(),
-                 new base::Value(state_response.disabled_state().message()));
+                 base::MakeUnique<base::Value>(
+                     state_response.disabled_state().message()));
 
       // Logging as "WARNING" to make sure it's preserved in the logs.
       LOG(WARNING) << "Restore mode: " << restore_mode;
     }
     local_state_->CommitPendingWrite();
     device_state_available_ = true;
     progress = true;
   }
 
   return progress;
@@ skipping 24 matching lines @@
   base::TimeDelta delta = kZero;
   if (!time_extra_start_.is_null())
     delta = now - time_extra_start_;
   // This samples |kZero| when there was no need for extra time, so that we can
   // measure the ratio of users that succeeded without needing a delay to the
   // total users going through OOBE.
   UMA_HISTOGRAM_CUSTOM_TIMES(kUMAExtraTime, delta, kMin, kMax, kBuckets);
 }
 
 }  // namespace policy