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

net/websockets/websocket_deflate_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_deflate_stream.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 22 matching lines @@
 
 const int kWindowBits = 15;
 const size_t kChunkSize = 4 * 1024;
 
 }  // namespace
 
 WebSocketDeflateStream::WebSocketDeflateStream(
     scoped_ptr<WebSocketStream> stream,
     const WebSocketDeflateParameters& params,
     scoped_ptr<WebSocketDeflatePredictor> predictor)
-    : stream_(stream.Pass()),
+    : stream_(std::move(stream)),
       deflater_(params.client_context_take_over_mode()),
       inflater_(kChunkSize, kChunkSize),
       reading_state_(NOT_READING),
       writing_state_(NOT_WRITING),
       current_reading_opcode_(WebSocketFrameHeader::kOpCodeText),
       current_writing_opcode_(WebSocketFrameHeader::kOpCodeText),
-      predictor_(predictor.Pass()) {
+      predictor_(std::move(predictor)) {
   DCHECK(stream_);
   DCHECK(params.IsValidAsResponse());
   int client_max_window_bits = 15;
   if (params.is_client_max_window_bits_specified()) {
     DCHECK(params.has_client_max_window_bits_value());
     client_max_window_bits = params.client_max_window_bits();
   }
   deflater_.Initialize(client_max_window_bits);
   inflater_.Initialize(kWindowBits);
 }
@@ skipping 68 matching lines @@
     if (writing_state_ == NOT_WRITING)
       OnMessageStart(*frames, i);
 
     scoped_ptr<WebSocketFrame> frame(std::move((*frames)[i]));
     predictor_->RecordInputDataFrame(frame.get());
 
     if (writing_state_ == WRITING_UNCOMPRESSED_MESSAGE) {
       if (frame->header.final)
         writing_state_ = NOT_WRITING;
       predictor_->RecordWrittenDataFrame(frame.get());
-      frames_to_write.push_back(frame.Pass());
+      frames_to_write.push_back(std::move(frame));
       current_writing_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
     } else {
       if (frame->data.get() &&
           !deflater_.AddBytes(
               frame->data->data(),
               static_cast<size_t>(frame->header.payload_length))) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "deflater_.AddBytes() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
       }
       if (frame->header.final && !deflater_.Finish()) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "deflater_.Finish() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
       }
 
       if (writing_state_ == WRITING_COMPRESSED_MESSAGE) {
         if (deflater_.CurrentOutputSize() >= kChunkSize ||
             frame->header.final) {
           int result = AppendCompressedFrame(frame->header, &frames_to_write);
           if (result != OK)
             return result;
         }
         if (frame->header.final)
           writing_state_ = NOT_WRITING;
       } else {
         DCHECK_EQ(WRITING_POSSIBLY_COMPRESSED_MESSAGE, writing_state_);
         bool final = frame->header.final;
-        frames_of_message.push_back(frame.Pass());
+        frames_of_message.push_back(std::move(frame));
         if (final) {
           int result = AppendPossiblyCompressedMessage(&frames_of_message,
                                                        &frames_to_write);
           if (result != OK)
             return result;
           frames_of_message.clear();
           writing_state_ = NOT_WRITING;
         }
       }
     }
@@ skipping 42 matching lines @@
   compressed->header.CopyFrom(header);
   compressed->header.opcode = opcode;
   compressed->header.final = header.final;
   compressed->header.reserved1 =
       (opcode != WebSocketFrameHeader::kOpCodeContinuation);
   compressed->data = compressed_payload;
   compressed->header.payload_length = compressed_payload->size();
 
   current_writing_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
   predictor_->RecordWrittenDataFrame(compressed.get());
-  frames_to_write->push_back(compressed.Pass());
+  frames_to_write->push_back(std::move(compressed));
   return OK;
 }
 
 int WebSocketDeflateStream::AppendPossiblyCompressedMessage(
     std::vector<scoped_ptr<WebSocketFrame>>* frames,
     std::vector<scoped_ptr<WebSocketFrame>>* frames_to_write) {
   DCHECK(!frames->empty());
 
   const WebSocketFrameHeader::OpCode opcode = current_writing_opcode_;
   scoped_refptr<IOBufferWithSize> compressed_payload =
@@ skipping 28 matching lines @@
   }
   scoped_ptr<WebSocketFrame> compressed(new WebSocketFrame(opcode));
   compressed->header.CopyFrom((*frames)[0]->header);
   compressed->header.opcode = opcode;
   compressed->header.final = true;
   compressed->header.reserved1 = true;
   compressed->data = compressed_payload;
   compressed->header.payload_length = compressed_payload->size();
 
   predictor_->RecordWrittenDataFrame(compressed.get());
-  frames_to_write->push_back(compressed.Pass());
+  frames_to_write->push_back(std::move(compressed));
   return OK;
 }
 
 int WebSocketDeflateStream::Inflate(
     std::vector<scoped_ptr<WebSocketFrame>>* frames) {
   std::vector<scoped_ptr<WebSocketFrame>> frames_to_output;
   std::vector<scoped_ptr<WebSocketFrame>> frames_passed;
   frames->swap(frames_passed);
   for (size_t i = 0; i < frames_passed.size(); ++i) {
     scoped_ptr<WebSocketFrame> frame(std::move(frames_passed[i]));
     frames_passed[i] = NULL;
     DVLOG(3) << "Input frame: opcode=" << frame->header.opcode
              << " final=" << frame->header.final
              << " reserved1=" << frame->header.reserved1
              << " payload_length=" << frame->header.payload_length;
 
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
-      frames_to_output.push_back(frame.Pass());
+      frames_to_output.push_back(std::move(frame));
       continue;
     }
 
     if (reading_state_ == NOT_READING) {
       if (frame->header.reserved1)
         reading_state_ = READING_COMPRESSED_MESSAGE;
       else
         reading_state_ = READING_UNCOMPRESSED_MESSAGE;
       current_reading_opcode_ = frame->header.opcode;
     } else {
       if (frame->header.reserved1) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "Receiving a non-first frame with RSV1 flag set.";
         return ERR_WS_PROTOCOL_ERROR;
       }
     }
 
     if (reading_state_ == READING_UNCOMPRESSED_MESSAGE) {
       if (frame->header.final)
         reading_state_ = NOT_READING;
       current_reading_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
-      frames_to_output.push_back(frame.Pass());
+      frames_to_output.push_back(std::move(frame));
     } else {
       DCHECK_EQ(reading_state_, READING_COMPRESSED_MESSAGE);
       if (frame->data.get() &&
           !inflater_.AddBytes(
               frame->data->data(),
               static_cast<size_t>(frame->header.payload_length))) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "inflater_.AddBytes() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
       }
@@ skipping 23 matching lines @@
         inflated->header.CopyFrom(frame->header);
         inflated->header.opcode = current_reading_opcode_;
         inflated->header.final = is_final;
         inflated->header.reserved1 = false;
         inflated->data = data;
         inflated->header.payload_length = data->size();
         DVLOG(3) << "Inflated frame: opcode=" << inflated->header.opcode
                  << " final=" << inflated->header.final
                  << " reserved1=" << inflated->header.reserved1
                  << " payload_length=" << inflated->header.payload_length;
-        frames_to_output.push_back(inflated.Pass());
+        frames_to_output.push_back(std::move(inflated));
         current_reading_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
         if (is_final)
           break;
       }
       if (frame->header.final)
         reading_state_ = NOT_READING;
     }
   }
   frames->swap(frames_to_output);
   return frames->empty() ? ERR_IO_PENDING : OK;
@@ skipping 18 matching lines @@
     DCHECK(!frames->empty());
 
     result = Inflate(frames);
   }
   if (result < 0)
     frames->clear();
   return result;
 }
 
 }  // namespace net