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

net/websockets/websocket_basic_stream_test.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.
 //
 // Tests for WebSocketBasicStream. Note that we do not attempt to verify that
 // frame parsing itself functions correctly, as that is covered by the
 // WebSocketFrameParser tests.
 
 #include "net/websockets/websocket_basic_stream.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>  // for memcpy() and memset().
-
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/macros.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 101 matching lines @@
     factory_.AddSocketDataProvider(socket_data_.get());
 
     scoped_ptr<ClientSocketHandle> transport_socket(new ClientSocketHandle);
     scoped_refptr<MockTransportSocketParams> params;
     transport_socket->Init("a",
                            params,
                            MEDIUM,
                            CompletionCallback(),
                            &pool_,
                            bound_net_log_.bound());
-    return transport_socket.Pass();
+    return transport_socket;
   }
 
   void SetHttpReadBuffer(const char* data, size_t size) {
     http_read_buffer_ = new GrowableIOBuffer;
     http_read_buffer_->SetCapacity(size);
     memcpy(http_read_buffer_->data(), data, size);
     http_read_buffer_->set_offset(size);
   }
 
   void CreateStream(MockRead reads[],
@@ skipping 100 matching lines @@
         kWriteFrameSize - (WebSocketFrameHeader::kBaseHeaderSize +
                            WebSocketFrameHeader::kMaskingKeyLength);
     frame->data = new IOBuffer(payload_size);
     memcpy(frame->data->data(),
            kWriteFrame + kWriteFrameSize - payload_size,
            payload_size);
     WebSocketFrameHeader& header = frame->header;
     header.final = true;
     header.masked = true;
     header.payload_length = payload_size;
-    frames_.push_back(frame.Pass());
+    frames_.push_back(std::move(frame));
   }
 
   // Creates a stream that expects the listed writes.
   template <size_t N>
   void CreateWriteOnly(MockWrite (&writes)[N]) {
     CreateStream(NULL, 0, writes, N);
   }
 };
 
 TEST_F(WebSocketBasicStreamSocketTest, ConstructionWorks) {
@@ skipping 622 matching lines @@
       MockWrite(SYNCHRONOUS, kMaskedEmptyPong, kMaskedEmptyPongSize)};
   CreateWriteOnly(writes);
 
   scoped_ptr<WebSocketFrame> frame(
       new WebSocketFrame(WebSocketFrameHeader::kOpCodePong));
   WebSocketFrameHeader& header = frame->header;
   header.final = true;
   header.masked = true;
   header.payload_length = 0;
   std::vector<scoped_ptr<WebSocketFrame>> frames;
-  frames.push_back(frame.Pass());
+  frames.push_back(std::move(frame));
   EXPECT_EQ(OK, stream_->WriteFrames(&frames, cb_.callback()));
 }
 
 // Check that writing with a non-NULL mask works correctly.
 TEST_F(WebSocketBasicStreamSocketTest, WriteNonNulMask) {
   std::string masked_frame = std::string("\x81\x88");
   masked_frame += std::string(kNonNulMaskingKey.key, 4);
   masked_frame += "jiggered";
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, masked_frame.data(), masked_frame.size())};
   generator_ = &GenerateNonNulMaskingKey;
   CreateStream(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<WebSocketFrame> frame(
       new WebSocketFrame(WebSocketFrameHeader::kOpCodeText));
   const std::string unmasked_payload = "graphics";
   const size_t payload_size = unmasked_payload.size();
   frame->data = new IOBuffer(payload_size);
   memcpy(frame->data->data(), unmasked_payload.data(), payload_size);
   WebSocketFrameHeader& header = frame->header;
   header.final = true;
   header.masked = true;
   header.payload_length = payload_size;
-  frames_.push_back(frame.Pass());
+  frames_.push_back(std::move(frame));
 
   EXPECT_EQ(OK, stream_->WriteFrames(&frames_, cb_.callback()));
 }
 
 TEST_F(WebSocketBasicStreamSocketTest, GetExtensionsWorks) {
   extensions_ = "inflate-uuencode";
   CreateNullStream();
 
   EXPECT_EQ("inflate-uuencode", stream_->GetExtensions());
 }
 
 TEST_F(WebSocketBasicStreamSocketTest, GetSubProtocolWorks) {
   sub_protocol_ = "cyberchat";
   CreateNullStream();
 
   EXPECT_EQ("cyberchat", stream_->GetSubProtocol());
 }
 
 }  // namespace
 }  // namespace net