Update CrOS to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/chromeos/web_socket_proxy.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/web_socket_proxy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 443 matching lines @@
     PHASE_CONNECTING,
     PHASE_RUNNING,
     PHASE_CLOSING,
     PHASE_CLOSED
   };
 
   class DerivedIOBufferWithSize : public net::IOBufferWithSize {
    public:
     DerivedIOBufferWithSize(net::IOBuffer* host, int size)
         : IOBufferWithSize(host->data(), size), host_(host) {
-      DCHECK(host_);
+      DCHECK(host_.get());
       DCHECK(host_->data());
     }
 
    protected:
     virtual ~DerivedIOBufferWithSize() {
       data_ = NULL;  // We do not own memory, bypass base class destructor.
     }
 
     scoped_refptr<net::IOBuffer> host_;
   };
 
   // Provides queue of data represented as IOBuffers.
   class IOBufferQueue {
    public:
     // We do not allocate all capacity at once but lazily in |buf_size_| chunks.
     explicit IOBufferQueue(int capacity)
         : buf_size_(1 + capacity / kNumBuffersLimit) {
     }
 
     // Obtains IOBuffer to add new data to back.
     net::IOBufferWithSize* GetIOBufferToFill() {
-      if (back_ == NULL) {
+      if (back_.get() == NULL) {
         if (storage_.size() >= kNumBuffersLimit)
           return NULL;
         storage_.push_back(new net::IOBufferWithSize(buf_size_));
-        back_ = new net::DrainableIOBuffer(storage_.back(), buf_size_);
+        back_ = new net::DrainableIOBuffer(storage_.back().get(), buf_size_);
       }
       return new DerivedIOBufferWithSize(
           back_.get(), back_->BytesRemaining());
     }
 
     // Obtains IOBuffer with some data from front.
     net::IOBufferWithSize* GetIOBufferToProcess() {
-      if (front_ == NULL) {
+      if (front_.get() == NULL) {
         if (storage_.empty())
           return NULL;
-        front_ = new net::DrainableIOBuffer(storage_.front(), buf_size_);
+        front_ = new net::DrainableIOBuffer(storage_.front().get(), buf_size_);
       }
-      int front_capacity = (storage_.size() == 1 && back_) ?
-          back_->BytesConsumed() : buf_size_;
+      int front_capacity =
+          (storage_.size() == 1 && back_.get()) ? back_->BytesConsumed()
+                                                : buf_size_;
       return new DerivedIOBufferWithSize(
           front_.get(), front_capacity - front_->BytesConsumed());
     }
 
     // Records number of bytes as added to back.
     void DidFill(int bytes) {
-      DCHECK(back_);
+      DCHECK(back_.get());
       back_->DidConsume(bytes);
       if (back_->BytesRemaining() == 0)
         back_ = NULL;
     }
 
     // Pops number of bytes from front.
     void DidProcess(int bytes) {
-      DCHECK(front_);
+      DCHECK(front_.get());
       front_->DidConsume(bytes);
       if (front_->BytesRemaining() == 0) {
         storage_.pop_front();
         front_ = NULL;
       }
     }
 
     void Clear() {
       front_ = NULL;
       back_ = NULL;
@@ skipping 48 matching lines @@
   }
 
   void Shut(int ALLOW_UNUSED net_error_code) {
     if (phase_ != PHASE_CLOSED) {
       phase_ = PHASE_CLOSING;
       scoped_refptr<net::IOBufferWithSize> buf[] = {
           outbound_stream_.GetIOBufferToProcess(),
           inbound_stream_.GetIOBufferToProcess()
       };
       for (int i = arraysize(buf); i--;) {
-        if (buf[i] && buf[i]->size() > 0) {
+        if (buf[i].get() && buf[i]->size() > 0) {
           base::MessageLoop::current()->PostTask(
               FROM_HERE,
               base::Bind(&SSLChan::Proceed, weak_factory_.GetWeakPtr()));
           return;
         }
       }
       phase_ = PHASE_CLOSED;
       if (socket_ != NULL) {
         socket_->Disconnect();
         socket_.reset();
@@ skipping 98 matching lines @@
 
  private:
   void Proceed() {
     if (phase_ != PHASE_RUNNING && phase_ != PHASE_CLOSING)
       return;
     for (bool proceed = true; proceed;) {
       proceed = false;
       if (!is_read_pipe_blocked_ && phase_ == PHASE_RUNNING) {
         scoped_refptr<net::IOBufferWithSize> buf =
             outbound_stream_.GetIOBufferToFill();
-        if (buf && buf->size() > 0) {
+        if (buf.get() && buf->size() > 0) {
           int rv = read(read_pipe_, buf->data(), buf->size());
           if (rv > 0) {
             outbound_stream_.DidFill(rv);
             proceed = true;
           } else if (rv == -1 && errno == EAGAIN) {
             is_read_pipe_blocked_ = true;
             base::MessageLoopForIO::current()->WatchFileDescriptor(
                 read_pipe_, false, base::MessageLoopForIO::WATCH_READ,
                 &read_pipe_controller_, this);
           } else if (rv == 0) {
             Shut(0);
           } else {
             DCHECK_LT(rv, 0);
             Shut(net::ERR_UNEXPECTED);
             return;
           }
         }
       }
       if (!is_socket_read_pending_ && phase_ == PHASE_RUNNING) {
         scoped_refptr<net::IOBufferWithSize> buf =
             inbound_stream_.GetIOBufferToFill();
-        if (buf && buf->size() > 0) {
+        if (buf.get() && buf->size() > 0) {
           int rv = socket_->Read(
-              buf, buf->size(),
+              buf.get(),
+              buf->size(),
               base::Bind(&SSLChan::OnSocketRead, base::Unretained(this)));
           is_socket_read_pending_ = true;
           if (rv != net::ERR_IO_PENDING) {
             base::MessageLoop::current()->PostTask(
                 FROM_HERE, base::Bind(&SSLChan::OnSocketRead,
                                       weak_factory_.GetWeakPtr(), rv));
           }
         }
       }
       if (!is_socket_write_pending_) {
         scoped_refptr<net::IOBufferWithSize> buf =
             outbound_stream_.GetIOBufferToProcess();
-        if (buf && buf->size() > 0) {
+        if (buf.get() && buf->size() > 0) {
           int rv = socket_->Write(
-              buf, buf->size(),
+              buf.get(),
+              buf->size(),
               base::Bind(&SSLChan::OnSocketWrite, base::Unretained(this)));
           is_socket_write_pending_ = true;
           if (rv != net::ERR_IO_PENDING) {
             base::MessageLoop::current()->PostTask(
                 FROM_HERE, base::Bind(&SSLChan::OnSocketWrite,
                                       weak_factory_.GetWeakPtr(), rv));
           }
         } else if (phase_ == PHASE_CLOSING) {
           Shut(0);
         }
       }
       if (!is_write_pipe_blocked_) {
         scoped_refptr<net::IOBufferWithSize> buf =
             inbound_stream_.GetIOBufferToProcess();
-        if (buf && buf->size() > 0) {
+        if (buf.get() && buf->size() > 0) {
           int rv = write(write_pipe_, buf->data(), buf->size());
           if (rv > 0) {
             inbound_stream_.DidProcess(rv);
             proceed = true;
           } else if (rv == -1 && errno == EAGAIN) {
             is_write_pipe_blocked_ = true;
             base::MessageLoopForIO::current()->WatchFileDescriptor(
                 write_pipe_, false, base::MessageLoopForIO::WATCH_WRITE,
                 &write_pipe_controller_, this);
           } else {
@@ skipping 1134 matching lines @@
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos