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

net/spdy/spdy_stream.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/spdy/spdy_stream.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 namespace {
 
 scoped_ptr<base::Value> NetLogSpdyStreamErrorCallback(
     SpdyStreamId stream_id,
     int status,
     const std::string* description,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetInteger("status", status);
   dict->SetString("description", *description);
-  return dict.Pass();
+  return std::move(dict);
 }
 
 scoped_ptr<base::Value> NetLogSpdyStreamWindowUpdateCallback(
     SpdyStreamId stream_id,
     int32_t delta,
     int32_t window_size,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", stream_id);
   dict->SetInteger("delta", delta);
   dict->SetInteger("window_size", window_size);
-  return dict.Pass();
+  return std::move(dict);
 }
 
 bool ContainsUppercaseAscii(const std::string& str) {
   for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) {
     if (*i >= 'A' && *i <= 'Z') {
       return true;
     }
   }
   return false;
 }
@@ skipping 120 matching lines @@
   response_headers_status_ = RESPONSE_HEADERS_ARE_COMPLETE;
 
   while (!pending_recv_data_.empty()) {
     // Take ownership of the first element of |pending_recv_data_|.
     scoped_ptr<SpdyBuffer> buffer = std::move(pending_recv_data_.at(0));
     pending_recv_data_.erase(pending_recv_data_.begin());
 
     bool eof = (buffer == NULL);
 
     CHECK(delegate_);
-    delegate_->OnDataReceived(buffer.Pass());
+    delegate_->OnDataReceived(std::move(buffer));
 
     // OnDataReceived() may have closed |this|.
     if (!weak_this)
       return;
 
     if (eof) {
       DCHECK(pending_recv_data_.empty());
       session_->CloseActiveStream(stream_id_, OK);
       DCHECK(!weak_this);
       // |pending_recv_data_| is invalid at this point.
       break;
     }
   }
 }
 
 scoped_ptr<SpdyFrame> SpdyStream::ProduceSynStreamFrame() {
   CHECK_EQ(io_state_, STATE_IDLE);
   CHECK(request_headers_);
   CHECK_GT(stream_id_, 0u);
 
   SpdyControlFlags flags =
       (pending_send_status_ == NO_MORE_DATA_TO_SEND) ?
       CONTROL_FLAG_FIN : CONTROL_FLAG_NONE;
   scoped_ptr<SpdyFrame> frame(session_->CreateSynStream(
       stream_id_, priority_, flags, *request_headers_));
   send_time_ = base::TimeTicks::Now();
-  return frame.Pass();
+  return frame;
 }
 
 void SpdyStream::DetachDelegate() {
   DCHECK(!IsClosed());
   delegate_ = NULL;
   Cancel();
 }
 
 void SpdyStream::AdjustSendWindowSize(int32_t delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
@@ skipping 323 matching lines @@
       return;
     buffer->AddConsumeCallback(
         base::Bind(&SpdyStream::OnReadBufferConsumed, GetWeakPtr()));
   }
 
   // Track our bandwidth.
   recv_bytes_ += length;
   recv_last_byte_time_ = base::TimeTicks::Now();
 
   // May close |this|.
-  delegate_->OnDataReceived(buffer.Pass());
+  delegate_->OnDataReceived(std::move(buffer));
 }
 
 void SpdyStream::OnPaddingConsumed(size_t len) {
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     // Decrease window size because padding bytes are received.
     // Increase window size because padding bytes are consumed (by discarding).
     // Net result: |unacked_recv_window_bytes_| increases by |len|,
     // |recv_window_size_| does not change.
     base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
     // May close the stream.
@@ skipping 130 matching lines @@
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> request_headers,
                                    SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(pending_send_status_, MORE_DATA_TO_SEND);
   CHECK(!request_headers_);
   CHECK(!pending_send_data_.get());
   CHECK_EQ(io_state_, STATE_IDLE);
-  request_headers_ = request_headers.Pass();
+  request_headers_ = std::move(request_headers);
   pending_send_status_ = send_status;
   session_->EnqueueStreamWrite(
       GetWeakPtr(), SYN_STREAM,
       scoped_ptr<SpdyBufferProducer>(
           new SynStreamBufferProducer(GetWeakPtr())));
   return ERR_IO_PENDING;
 }
 
 void SpdyStream::SendData(IOBuffer* data,
                           int length,
@@ skipping 153 matching lines @@
       // here anyway just in case this changes.
       data_buffer->AddConsumeCallback(
           base::Bind(&SpdyStream::OnWriteBufferConsumed,
                      GetWeakPtr(), payload_size));
     }
   }
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       scoped_ptr<SpdyBufferProducer>(
-          new SimpleBufferProducer(data_buffer.Pass())));
+          new SimpleBufferProducer(std::move(data_buffer))));
 }
 
 int SpdyStream::MergeWithResponseHeaders(
     const SpdyHeaderBlock& new_response_headers) {
   if (new_response_headers.find("transfer-encoding") !=
       new_response_headers.end()) {
     session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
                          "Received transfer-encoding header");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
@@ skipping 65 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net