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

net/quic/quic_http_stream_test.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/quic/quic_http_stream.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 333 matching lines @@
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response without a body.
   SetResponseString("404 Not Found", std::string());
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
-  ASSERT_TRUE(response_.headers != NULL);
+  ASSERT_TRUE(response_.headers.get() != NULL);
   EXPECT_EQ(404, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
@@ skipping 21 matching lines @@
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponseString("200 OK", "hello world!");
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
-  ASSERT_TRUE(response_.headers != NULL);
+  ASSERT_TRUE(response_.headers.get() != NULL);
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // There is no body, so this should return immediately.
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(12, stream_->ReadResponseBody(read_buffer_.get(),
                                           read_buffer_->size(),
                                           callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
@@ skipping 29 matching lines @@
   ProcessPacket(*ack);
 
   // Send the response headers (but not the body).
   SetResponseString("200 OK", std::string());
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, !kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Since the headers have already arrived, this should return immediately.
   EXPECT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
-  ASSERT_TRUE(response_.headers != NULL);
+  ASSERT_TRUE(response_.headers.get() != NULL);
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   scoped_ptr<QuicEncryptedPacket> resp_body(
       ConstructDataPacket(3, false, kFin, response_data_.length(),
                           kResponseBody));
   ProcessPacket(*resp_body);
 
@@ skipping 41 matching lines @@
   ProcessPacket(*ack);
 
   // Send the response headers (but not the body).
   SetResponseString("200 OK", std::string());
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, !kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Since the headers have already arrived, this should return immediately.
   ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
-  ASSERT_TRUE(response_.headers != NULL);
+  ASSERT_TRUE(response_.headers.get() != NULL);
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   scoped_ptr<QuicEncryptedPacket> resp_body(
       ConstructDataPacket(3, false, kFin, response_data_.length(),
                           kResponseBody));
   ProcessPacket(*resp_body);
 
@@ skipping 36 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net