Subsituting pattern ScopedVector push_back.(ptr.release()) with push_back(ptr.Pass()) in net/websoc…

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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 111 matching lines @@
       OnMessageStart(*frames, i);
 
     scoped_ptr<WebSocketFrame> frame((*frames)[i]);
     (*frames)[i] = NULL;
     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.release());
+      frames_to_write.push_back(frame.Pass());
       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.release());
+        frames_of_message.push_back(frame.Pass());
         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 41 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.release());
+  frames_to_write->push_back(compressed.Pass());
   return OK;
 }
 
 int WebSocketDeflateStream::AppendPossiblyCompressedMessage(
     ScopedVector<WebSocketFrame>* frames,
     ScopedVector<WebSocketFrame>* frames_to_write) {
   DCHECK(!frames->empty());
 
   const WebSocketFrameHeader::OpCode opcode = current_writing_opcode_;
   scoped_refptr<IOBufferWithSize> compressed_payload =
@@ skipping 29 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.release());
+  frames_to_write->push_back(compressed.Pass());
   return OK;
 }
 
 int WebSocketDeflateStream::Inflate(ScopedVector<WebSocketFrame>* frames) {
   ScopedVector<WebSocketFrame> frames_to_output;
   ScopedVector<WebSocketFrame> frames_passed;
   frames->swap(frames_passed);
   for (size_t i = 0; i < frames_passed.size(); ++i) {
     scoped_ptr<WebSocketFrame> frame(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.release());
+      frames_to_output.push_back(frame.Pass());
       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.release());
+      frames_to_output.push_back(frame.Pass());
     } 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.release());
+        frames_to_output.push_back(inflated.Pass());
         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