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

net/websockets/websocket_basic_stream.cc

 // Copyright 2013 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/websockets/websocket_basic_stream.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
@@ skipping 54 matching lines @@
 }
 
 }  // namespace
 
 WebSocketBasicStream::WebSocketBasicStream(
     scoped_ptr<ClientSocketHandle> connection,
     const scoped_refptr<GrowableIOBuffer>& http_read_buffer,
     const std::string& sub_protocol,
     const std::string& extensions)
     : read_buffer_(new IOBufferWithSize(kReadBufferSize)),
-      connection_(connection.Pass()),
+      connection_(std::move(connection)),
       http_read_buffer_(http_read_buffer),
       sub_protocol_(sub_protocol),
       extensions_(extensions),
       generate_websocket_masking_key_(&GenerateWebSocketMaskingKey) {
   // http_read_buffer_ should not be set if it contains no data.
   if (http_read_buffer_.get() && http_read_buffer_->offset() == 0)
     http_read_buffer_ = NULL;
   DCHECK(connection_->is_initialized());
 }
 
@@ skipping 99 matching lines @@
 
 /*static*/
 scoped_ptr<WebSocketBasicStream>
 WebSocketBasicStream::CreateWebSocketBasicStreamForTesting(
     scoped_ptr<ClientSocketHandle> connection,
     const scoped_refptr<GrowableIOBuffer>& http_read_buffer,
     const std::string& sub_protocol,
     const std::string& extensions,
     WebSocketMaskingKeyGeneratorFunction key_generator_function) {
   scoped_ptr<WebSocketBasicStream> stream(new WebSocketBasicStream(
-      connection.Pass(), http_read_buffer, sub_protocol, extensions));
+      std::move(connection), http_read_buffer, sub_protocol, extensions));
   stream->generate_websocket_masking_key_ = key_generator_function;
-  return stream.Pass();
+  return stream;
 }
 
 int WebSocketBasicStream::WriteEverything(
     const scoped_refptr<DrainableIOBuffer>& buffer,
     const CompletionCallback& callback) {
   while (buffer->BytesRemaining() > 0) {
     // The use of base::Unretained() here is safe because on destruction we
     // disconnect the socket, preventing any further callbacks.
     int result = connection_->socket()->Write(
         buffer.get(),
@@ skipping 47 matching lines @@
 
 int WebSocketBasicStream::ConvertChunksToFrames(
     std::vector<scoped_ptr<WebSocketFrameChunk>>* frame_chunks,
     std::vector<scoped_ptr<WebSocketFrame>>* frames) {
   for (size_t i = 0; i < frame_chunks->size(); ++i) {
     scoped_ptr<WebSocketFrame> frame;
     int result = ConvertChunkToFrame(std::move((*frame_chunks)[i]), &frame);
     if (result != OK)
       return result;
     if (frame)
-      frames->push_back(frame.Pass());
+      frames->push_back(std::move(frame));
   }
   frame_chunks->clear();
   if (frames->empty())
     return ERR_IO_PENDING;
   return OK;
 }
 
 int WebSocketBasicStream::ConvertChunkToFrame(
     scoped_ptr<WebSocketFrameChunk> chunk,
     scoped_ptr<WebSocketFrame>* frame) {
@@ skipping 107 matching lines @@
       current_frame_header_->opcode = WebSocketFrameHeader::kOpCodeContinuation;
       current_frame_header_->reserved1 = false;
       current_frame_header_->reserved2 = false;
       current_frame_header_->reserved3 = false;
     }
   }
   // Make sure that a frame header is not applied to any chunks that do not
   // belong to it.
   if (is_final_chunk)
     current_frame_header_.reset();
-  return result_frame.Pass();
+  return result_frame;
 }
 
 void WebSocketBasicStream::AddToIncompleteControlFrameBody(
     const scoped_refptr<IOBufferWithSize>& data_buffer) {
   if (!data_buffer.get())
     return;
   const int new_offset =
       incomplete_control_frame_body_->offset() + data_buffer->size();
   CHECK_GE(incomplete_control_frame_body_->capacity(), new_offset)
       << "Control frame body larger than frame header indicates; frame parser "
          "bug?";
   memcpy(incomplete_control_frame_body_->data(),
          data_buffer->data(),
          data_buffer->size());
   incomplete_control_frame_body_->set_offset(new_offset);
 }
 
 void WebSocketBasicStream::OnReadComplete(
     std::vector<scoped_ptr<WebSocketFrame>>* frames,
     const CompletionCallback& callback,
     int result) {
   result = HandleReadResult(result, frames);
   if (result == ERR_IO_PENDING)
     result = ReadFrames(frames, callback);
   if (result != ERR_IO_PENDING)
     callback.Run(result);
 }
 
 }  // namespace net