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

net/dns/dns_transaction.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 "net/dns/dns_transaction.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 376 matching lines @@
     }
     return rv;
   }
 
   int DoConnectComplete(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     WriteBigEndian<uint16>(length_buffer_->data(), query_->io_buffer()->size());
-    buffer_ = new DrainableIOBuffer(length_buffer_, length_buffer_->size());
+    buffer_ =
+        new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
     next_state_ = STATE_SEND_LENGTH;
     return OK;
   }
 
   int DoSendLength(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_SEND_LENGTH;
-      return socket_->Write(buffer_,
-                            buffer_->BytesRemaining(),
-                            base::Bind(&DnsTCPAttempt::OnIOComplete,
-                                       base::Unretained(this)));
+      return socket_->Write(
+          buffer_.get(),
+          buffer_->BytesRemaining(),
+          base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     }
     buffer_ = new DrainableIOBuffer(query_->io_buffer(),
                                     query_->io_buffer()->size());
     next_state_ = STATE_SEND_QUERY;
     return OK;
   }
 
   int DoSendQuery(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_SEND_QUERY;
-      return socket_->Write(buffer_,
-                            buffer_->BytesRemaining(),
-                            base::Bind(&DnsTCPAttempt::OnIOComplete,
-                                       base::Unretained(this)));
+      return socket_->Write(
+          buffer_.get(),
+          buffer_->BytesRemaining(),
+          base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     }
-    buffer_ = new DrainableIOBuffer(length_buffer_, length_buffer_->size());
+    buffer_ =
+        new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
     next_state_ = STATE_READ_LENGTH;
     return OK;
   }
 
   int DoReadLength(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_READ_LENGTH;
-      return socket_->Read(buffer_,
-                           buffer_->BytesRemaining(),
-                           base::Bind(&DnsTCPAttempt::OnIOComplete,
-                                      base::Unretained(this)));
+      return socket_->Read(
+          buffer_.get(),
+          buffer_->BytesRemaining(),
+          base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     }
     ReadBigEndian<uint16>(length_buffer_->data(), &response_length_);
     // Check if advertised response is too short. (Optimization only.)
     if (response_length_ < query_->io_buffer()->size())
       return ERR_DNS_MALFORMED_RESPONSE;
     // Allocate more space so that DnsResponse::InitParse sanity check passes.
     response_.reset(new DnsResponse(response_length_ + 1));
     buffer_ = new DrainableIOBuffer(response_->io_buffer(), response_length_);
     next_state_ = STATE_READ_RESPONSE;
     return OK;
   }
 
   int DoReadResponse(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_READ_RESPONSE;
-      return socket_->Read(buffer_,
-                           buffer_->BytesRemaining(),
-                           base::Bind(&DnsTCPAttempt::OnIOComplete,
-                                      base::Unretained(this)));
+      return socket_->Read(
+          buffer_.get(),
+          buffer_->BytesRemaining(),
+          base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     }
     if (!response_->InitParse(buffer_->BytesConsumed(), *query_))
       return ERR_DNS_MALFORMED_RESPONSE;
     if (response_->flags() & dns_protocol::kFlagTC)
       return ERR_UNEXPECTED;
     // TODO(szym): Frankly, none of these are expected.
     if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
       return ERR_NAME_NOT_RESOLVED;
     if (response_->rcode() != dns_protocol::kRcodeNOERROR)
       return ERR_DNS_SERVER_FAILED;
@@ skipping 42 matching lines @@
                      const DnsTransactionFactory::CallbackType& callback,
                      const BoundNetLog& net_log)
     : session_(session),
       hostname_(hostname),
       qtype_(qtype),
       callback_(callback),
       net_log_(net_log),
       qnames_initial_size_(0),
       had_tcp_attempt_(false),
       first_server_index_(0) {
-    DCHECK(session_);
+    DCHECK(session_.get());
     DCHECK(!hostname_.empty());
     DCHECK(!callback_.is_null());
     DCHECK(!IsIPLiteral(hostname_));
   }
 
   virtual ~DnsTransactionImpl() {
     if (!callback_.is_null()) {
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
                                         ERR_ABORTED);
     }  // otherwise logged in DoCallback or Start
@@ skipping 382 matching lines @@
  public:
   explicit DnsTransactionFactoryImpl(DnsSession* session) {
     session_ = session;
   }
 
   virtual scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
       uint16 qtype,
       const CallbackType& callback,
       const BoundNetLog& net_log) OVERRIDE {
-    return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(session_,
-                                                             hostname,
-                                                             qtype,
-                                                             callback,
-                                                             net_log));
+    return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(
+        session_.get(), hostname, qtype, callback, net_log));
   }
 
  private:
   scoped_refptr<DnsSession> session_;
 };
 
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net