Convert Pass()→std::move() in //net

net/log/net_log.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 "net/log/net_log.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
 // Returns parameters for logging data transferred events. At a minimum includes
 // the number of bytes transferred. If the capture mode allows logging byte
 // contents and |byte_count| > 0, then will include the actual bytes. The
 // bytes are hex-encoded, since base::StringValue only supports UTF-8.
 scoped_ptr<base::Value> BytesTransferredCallback(
     int byte_count,
     const char* bytes,
     NetLogCaptureMode capture_mode) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("byte_count", byte_count);
   if (capture_mode.include_socket_bytes() && byte_count > 0)
     dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count));
-  return dict.Pass();
+  return std::move(dict);
 }
 
 scoped_ptr<base::Value> SourceEventParametersCallback(
     const NetLog::Source source,
     NetLogCaptureMode /* capture_mode */) {
   if (!source.IsValid())
     return scoped_ptr<base::Value>();
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   source.AddToEventParameters(event_params.get());
-  return event_params.Pass();
+  return std::move(event_params);
 }
 
 scoped_ptr<base::Value> NetLogBoolCallback(
     const char* name,
     bool value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetBoolean(name, value);
-  return event_params.Pass();
+  return std::move(event_params);
 }
 
 scoped_ptr<base::Value> NetLogIntCallback(
     const char* name,
     int value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetInteger(name, value);
-  return event_params.Pass();
+  return std::move(event_params);
 }
 
 scoped_ptr<base::Value> NetLogInt64Callback(
     const char* name,
     int64_t value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, base::Int64ToString(value));
-  return event_params.Pass();
+  return std::move(event_params);
 }
 
 scoped_ptr<base::Value> NetLogStringCallback(
     const char* name,
     const std::string* value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, *value);
-  return event_params.Pass();
+  return std::move(event_params);
 }
 
 scoped_ptr<base::Value> NetLogString16Callback(
     const char* name,
     const base::string16* value,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, *value);
-  return event_params.Pass();
+  return std::move(event_params);
 }
 
 }  // namespace
 
 // LoadTimingInfo requires this be 0.
 const uint32_t NetLog::Source::kInvalidId = 0;
 
 NetLog::Source::Source() : type(SOURCE_NONE), id(kInvalidId) {
 }
 
 NetLog::Source::Source(SourceType type, uint32_t id) : type(type), id(id) {}
 
 bool NetLog::Source::IsValid() const {
   return id != kInvalidId;
 }
 
 void NetLog::Source::AddToEventParameters(
     base::DictionaryValue* event_params) const {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("type", static_cast<int>(type));
   dict->SetInteger("id", static_cast<int>(id));
-  event_params->Set("source_dependency", dict.Pass());
+  event_params->Set("source_dependency", std::move(dict));
 }
 
 NetLog::ParametersCallback NetLog::Source::ToEventParametersCallback() const {
   return base::Bind(&SourceEventParametersCallback, *this);
 }
 
 // static
 bool NetLog::Source::FromEventParameters(base::Value* event_params,
                                          Source* source) {
   base::DictionaryValue* dict = NULL;
@@ skipping 16 matching lines @@
 
 base::Value* NetLog::Entry::ToValue() const {
   scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
 
   entry_dict->SetString("time", TickCountToString(data_->time));
 
   // Set the entry source.
   scoped_ptr<base::DictionaryValue> source_dict(new base::DictionaryValue());
   source_dict->SetInteger("id", data_->source.id);
   source_dict->SetInteger("type", static_cast<int>(data_->source.type));
-  entry_dict->Set("source", source_dict.Pass());
+  entry_dict->Set("source", std::move(source_dict));
 
   // Set the event info.
   entry_dict->SetInteger("type", static_cast<int>(data_->type));
   entry_dict->SetInteger("phase", static_cast<int>(data_->phase));
 
   // Set the event-specific parameters.
   if (data_->parameters_callback) {
     scoped_ptr<base::Value> value(
         data_->parameters_callback->Run(capture_mode_));
     if (value)
-      entry_dict->Set("params", value.Pass());
+      entry_dict->Set("params", std::move(value));
   }
 
   return entry_dict.release();
 }
 
 base::Value* NetLog::Entry::ParametersToValue() const {
   if (data_->parameters_callback)
     return data_->parameters_callback->Run(capture_mode_).release();
   return NULL;
 }
@@ skipping 314 matching lines @@
   Liveness liveness = liveness_;
 
   if (liveness == ALIVE)
     return;
 
   base::debug::Alias(&liveness);
   CHECK_EQ(ALIVE, liveness);
 }
 
 }  // namespace net