Use std::unique_ptr to transfer base::Value ownership in extensions::ValueStoreChange

chrome/browser/extensions/api/storage/syncable_settings_storage.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/extensions/api/storage/syncable_settings_storage.h"
 
 #include <utility>
 
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
@@ skipping 176 matching lines @@
     return syncer::SyncError();
 
   // Transform the current settings into a list of sync changes.
   ValueStoreChangeList changes;
   while (!local_state->empty()) {
     // It's not possible to iterate over a DictionaryValue and modify it at the
     // same time, so hack around that restriction.
     std::string key = base::DictionaryValue::Iterator(*local_state).key();
     std::unique_ptr<base::Value> value;
     local_state->RemoveWithoutPathExpansion(key, &value);
-    changes.push_back(ValueStoreChange(key, nullptr, value.release()));
+    changes.push_back(ValueStoreChange(key, nullptr, std::move(value)));
   }
 
   syncer::SyncError error = sync_processor_->SendChanges(changes);
   if (error.IsSet())
     StopSyncing();
   return error;
 }
 
 syncer::SyncError SyncableSettingsStorage::OverwriteLocalSettingsWithSync(
     std::unique_ptr<base::DictionaryValue> sync_state,
@@ skipping 80 matching lines @@
       }
       maybe_settings->settings().RemoveWithoutPathExpansion(key,
                                                             &current_value);
     }
 
     syncer::SyncError error;
 
     switch ((*it)->change_type()) {
       case syncer::SyncChange::ACTION_ADD:
         if (!current_value.get()) {
-          error = OnSyncAdd(key, change_value.release(), &changes);
+          error = OnSyncAdd(key, std::move(change_value), &changes);
         } else {
           // Already a value; hopefully a local change has beaten sync in a
           // race and change's not a bug, so pretend change's an update.
           LOG(WARNING) << "Got add from sync for existing setting " <<
               extension_id_ << "/" << key;
-          error = OnSyncUpdate(key, current_value.release(),
-                               change_value.release(), &changes);
+          error = OnSyncUpdate(key, std::move(current_value),
+                               std::move(change_value), &changes);
         }
         break;
 
       case syncer::SyncChange::ACTION_UPDATE:
         if (current_value.get()) {
-          error = OnSyncUpdate(key, current_value.release(),
-                               change_value.release(), &changes);
+          error = OnSyncUpdate(key, std::move(current_value),
+                               std::move(change_value), &changes);
         } else {
           // Similarly, pretend change's an add.
           LOG(WARNING) << "Got update from sync for nonexistent setting" <<
               extension_id_ << "/" << key;
-          error = OnSyncAdd(key, change_value.release(), &changes);
+          error = OnSyncAdd(key, std::move(change_value), &changes);
         }
         break;
 
       case syncer::SyncChange::ACTION_DELETE:
         if (current_value.get()) {
-          error = OnSyncDelete(key, current_value.release(), &changes);
+          error = OnSyncDelete(key, std::move(current_value), &changes);
         } else {
           // Similarly, ignore change.
           LOG(WARNING) << "Got delete from sync for nonexistent setting " <<
               extension_id_ << "/" << key;
         }
         break;
 
       default:
         NOTREACHED();
     }
 
     if (error.IsSet()) {
       errors.push_back(error);
     }
   }
 
   sync_processor_->NotifyChanges(changes);
 
   observers_->Notify(FROM_HERE, &SettingsObserver::OnSettingsChanged,
                      extension_id_, settings_namespace::SYNC,
                      ValueStoreChange::ToJson(changes));
 
   // TODO(kalman): Something sensible with multiple errors.
   return errors.empty() ? syncer::SyncError() : errors[0];
 }
 
 syncer::SyncError SyncableSettingsStorage::OnSyncAdd(
     const std::string& key,
-    base::Value* new_value,
+    std::unique_ptr<base::Value> new_value,
     ValueStoreChangeList* changes) {
   DCHECK(new_value);
   WriteResult result =
       HandleResult(delegate_->Set(IGNORE_QUOTA, key, *new_value));
   if (!result->status().ok()) {
     return syncer::SyncError(
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
         base::StringPrintf("Error pushing sync add to local settings: %s",
                            result->status().message.c_str()),
         sync_processor_->type());
   }
-  changes->push_back(ValueStoreChange(key, NULL, new_value));
+  changes->push_back(ValueStoreChange(key, nullptr, std::move(new_value)));
   return syncer::SyncError();
 }
 
 syncer::SyncError SyncableSettingsStorage::OnSyncUpdate(
     const std::string& key,
-    base::Value* old_value,
-    base::Value* new_value,
+    std::unique_ptr<base::Value> old_value,
+    std::unique_ptr<base::Value> new_value,
     ValueStoreChangeList* changes) {
   DCHECK(old_value);
   DCHECK(new_value);
   WriteResult result =
       HandleResult(delegate_->Set(IGNORE_QUOTA, key, *new_value));
   if (!result->status().ok()) {
     return syncer::SyncError(
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
         base::StringPrintf("Error pushing sync update to local settings: %s",
                            result->status().message.c_str()),
         sync_processor_->type());
   }
-  changes->push_back(ValueStoreChange(key, old_value, new_value));
+  changes->push_back(
+      ValueStoreChange(key, std::move(old_value), std::move(new_value)));
   return syncer::SyncError();
 }
 
 syncer::SyncError SyncableSettingsStorage::OnSyncDelete(
     const std::string& key,
-    base::Value* old_value,
+    std::unique_ptr<base::Value> old_value,
     ValueStoreChangeList* changes) {
   DCHECK(old_value);
   WriteResult result = HandleResult(delegate_->Remove(key));
   if (!result->status().ok()) {
     return syncer::SyncError(
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
         base::StringPrintf("Error pushing sync remove to local settings: %s",
                            result->status().message.c_str()),
         sync_processor_->type());
   }
-  changes->push_back(ValueStoreChange(key, old_value, NULL));
+  changes->push_back(ValueStoreChange(key, std::move(old_value), nullptr));
   return syncer::SyncError();
 }
 
 }  // namespace extensions