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

base/values.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/values.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cmath>
 #include <ostream>
+#include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/move.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace base {
 
 namespace {
 
 scoped_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
 
 // Make a deep copy of |node|, but don't include empty lists or dictionaries
 // in the copy. It's possible for this function to return NULL and it
 // expects |node| to always be non-NULL.
 scoped_ptr<ListValue> CopyListWithoutEmptyChildren(const ListValue& list) {
   scoped_ptr<ListValue> copy;
   for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) {
     scoped_ptr<Value> child_copy = CopyWithoutEmptyChildren(**it);
     if (child_copy) {
       if (!copy)
         copy.reset(new ListValue);
-      copy->Append(child_copy.Pass());
+      copy->Append(std::move(child_copy));
     }
   }
   return copy;
 }
 
 scoped_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
     const DictionaryValue& dict) {
   scoped_ptr<DictionaryValue> copy;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     scoped_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
     if (child_copy) {
       if (!copy)
         copy.reset(new DictionaryValue);
-      copy->SetWithoutPathExpansion(it.key(), child_copy.Pass());
+      copy->SetWithoutPathExpansion(it.key(), std::move(child_copy));
     }
   }
   return copy;
 }
 
 scoped_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
   switch (node.GetType()) {
     case Value::TYPE_LIST:
       return CopyListWithoutEmptyChildren(static_cast<const ListValue&>(node));
 
@@ skipping 246 matching lines @@
 }
 
 ///////////////////// BinaryValue ////////////////////
 
 BinaryValue::BinaryValue()
     : Value(TYPE_BINARY),
       size_(0) {
 }
 
 BinaryValue::BinaryValue(scoped_ptr<char[]> buffer, size_t size)
-    : Value(TYPE_BINARY),
-      buffer_(buffer.Pass()),
-      size_(size) {
-}
+    : Value(TYPE_BINARY), buffer_(std::move(buffer)), size_(size) {}
 
 BinaryValue::~BinaryValue() {
 }
 
 // static
 BinaryValue* BinaryValue::CreateWithCopiedBuffer(const char* buffer,
                                                  size_t size) {
   char* buffer_copy = new char[size];
   memcpy(buffer_copy, buffer, size);
   scoped_ptr<char[]> scoped_buffer_copy(buffer_copy);
-  return new BinaryValue(scoped_buffer_copy.Pass(), size);
+  return new BinaryValue(std::move(scoped_buffer_copy), size);
 }
 
 bool BinaryValue::GetAsBinary(const BinaryValue** out_value) const {
   if (out_value)
     *out_value = this;
   return true;
 }
 
 BinaryValue* BinaryValue::DeepCopy() const {
   return CreateWithCopiedBuffer(buffer_.get(), size_);
@@ skipping 71 matching lines @@
     DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
       child_dictionary = new DictionaryValue;
       current_dictionary->SetWithoutPathExpansion(key, child_dictionary);
     }
 
     current_dictionary = child_dictionary;
     current_path.erase(0, delimiter_position + 1);
   }
 
-  current_dictionary->SetWithoutPathExpansion(current_path, in_value.Pass());
+  current_dictionary->SetWithoutPathExpansion(current_path,
+                                              std::move(in_value));
 }
 
 void DictionaryValue::Set(const std::string& path, Value* in_value) {
   Set(path, make_scoped_ptr(in_value));
 }
 
 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
@@ skipping 762 matching lines @@
 ValueDeserializer::~ValueDeserializer() {
 }
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return out << json;
 }
 
 }  // namespace base