Remove implicit conversions from scoped_refptr to T* in net/websockets/

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 <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 61 matching lines @@
     const scoped_refptr<GrowableIOBuffer>& http_read_buffer,
     const std::string& sub_protocol,
     const std::string& extensions)
     : read_buffer_(new IOBufferWithSize(kReadBufferSize)),
       connection_(connection.Pass()),
       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_ && http_read_buffer_->offset() == 0)
+  if (http_read_buffer_.get() && http_read_buffer_->offset() == 0)
     http_read_buffer_ = NULL;
   DCHECK(connection_->is_initialized());
 }
 
 WebSocketBasicStream::~WebSocketBasicStream() { Close(); }
 
 int WebSocketBasicStream::ReadFrames(ScopedVector<WebSocketFrame>* frames,
                                      const CompletionCallback& callback) {
   DCHECK(frames->empty());
   // If there is data left over after parsing the HTTP headers, attempt to parse
   // it as WebSocket frames.
-  if (http_read_buffer_) {
+  if (http_read_buffer_.get()) {
     DCHECK_GE(http_read_buffer_->offset(), 0);
     // We cannot simply copy the data into read_buffer_, as it might be too
     // large.
     scoped_refptr<GrowableIOBuffer> buffered_data;
     buffered_data.swap(http_read_buffer_);
     DCHECK(http_read_buffer_.get() == NULL);
     ScopedVector<WebSocketFrameChunk> frame_chunks;
     if (!parser_.Decode(buffered_data->StartOfBuffer(),
                         buffered_data->offset(),
                         &frame_chunks))
@@ skipping 58 matching lines @@
       const char* const frame_data = frame->data->data();
       std::copy(frame_data, frame_data + frame_size, dest);
       MaskWebSocketFramePayload(mask, 0, dest, frame_size);
       dest += frame_size;
       remaining_size -= frame_size;
     }
   }
   DCHECK_EQ(0, remaining_size) << "Buffer size calculation was wrong; "
                                << remaining_size << " bytes left over.";
   scoped_refptr<DrainableIOBuffer> drainable_buffer(
-      new DrainableIOBuffer(combined_buffer, total_size));
+      new DrainableIOBuffer(combined_buffer.get(), total_size));
   return WriteEverything(drainable_buffer, callback);
 }
 
 void WebSocketBasicStream::Close() { connection_->socket()->Disconnect(); }
 
 std::string WebSocketBasicStream::GetSubProtocol() const {
   return sub_protocol_;
 }
 
 std::string WebSocketBasicStream::GetExtensions() const { return extensions_; }
@@ skipping 94 matching lines @@
     scoped_ptr<WebSocketFrame>* frame) {
   DCHECK(frame->get() == NULL);
   bool is_first_chunk = false;
   if (chunk->header) {
     DCHECK(current_frame_header_ == NULL)
         << "Received the header for a new frame without notification that "
         << "the previous frame was complete (bug in WebSocketFrameParser?)";
     is_first_chunk = true;
     current_frame_header_.swap(chunk->header);
   }
-  const int chunk_size = chunk->data ? chunk->data->size() : 0;
+  const int chunk_size = chunk->data.get() ? chunk->data->size() : 0;
   DCHECK(current_frame_header_) << "Unexpected header-less chunk received "
                                 << "(final_chunk = " << chunk->final_chunk
                                 << ", data size = " << chunk_size
                                 << ") (bug in WebSocketFrameParser?)";
   scoped_refptr<IOBufferWithSize> data_buffer;
   data_buffer.swap(chunk->data);
   const bool is_final_chunk = chunk->final_chunk;
   const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
   if (WebSocketFrameHeader::IsKnownControlOpCode(opcode)) {
     bool protocol_error = false;
     if (!current_frame_header_->final) {
       DVLOG(1) << "WebSocket protocol error. Control frame, opcode=" << opcode
                << " received with FIN bit unset.";
       protocol_error = true;
     }
     if (current_frame_header_->payload_length > kMaxControlFramePayload) {
       DVLOG(1) << "WebSocket protocol error. Control frame, opcode=" << opcode
                << ", payload_length=" << current_frame_header_->payload_length
                << " exceeds maximum payload length for a control message.";
       protocol_error = true;
     }
     if (protocol_error) {
       current_frame_header_.reset();
       return ERR_WS_PROTOCOL_ERROR;
     }
     if (!is_final_chunk) {
       DVLOG(2) << "Encountered a split control frame, opcode " << opcode;
-      if (incomplete_control_frame_body_) {
+      if (incomplete_control_frame_body_.get()) {
         DVLOG(3) << "Appending to an existing split control frame.";
         AddToIncompleteControlFrameBody(data_buffer);
       } else {
         DVLOG(3) << "Creating new storage for an incomplete control frame.";
         incomplete_control_frame_body_ = new GrowableIOBuffer();
         // This method checks for oversize control frames above, so as long as
         // the frame parser is working correctly, this won't overflow. If a bug
         // does cause it to overflow, it will CHECK() in
         // AddToIncompleteControlFrameBody() without writing outside the buffer.
         incomplete_control_frame_body_->SetCapacity(kMaxControlFramePayload);
         AddToIncompleteControlFrameBody(data_buffer);
       }
       return OK;
     }
-    if (incomplete_control_frame_body_) {
+    if (incomplete_control_frame_body_.get()) {
       DVLOG(2) << "Rejoining a split control frame, opcode " << opcode;
       AddToIncompleteControlFrameBody(data_buffer);
       const int body_size = incomplete_control_frame_body_->offset();
       DCHECK_EQ(body_size,
                 static_cast<int>(current_frame_header_->payload_length));
       scoped_refptr<IOBufferWithSize> body = new IOBufferWithSize(body_size);
       memcpy(body->data(),
              incomplete_control_frame_body_->StartOfBuffer(),
              body_size);
       incomplete_control_frame_body_ = NULL;  // Frame now complete.
@@ skipping 16 matching lines @@
   *frame = CreateFrame(is_final_chunk, data_buffer);
   return OK;
 }
 
 scoped_ptr<WebSocketFrame> WebSocketBasicStream::CreateFrame(
     bool is_final_chunk,
     const scoped_refptr<IOBufferWithSize>& data) {
   scoped_ptr<WebSocketFrame> result_frame;
   const bool is_final_chunk_in_message =
       is_final_chunk && current_frame_header_->final;
-  const int data_size = data ? data->size() : 0;
+  const int data_size = data.get() ? data->size() : 0;
   const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
   // Empty frames convey no useful information unless they are the first frame
   // (containing the type and flags) or have the "final" bit set.
   if (is_final_chunk_in_message || data_size > 0 ||
       current_frame_header_->opcode !=
           WebSocketFrameHeader::kOpCodeContinuation) {
     result_frame.reset(new WebSocketFrame(opcode));
     result_frame->header.CopyFrom(*current_frame_header_);
     result_frame->header.final = is_final_chunk_in_message;
     result_frame->header.payload_length = data_size;
@@ skipping 12 matching lines @@
   }
   // 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();
 }
 
 void WebSocketBasicStream::AddToIncompleteControlFrameBody(
     const scoped_refptr<IOBufferWithSize>& data_buffer) {
-  if (!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(ScopedVector<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