base: Use std::move() instead of Pass() for real movable types.

base/prefs/json_pref_store.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 "base/prefs/json_pref_store.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_filter.h"
@@ skipping 101 matching lines @@
       new JsonPrefStore::ReadResult);
   JSONFileValueDeserializer deserializer(path);
   read_result->value = deserializer.Deserialize(&error_code, &error_msg);
   read_result->error =
       HandleReadErrors(read_result->value.get(), path, error_code, error_msg);
   read_result->no_dir = !base::PathExists(path.DirName());
 
   if (read_result->error == PersistentPrefStore::PREF_READ_ERROR_NONE)
     RecordJsonDataSizeHistogram(path, deserializer.get_last_read_size());
 
-  return read_result.Pass();
+  return read_result;
 }
 
 }  // namespace
 
 // static
 scoped_refptr<base::SequencedTaskRunner> JsonPrefStore::GetTaskRunnerForFile(
     const base::FilePath& filename,
     base::SequencedWorkerPool* worker_pool) {
   std::string token("json_pref_store-");
   token.append(filename.AsUTF8Unsafe());
   return worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
       worker_pool->GetNamedSequenceToken(token),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
 JsonPrefStore::JsonPrefStore(
     const base::FilePath& pref_filename,
     const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
     scoped_ptr<PrefFilter> pref_filter)
     : JsonPrefStore(pref_filename,
                     base::FilePath(),
                     sequenced_task_runner,
-                    pref_filter.Pass()) {
-}
+                    std::move(pref_filter)) {}
 
 JsonPrefStore::JsonPrefStore(
     const base::FilePath& pref_filename,
     const base::FilePath& pref_alternate_filename,
     const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
     scoped_ptr<PrefFilter> pref_filter)
     : path_(pref_filename),
       alternate_path_(pref_alternate_filename),
       sequenced_task_runner_(sequenced_task_runner),
       prefs_(new base::DictionaryValue()),
       read_only_(false),
       writer_(pref_filename, sequenced_task_runner),
-      pref_filter_(pref_filter.Pass()),
+      pref_filter_(std::move(pref_filter)),
       initialized_(false),
       filtering_in_progress_(false),
       pending_lossy_write_(false),
       read_error_(PREF_READ_ERROR_NONE),
       write_count_histogram_(writer_.commit_interval(), path_) {
   DCHECK(!path_.empty());
 }
 
 bool JsonPrefStore::GetValue(const std::string& key,
                              const base::Value** result) const {
@@ skipping 41 matching lines @@
 
 void JsonPrefStore::SetValue(const std::string& key,
                              scoped_ptr<base::Value> value,
                              uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
-    prefs_->Set(key, value.Pass());
+    prefs_->Set(key, std::move(value));
     ReportValueChanged(key, flags);
   }
 }
 
 void JsonPrefStore::SetValueSilently(const std::string& key,
                                      scoped_ptr<base::Value> value,
                                      uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
-    prefs_->Set(key, value.Pass());
+    prefs_->Set(key, std::move(value));
     ScheduleWrite(flags);
   }
 }
 
 void JsonPrefStore::RemoveValue(const std::string& key, uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   if (prefs_->RemovePath(key, nullptr))
     ReportValueChanged(key, flags);
 }
@@ skipping 117 matching lines @@
     }
   }
 
   if (pref_filter_) {
     filtering_in_progress_ = true;
     const PrefFilter::PostFilterOnLoadCallback post_filter_on_load_callback(
         base::Bind(
             &JsonPrefStore::FinalizeFileRead, AsWeakPtr(),
             initialization_successful));
     pref_filter_->FilterOnLoad(post_filter_on_load_callback,
-                               unfiltered_prefs.Pass());
+                               std::move(unfiltered_prefs));
   } else {
-    FinalizeFileRead(initialization_successful, unfiltered_prefs.Pass(), false);
+    FinalizeFileRead(initialization_successful, std::move(unfiltered_prefs),
+                     false);
   }
 }
 
 JsonPrefStore::~JsonPrefStore() {
   CommitPendingWrite();
 }
 
 bool JsonPrefStore::SerializeData(std::string* output) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 19 matching lines @@
 
   filtering_in_progress_ = false;
 
   if (!initialization_successful) {
     FOR_EACH_OBSERVER(PrefStore::Observer,
                       observers_,
                       OnInitializationCompleted(false));
     return;
   }
 
-  prefs_ = prefs.Pass();
+  prefs_ = std::move(prefs);
 
   initialized_ = true;
 
   if (schedule_write)
     ScheduleWrite(DEFAULT_PREF_WRITE_FLAGS);
 
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
@@ skipping 93 matching lines @@
   DCHECK_EQ(31, num_buckets);
 
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       histogram_name, min_value, max_value, num_buckets,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   return histogram;
 }