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

Linux fixes

BUG=110610
TBR=darin

Review URL: https://chromiumcodereview.appspot.com/15829004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@203535 0039d316-1c4b-4281-b951-d872f2087c98

179 files changed, 3647 insertions, 2877 deletions

diff --git a/net/base/file_stream_context.cc b/net/base/file_stream_context.cc
index 092302f..dc0e6b8 100644
--- a/net/base/file_stream_context.cc
+++ b/net/base/file_stream_context.cc
@@ -70,12 +70,11 @@ void FileStream::Context::OpenAsync(const base::FilePath& path,
   BeginOpenEvent(path);
 
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task_is_slow */),
+      base::WorkerPool::GetTaskRunner(true /* task_is_slow */).get(),
       FROM_HERE,
-      base::Bind(&Context::OpenFileImpl,
-                 base::Unretained(this), path, open_flags),
-      base::Bind(&Context::OnOpenCompleted,
-                 base::Unretained(this), callback));
+      base::Bind(
+          &Context::OpenFileImpl, base::Unretained(this), path, open_flags),
+      base::Bind(&Context::OnOpenCompleted, base::Unretained(this), callback));
   DCHECK(posted);
 
   async_in_progress_ = true;
@@ -113,12 +112,14 @@ void FileStream::Context::SeekAsync(Whence whence,
   DCHECK(!async_in_progress_);
 
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task is slow */),
+      base::WorkerPool::GetTaskRunner(true /* task is slow */).get(),
       FROM_HERE,
-      base::Bind(&Context::SeekFileImpl,
-                 base::Unretained(this), whence, offset),
+      base::Bind(
+          &Context::SeekFileImpl, base::Unretained(this), whence, offset),
       base::Bind(&Context::ProcessAsyncResult,
-                 base::Unretained(this), callback, FILE_ERROR_SOURCE_SEEK));
+                 base::Unretained(this),
+                 callback,
+                 FILE_ERROR_SOURCE_SEEK));
   DCHECK(posted);
 
   async_in_progress_ = true;
@@ -134,12 +135,12 @@ void FileStream::Context::FlushAsync(const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task is slow */),
+      base::WorkerPool::GetTaskRunner(true /* task is slow */).get(),
       FROM_HERE,
-      base::Bind(&Context::FlushFileImpl,
-                 base::Unretained(this)),
+      base::Bind(&Context::FlushFileImpl, base::Unretained(this)),
       base::Bind(&Context::ProcessAsyncResult,
-                 base::Unretained(this), IntToInt64(callback),
+                 base::Unretained(this),
+                 IntToInt64(callback),
                  FILE_ERROR_SOURCE_FLUSH));
   DCHECK(posted);
 
diff --git a/net/base/file_stream_context_posix.cc b/net/base/file_stream_context_posix.cc
index 87fa106..e4102e1 100644
--- a/net/base/file_stream_context_posix.cc
+++ b/net/base/file_stream_context_posix.cc
@@ -84,12 +84,12 @@ int FileStream::Context::ReadAsync(IOBuffer* in_buf,
 
   scoped_refptr<IOBuffer> buf = in_buf;
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task is slow */),
+      base::WorkerPool::GetTaskRunner(true /* task is slow */).get(),
       FROM_HERE,
-      base::Bind(&Context::ReadFileImpl,
-                 base::Unretained(this), buf, buf_len),
+      base::Bind(&Context::ReadFileImpl, base::Unretained(this), buf, buf_len),
       base::Bind(&Context::ProcessAsyncResult,
-                 base::Unretained(this), IntToInt64(callback),
+                 base::Unretained(this),
+                 IntToInt64(callback),
                  FILE_ERROR_SOURCE_READ));
   DCHECK(posted);
 
@@ -111,12 +111,12 @@ int FileStream::Context::WriteAsync(IOBuffer* in_buf,
 
   scoped_refptr<IOBuffer> buf = in_buf;
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task is slow */),
+      base::WorkerPool::GetTaskRunner(true /* task is slow */).get(),
       FROM_HERE,
-      base::Bind(&Context::WriteFileImpl,
-                 base::Unretained(this), buf, buf_len),
+      base::Bind(&Context::WriteFileImpl, base::Unretained(this), buf, buf_len),
       base::Bind(&Context::ProcessAsyncResult,
-                 base::Unretained(this), IntToInt64(callback),
+                 base::Unretained(this),
+                 IntToInt64(callback),
                  FILE_ERROR_SOURCE_WRITE));
   DCHECK(posted);
 
diff --git a/net/base/file_stream_unittest.cc b/net/base/file_stream_unittest.cc
index efbde33..89b6dbd 100644
--- a/net/base/file_stream_unittest.cc
+++ b/net/base/file_stream_unittest.cc
@@ -203,7 +203,7 @@ TEST_F(FileStreamTest, AsyncRead) {
   std::string data_read;
   for (;;) {
     scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-    rv = stream.Read(buf, buf->size(), callback.callback());
+    rv = stream.Read(buf.get(), buf->size(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LE(0, rv);
@@ -234,7 +234,7 @@ TEST_F(FileStreamTest, AsyncRead_EarlyDelete) {
   EXPECT_EQ(file_size, total_bytes_avail);
 
   scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-  rv = stream->Read(buf, buf->size(), callback.callback());
+  rv = stream->Read(buf.get(), buf->size(), callback.callback());
   stream.reset();  // Delete instead of closing it.
   if (rv < 0) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -310,7 +310,7 @@ TEST_F(FileStreamTest, AsyncRead_FromOffset) {
   std::string data_read;
   for (;;) {
     scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-    rv = stream.Read(buf, buf->size(), callback.callback());
+    rv = stream.Read(buf.get(), buf->size(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LE(0, rv);
@@ -422,10 +422,10 @@ TEST_F(FileStreamTest, AsyncWrite) {
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
   scoped_refptr<DrainableIOBuffer> drainable =
-      new DrainableIOBuffer(buf, buf->size());
+      new DrainableIOBuffer(buf.get(), buf->size());
   while (total_bytes_written != kTestDataSize) {
-    rv = stream.Write(drainable, drainable->BytesRemaining(),
-                      callback.callback());
+    rv = stream.Write(
+        drainable.get(), drainable->BytesRemaining(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LT(0, rv);
@@ -455,7 +455,7 @@ TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) {
   EXPECT_EQ(0, file_size);
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
-  rv = stream->Write(buf, buf->size(), callback.callback());
+  rv = stream->Write(buf.get(), buf->size(), callback.callback());
   stream.reset();
   if (rv < 0) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -519,10 +519,10 @@ TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
   scoped_refptr<DrainableIOBuffer> drainable =
-      new DrainableIOBuffer(buf, buf->size());
+      new DrainableIOBuffer(buf.get(), buf->size());
   while (total_bytes_written != kTestDataSize) {
-    rv = stream.Write(drainable, drainable->BytesRemaining(),
-                      callback.callback());
+    rv = stream.Write(
+        drainable.get(), drainable->BytesRemaining(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LT(0, rv);
@@ -646,7 +646,7 @@ TEST_F(FileStreamTest, BasicAsyncReadWrite) {
   std::string data_read;
   for (;;) {
     scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-    rv = stream->Read(buf, buf->size(), callback.callback());
+    rv = stream->Read(buf.get(), buf->size(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LE(0, rv);
@@ -662,10 +662,10 @@ TEST_F(FileStreamTest, BasicAsyncReadWrite) {
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
   scoped_refptr<DrainableIOBuffer> drainable =
-      new DrainableIOBuffer(buf, buf->size());
+      new DrainableIOBuffer(buf.get(), buf->size());
   while (total_bytes_written != kTestDataSize) {
-    rv = stream->Write(drainable, drainable->BytesRemaining(),
-                       callback.callback());
+    rv = stream->Write(
+        drainable.get(), drainable->BytesRemaining(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LT(0, rv);
@@ -710,10 +710,10 @@ TEST_F(FileStreamTest, BasicAsyncWriteRead) {
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
   scoped_refptr<DrainableIOBuffer> drainable =
-      new DrainableIOBuffer(buf, buf->size());
+      new DrainableIOBuffer(buf.get(), buf->size());
   while (total_bytes_written != kTestDataSize) {
-    rv = stream->Write(drainable, drainable->BytesRemaining(),
-                      callback.callback());
+    rv = stream->Write(
+        drainable.get(), drainable->BytesRemaining(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LT(0, rv);
@@ -735,7 +735,7 @@ TEST_F(FileStreamTest, BasicAsyncWriteRead) {
   std::string data_read;
   for (;;) {
     scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-    rv = stream->Read(buf, buf->size(), callback.callback());
+    rv = stream->Read(buf.get(), buf->size(), callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     EXPECT_LE(0, rv);
@@ -758,11 +758,10 @@ TEST_F(FileStreamTest, BasicAsyncWriteRead) {
 
 class TestWriteReadCompletionCallback {
  public:
-  TestWriteReadCompletionCallback(
-      FileStream* stream,
-      int* total_bytes_written,
-      int* total_bytes_read,
-      std::string* data_read)
+  TestWriteReadCompletionCallback(FileStream* stream,
+                                  int* total_bytes_written,
+                                  int* total_bytes_read,
+                                  std::string* data_read)
       : result_(0),
         have_result_(false),
         waiting_for_result_(false),
@@ -773,8 +772,7 @@ class TestWriteReadCompletionCallback {
         callback_(base::Bind(&TestWriteReadCompletionCallback::OnComplete,
                              base::Unretained(this))),
         test_data_(CreateTestDataBuffer()),
-        drainable_(new DrainableIOBuffer(test_data_, kTestDataSize)) {
-  }
+        drainable_(new DrainableIOBuffer(test_data_.get(), kTestDataSize)) {}
 
   int WaitForResult() {
     DCHECK(!waiting_for_result_);
@@ -802,8 +800,8 @@ class TestWriteReadCompletionCallback {
       std::string data_read;
       TestWriteReadCompletionCallback callback(
           stream_, &total_bytes_written, &total_bytes_read, &data_read);
-      rv = stream_->Write(drainable_, drainable_->BytesRemaining(),
-                          callback.callback());
+      rv = stream_->Write(
+          drainable_.get(), drainable_->BytesRemaining(), callback.callback());
       DCHECK_EQ(ERR_IO_PENDING, rv);
       rv = callback.WaitForResult();
       drainable_->DidConsume(total_bytes_written);
@@ -816,7 +814,7 @@ class TestWriteReadCompletionCallback {
       TestCompletionCallback callback;
       for (;;) {
         scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-        rv = stream_->Read(buf, buf->size(), callback.callback());
+        rv = stream_->Read(buf.get(), buf->size(), callback.callback());
         if (rv == ERR_IO_PENDING) {
           base::MessageLoop::ScopedNestableTaskAllower allow(
               base::MessageLoop::current());
@@ -878,7 +876,7 @@ TEST_F(FileStreamTest, AsyncWriteRead) {
                                            &total_bytes_read, &data_read);
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
-  rv = stream->Write(buf, buf->size(), callback.callback());
+  rv = stream->Write(buf.get(), buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_LT(0, rv);
@@ -907,8 +905,7 @@ class TestWriteCloseCompletionCallback {
         callback_(base::Bind(&TestWriteCloseCompletionCallback::OnComplete,
                              base::Unretained(this))),
         test_data_(CreateTestDataBuffer()),
-        drainable_(new DrainableIOBuffer(test_data_, kTestDataSize)) {
-  }
+        drainable_(new DrainableIOBuffer(test_data_.get(), kTestDataSize)) {}
 
   int WaitForResult() {
     DCHECK(!waiting_for_result_);
@@ -934,8 +931,8 @@ class TestWriteCloseCompletionCallback {
       // Recurse to finish writing all data.
       int total_bytes_written = 0;
       TestWriteCloseCompletionCallback callback(stream_, &total_bytes_written);
-      rv = stream_->Write(drainable_, drainable_->BytesRemaining(),
-                          callback.callback());
+      rv = stream_->Write(
+          drainable_.get(), drainable_->BytesRemaining(), callback.callback());
       DCHECK_EQ(ERR_IO_PENDING, rv);
       rv = callback.WaitForResult();
       drainable_->DidConsume(total_bytes_written);
@@ -985,7 +982,7 @@ TEST_F(FileStreamTest, AsyncWriteClose) {
   TestWriteCloseCompletionCallback callback(stream.get(), &total_bytes_written);
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
-  rv = stream->Write(buf, buf->size(), callback.callback());
+  rv = stream->Write(buf.get(), buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     total_bytes_written = callback.WaitForResult();
   EXPECT_LT(0, total_bytes_written);
@@ -1055,7 +1052,7 @@ TEST_F(FileStreamTest, AsyncWriteError) {
 
   // Try passing NULL buffer to Write() and check that it fails.
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(NULL);
-  rv = stream->Write(buf, 1, callback.callback());
+  rv = stream->Write(buf.get(), 1, callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_LT(rv, 0);
@@ -1074,7 +1071,7 @@ TEST_F(FileStreamTest, AsyncReadError) {
 
   // Try passing NULL buffer to Read() and check that it fails.
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(NULL);
-  rv = stream->Read(buf, 1, callback.callback());
+  rv = stream->Read(buf.get(), 1, callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_LT(rv, 0);
diff --git a/net/base/test_completion_callback_unittest.cc b/net/base/test_completion_callback_unittest.cc
index 20b59e1..99f486c 100644
--- a/net/base/test_completion_callback_unittest.cc
+++ b/net/base/test_completion_callback_unittest.cc
@@ -94,7 +94,7 @@ ExampleEmployer::~ExampleEmployer() {
 }
 
 bool ExampleEmployer::DoSomething(const net::CompletionCallback& callback) {
-  DCHECK(!request_) << "already in use";
+  DCHECK(!request_.get()) << "already in use";
 
   request_ = new ExampleWorker(this, callback);
 
diff --git a/net/base/upload_bytes_element_reader_unittest.cc b/net/base/upload_bytes_element_reader_unittest.cc
index b5bd588..1aad55e 100644
--- a/net/base/upload_bytes_element_reader_unittest.cc
+++ b/net/base/upload_bytes_element_reader_unittest.cc
@@ -33,8 +33,9 @@ TEST_F(UploadBytesElementReaderTest, ReadPartially) {
   const size_t kHalfSize = bytes_.size() / 2;
   std::vector<char> buf(kHalfSize);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining());
   bytes_.resize(kHalfSize);  // Resize to compare.
   EXPECT_EQ(bytes_, buf);
@@ -43,20 +44,23 @@ TEST_F(UploadBytesElementReaderTest, ReadPartially) {
 TEST_F(UploadBytesElementReaderTest, ReadAll) {
   std::vector<char> buf(bytes_.size());
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
   // Try to read again.
-  EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      0, reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
 }
 
 TEST_F(UploadBytesElementReaderTest, ReadTooMuch) {
   const size_t kTooLargeSize = bytes_.size() * 2;
   std::vector<char> buf(kTooLargeSize);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(static_cast<int>(bytes_.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(bytes_.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   buf.resize(bytes_.size());  // Resize to compare.
   EXPECT_EQ(bytes_, buf);
@@ -67,8 +71,9 @@ TEST_F(UploadBytesElementReaderTest, MultipleInit) {
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 
   // Read all.
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
 
@@ -78,8 +83,9 @@ TEST_F(UploadBytesElementReaderTest, MultipleInit) {
   EXPECT_EQ(bytes_.size(), reader_->BytesRemaining());
 
   // Read again.
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
 }
diff --git a/net/base/upload_data_stream.cc b/net/base/upload_data_stream.cc
index ad59ad3..03946da6 100644
--- a/net/base/upload_data_stream.cc
+++ b/net/base/upload_data_stream.cc
@@ -189,7 +189,7 @@ int UploadDataStream::ReadInternal(scoped_refptr<DrainableIOBuffer> buf,
       break;
 
     int result = reader->Read(
-        buf,
+        buf.get(),
         buf->BytesRemaining(),
         base::Bind(base::IgnoreResult(&UploadDataStream::ResumePendingRead),
                    weak_ptr_factory_.GetWeakPtr(),
diff --git a/net/base/upload_data_stream_unittest.cc b/net/base/upload_data_stream_unittest.cc
index f3856f1..59b44af 100644
--- a/net/base/upload_data_stream_unittest.cc
+++ b/net/base/upload_data_stream_unittest.cc
@@ -43,7 +43,8 @@ std::string ReadFromUploadDataStream(UploadDataStream* stream) {
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     TestCompletionCallback callback;
-    const int result = stream->Read(buf, kTestBufferSize, callback.callback());
+    const int result =
+        stream->Read(buf.get(), kTestBufferSize, callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : callback.WaitForResult();
     data_read.append(buf->data(), bytes_read);
@@ -154,7 +155,8 @@ TEST_F(UploadDataStreamTest, ConsumeAllBytes) {
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
-    int bytes_read = stream.Read(buf, kTestBufferSize, CompletionCallback());
+    int bytes_read =
+        stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream.position());
@@ -183,8 +185,9 @@ TEST_F(UploadDataStreamTest, File) {
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
-    ASSERT_EQ(ERR_IO_PENDING,
-              stream.Read(buf, kTestBufferSize, read_callback.callback()));
+    ASSERT_EQ(
+        ERR_IO_PENDING,
+        stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
     ASSERT_LE(0, read_callback.WaitForResult());  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream.position());
@@ -218,8 +221,9 @@ TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
-    ASSERT_EQ(ERR_IO_PENDING,
-              stream.Read(buf, kTestBufferSize, read_callback.callback()));
+    ASSERT_EQ(
+        ERR_IO_PENDING,
+        stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
     int bytes_read = read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
     read_counter += bytes_read;
@@ -256,9 +260,9 @@ TEST_F(UploadDataStreamTest, ReadErrorSync) {
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2),
-            stream.Read(buf, kTestBufferSize, CompletionCallback()));
-  EXPECT_EQ(kTestDataSize*2, stream.position());
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
+            stream.Read(buf.get(), kTestBufferSize, CompletionCallback()));
+  EXPECT_EQ(kTestDataSize * 2, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 
   // The buffer is filled with zero.
@@ -295,8 +299,8 @@ TEST_F(UploadDataStreamTest, ReadErrorAsync) {
   // Read() results in success even when the reader returns error.
   TestCompletionCallback read_callback;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf, kTestBufferSize, read_callback.callback()));
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2), read_callback.WaitForResult());
+            stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult());
   EXPECT_EQ(kTestDataSize*2, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 
@@ -334,7 +338,7 @@ TEST_F(UploadDataStreamTest, FileAndBytes) {
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
     const int result =
-        stream.Read(buf, kTestBufferSize, read_callback.callback());
+        stream.Read(buf.get(), kTestBufferSize, read_callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
@@ -356,7 +360,8 @@ TEST_F(UploadDataStreamTest, Chunk) {
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
-    int bytes_read = stream.Read(buf, kTestBufferSize, CompletionCallback());
+    int bytes_read =
+        stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kStreamSize, stream.position());
@@ -446,7 +451,7 @@ TEST_F(UploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
-  int bytes_read = stream.Read(buf, kTestDataSize, CompletionCallback());
+  int bytes_read = stream.Read(buf.get(), kTestDataSize, CompletionCallback());
   ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read);  // Not an error.
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
@@ -489,21 +494,23 @@ TEST_F(UploadDataStreamTest, ReadAsync) {
   // Consume the first element.
   TestCompletionCallback read_callback1;
   EXPECT_EQ(static_cast<int>(kTestDataSize),
-            stream.Read(buf, kTestDataSize, read_callback1.callback()));
+            stream.Read(buf.get(), kTestDataSize, read_callback1.callback()));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(read_callback1.have_result());
 
   // Consume the second element.
   TestCompletionCallback read_callback2;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf, kTestDataSize, read_callback2.callback()));
+            stream.Read(buf.get(), kTestDataSize, read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(kTestDataSize), read_callback2.WaitForResult());
 
   // Consume the third and the fourth elements.
   TestCompletionCallback read_callback3;
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf, kTestDataSize*2, read_callback3.callback()));
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2), read_callback3.WaitForResult());
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      stream.Read(buf.get(), kTestDataSize * 2, read_callback3.callback()));
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
+            read_callback3.WaitForResult());
 }
 
 void UploadDataStreamTest::FileChangedHelper(const base::FilePath& file_path,
@@ -655,8 +662,9 @@ TEST_F(UploadDataStreamTest, InitToReset) {
   TestCompletionCallback read_callback1;
   std::vector<char> buf(kTestDataSize + kTestDataSize/2);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer, buf.size(),
-                                        read_callback1.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
   EXPECT_EQ(buf.size(), stream.position());
 
@@ -671,8 +679,9 @@ TEST_F(UploadDataStreamTest, InitToReset) {
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(),
-                                        read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream.Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
 }
@@ -711,8 +720,9 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(),
-                                        read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream.Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream.IsEOF());
@@ -751,8 +761,9 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
   TestCompletionCallback read_callback1;
   std::vector<char> buf(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer, buf.size(),
-                                        read_callback1.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 
   // Call Init to cancel the previous read.
   TestCompletionCallback init_callback2;
@@ -765,8 +776,9 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(),
-                                        read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream.Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream.IsEOF());
diff --git a/net/base/upload_file_element_reader.cc b/net/base/upload_file_element_reader.cc
index 611b8c0..d1f2a12 100644
--- a/net/base/upload_file_element_reader.cc
+++ b/net/base/upload_file_element_reader.cc
@@ -94,7 +94,7 @@ int ReadInternal(scoped_refptr<IOBuffer> buf,
 
 UploadFileElementReader::FileStreamDeleter::FileStreamDeleter(
     base::TaskRunner* task_runner) : task_runner_(task_runner) {
-  DCHECK(task_runner_);
+  DCHECK(task_runner_.get());
 }
 
 UploadFileElementReader::FileStreamDeleter::~FileStreamDeleter() {}
@@ -119,11 +119,11 @@ UploadFileElementReader::UploadFileElementReader(
       range_offset_(range_offset),
       range_length_(range_length),
       expected_modification_time_(expected_modification_time),
-      file_stream_(NULL, FileStreamDeleter(task_runner_)),
+      file_stream_(NULL, FileStreamDeleter(task_runner_.get())),
       content_length_(0),
       bytes_remaining_(0),
       weak_ptr_factory_(this) {
-  DCHECK(task_runner_);
+  DCHECK(task_runner_.get());
 }
 
 UploadFileElementReader::~UploadFileElementReader() {
@@ -138,10 +138,10 @@ int UploadFileElementReader::Init(const CompletionCallback& callback) {
   Reset();
 
   ScopedFileStreamPtr* file_stream =
-      new ScopedFileStreamPtr(NULL, FileStreamDeleter(task_runner_));
+      new ScopedFileStreamPtr(NULL, FileStreamDeleter(task_runner_.get()));
   uint64* content_length = new uint64;
   const bool posted = base::PostTaskAndReplyWithResult(
-      task_runner_,
+      task_runner_.get(),
       FROM_HERE,
       base::Bind(&InitInternal<FileStreamDeleter>,
                  path_,
@@ -182,7 +182,7 @@ int UploadFileElementReader::Read(IOBuffer* buf,
   // Pass the ownership of file_stream_ to the worker pool to safely perform
   // operation even when |this| is destructed before the read completes.
   const bool posted = base::PostTaskAndReplyWithResult(
-      task_runner_,
+      task_runner_.get(),
       FROM_HERE,
       base::Bind(&ReadInternal,
                  scoped_refptr<IOBuffer>(buf),
diff --git a/net/base/upload_file_element_reader_unittest.cc b/net/base/upload_file_element_reader_unittest.cc
index 672ad54..783175f 100644
--- a/net/base/upload_file_element_reader_unittest.cc
+++ b/net/base/upload_file_element_reader_unittest.cc
@@ -53,15 +53,17 @@ TEST_F(UploadFileElementReaderTest, ReadPartially) {
   std::vector<char> buf(kHalfSize);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   TestCompletionCallback read_callback1;
-  ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback1.callback()));
+  ASSERT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback1.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
   EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining());
   EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf);
 
   TestCompletionCallback read_callback2;
-  EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf);
@@ -71,14 +73,16 @@ TEST_F(UploadFileElementReaderTest, ReadAll) {
   std::vector<char> buf(bytes_.size());
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   TestCompletionCallback read_callback;
-  ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
   // Try to read again.
-  EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(),
-                             read_callback.callback()));
+  EXPECT_EQ(0,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback.callback()));
 }
 
 TEST_F(UploadFileElementReaderTest, ReadTooMuch) {
@@ -86,8 +90,9 @@ TEST_F(UploadFileElementReaderTest, ReadTooMuch) {
   std::vector<char> buf(kTooLargeSize);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   TestCompletionCallback read_callback;
-  ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback.callback()));
   EXPECT_EQ(static_cast<int>(bytes_.size()), read_callback.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   buf.resize(bytes_.size());  // Resize to compare.
@@ -100,8 +105,9 @@ TEST_F(UploadFileElementReaderTest, MultipleInit) {
 
   // Read all.
   TestCompletionCallback read_callback1;
-  ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback1.callback()));
+  ASSERT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback1.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
@@ -115,8 +121,9 @@ TEST_F(UploadFileElementReaderTest, MultipleInit) {
 
   // Read again.
   TestCompletionCallback read_callback2;
-  ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback2.callback()));
+  ASSERT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
@@ -128,8 +135,9 @@ TEST_F(UploadFileElementReaderTest, InitDuringAsyncOperation) {
 
   // Start reading all.
   TestCompletionCallback read_callback1;
-  EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(),
-                                          read_callback1.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 
   // Call Init to cancel the previous read.
   TestCompletionCallback init_callback1;
@@ -146,8 +154,9 @@ TEST_F(UploadFileElementReaderTest, InitDuringAsyncOperation) {
   std::vector<char> buf2(bytes_.size() / 2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   TestCompletionCallback read_callback2;
-  EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer2, buf2.size(),
-                                          read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            reader_->Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(bytes_.size() - buf2.size(), reader_->BytesRemaining());
   EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + buf2.size()),
@@ -172,8 +181,9 @@ TEST_F(UploadFileElementReaderTest, Range) {
   std::vector<char> buf(kLength);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   TestCompletionCallback read_callback;
-  ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, kLength,
-                                          read_callback.callback()));
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      reader_->Read(wrapped_buffer.get(), kLength, read_callback.callback()));
   EXPECT_EQ(static_cast<int>(kLength), read_callback.WaitForResult());
   const std::vector<char> expected(bytes_.begin() + kOffset,
                                    bytes_.begin() + kOffset + kLength);
@@ -242,13 +252,15 @@ TEST_F(UploadFileElementReaderSyncTest, ReadPartially) {
   ASSERT_EQ(bytes_.size(), kHalfSize * 2);
   std::vector<char> buf(kHalfSize);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining());
   EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf);
 
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf);
 }
@@ -256,20 +268,23 @@ TEST_F(UploadFileElementReaderSyncTest, ReadPartially) {
 TEST_F(UploadFileElementReaderSyncTest, ReadAll) {
   std::vector<char> buf(bytes_.size());
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
   // Try to read again.
-  EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      0, reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
 }
 
 TEST_F(UploadFileElementReaderSyncTest, ReadTooMuch) {
   const size_t kTooLargeSize = bytes_.size() * 2;
   std::vector<char> buf(kTooLargeSize);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(static_cast<int>(bytes_.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(bytes_.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   buf.resize(bytes_.size());  // Resize to compare.
   EXPECT_EQ(bytes_, buf);
@@ -280,8 +295,9 @@ TEST_F(UploadFileElementReaderSyncTest, MultipleInit) {
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 
   // Read all.
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
 
@@ -291,8 +307,9 @@ TEST_F(UploadFileElementReaderSyncTest, MultipleInit) {
   EXPECT_EQ(bytes_.size(), reader_->BytesRemaining());
 
   // Read again.
-  EXPECT_EQ(static_cast<int>(buf.size()),
-            reader_->Read(wrapped_buffer, buf.size(), CompletionCallback()));
+  EXPECT_EQ(
+      static_cast<int>(buf.size()),
+      reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback()));
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_EQ(bytes_, buf);
 }
@@ -308,7 +325,7 @@ TEST_F(UploadFileElementReaderSyncTest, Range) {
   std::vector<char> buf(kLength);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   EXPECT_EQ(static_cast<int>(kLength),
-            reader_->Read(wrapped_buffer, kLength, CompletionCallback()));
+            reader_->Read(wrapped_buffer.get(), kLength, CompletionCallback()));
   const std::vector<char> expected(bytes_.begin() + kOffset,
                                    bytes_.begin() + kOffset + kLength);
   EXPECT_EQ(expected, buf);
diff --git a/net/cert/cert_verify_proc_unittest.cc b/net/cert/cert_verify_proc_unittest.cc
index d5bc7db..e376806 100644
--- a/net/cert/cert_verify_proc_unittest.cc
+++ b/net/cert/cert_verify_proc_unittest.cc
@@ -125,8 +125,13 @@ TEST_F(CertVerifyProcTest, WithoutRevocationChecking) {
                                         intermediates);
 
   CertVerifyResult verify_result;
-  EXPECT_EQ(OK, Verify(google_full_chain, "www.google.com", 0 /* flags */,
-                       NULL, empty_cert_list_, &verify_result));
+  EXPECT_EQ(OK,
+            Verify(google_full_chain.get(),
+                   "www.google.com",
+                   0 /* flags */,
+                   NULL,
+                   empty_cert_list_,
+                   &verify_result));
 }
 
 #if defined(OS_ANDROID) || defined(USE_OPENSSL)
@@ -154,8 +159,12 @@ TEST_F(CertVerifyProcTest, MAYBE_EVVerification) {
   scoped_refptr<CRLSet> crl_set(CRLSet::EmptyCRLSetForTesting());
   CertVerifyResult verify_result;
   int flags = CertVerifier::VERIFY_EV_CERT;
-  int error = Verify(comodo_chain, "comodo.com", flags, crl_set.get(),
-                     empty_cert_list_, &verify_result);
+  int error = Verify(comodo_chain.get(),
+                     "comodo.com",
+                     flags,
+                     crl_set.get(),
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_TRUE(verify_result.cert_status & CERT_STATUS_IS_EV);
 }
@@ -175,8 +184,12 @@ TEST_F(CertVerifyProcTest, PaypalNullCertParsing) {
 
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = Verify(paypal_null_cert, "www.paypal.com", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(paypal_null_cert.get(),
+                     "www.paypal.com",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
 #if defined(USE_NSS) || defined(OS_IOS) || defined(OS_ANDROID)
   EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error);
 #else
@@ -212,7 +225,7 @@ TEST_F(CertVerifyProcTest, IntermediateCARequireExplicitPolicy) {
 
   scoped_refptr<X509Certificate> root_cert =
       ImportCertFromFile(certs_dir, "dod_root_ca_2_cert.der");
-  ScopedTestRoot scoped_root(root_cert);
+  ScopedTestRoot scoped_root(root_cert.get());
 
   X509Certificate::OSCertHandles intermediates;
   intermediates.push_back(intermediate_cert->os_cert_handle());
@@ -222,8 +235,12 @@ TEST_F(CertVerifyProcTest, IntermediateCARequireExplicitPolicy) {
 
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = Verify(cert_chain, "www.us.army.mil", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(cert_chain.get(),
+                     "www.us.army.mil",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   if (error == OK) {
     EXPECT_EQ(0U, verify_result.cert_status);
   } else {
@@ -262,8 +279,12 @@ TEST_F(CertVerifyProcTest, DISABLED_GlobalSignR3EVTest) {
   CertVerifyResult verify_result;
   int flags = CertVerifier::VERIFY_REV_CHECKING_ENABLED |
               CertVerifier::VERIFY_EV_CERT;
-  int error = Verify(cert_chain, "2029.globalsign.com", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(cert_chain.get(),
+                     "2029.globalsign.com",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   if (error == OK)
     EXPECT_TRUE(verify_result.cert_status & CERT_STATUS_IS_EV);
   else
@@ -280,7 +301,7 @@ TEST_F(CertVerifyProcTest, ECDSA_RSA) {
                          "prime256v1-ecdsa-ee-by-1024-rsa-intermediate.pem");
 
   CertVerifyResult verify_result;
-  Verify(cert, "127.0.0.1", 0, NULL, empty_cert_list_, &verify_result);
+  Verify(cert.get(), "127.0.0.1", 0, NULL, empty_cert_list_, &verify_result);
 
   // We don't check verify_result because the certificate is signed by an
   // unknown CA and will be considered invalid on XP because of the ECDSA
@@ -328,7 +349,7 @@ TEST_F(CertVerifyProcTest, RejectWeakKeys) {
   scoped_refptr<X509Certificate> root_cert =
       ImportCertFromFile(certs_dir, "2048-rsa-root.pem");
   ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert);
-  ScopedTestRoot scoped_root(root_cert);
+  ScopedTestRoot scoped_root(root_cert.get());
 
   // Now test each chain.
   for (Strings::const_iterator ee_type = key_types.begin();
@@ -354,8 +375,12 @@ TEST_F(CertVerifyProcTest, RejectWeakKeys) {
                                             intermediates);
 
       CertVerifyResult verify_result;
-      int error = Verify(cert_chain, "127.0.0.1", 0, NULL,
-                         empty_cert_list_, &verify_result);
+      int error = Verify(cert_chain.get(),
+                         "127.0.0.1",
+                         0,
+                         NULL,
+                         empty_cert_list_,
+                         &verify_result);
 
       if (IsWeakKeyType(*ee_type) || IsWeakKeyType(*signer_type)) {
         EXPECT_NE(OK, error);
@@ -399,8 +424,12 @@ TEST_F(CertVerifyProcTest, ExtraneousMD5RootCert) {
 
   CertVerifyResult verify_result;
   int flags = 0;
-  int error = Verify(cert_chain, "images.etrade.wallst.com", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(cert_chain.get(),
+                     "images.etrade.wallst.com",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   if (error != OK)
     EXPECT_EQ(ERR_CERT_DATE_INVALID, error);
 
@@ -428,15 +457,23 @@ TEST_F(CertVerifyProcTest, GoogleDigiNotarTest) {
 
   CertVerifyResult verify_result;
   int flags = CertVerifier::VERIFY_REV_CHECKING_ENABLED;
-  int error = Verify(cert_chain, "mail.google.com", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(cert_chain.get(),
+                     "mail.google.com",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_NE(OK, error);
 
   // Now turn off revocation checking.  Certificate verification should still
   // fail.
   flags = 0;
-  error = Verify(cert_chain, "mail.google.com", flags, NULL,
-                 empty_cert_list_, &verify_result);
+  error = Verify(cert_chain.get(),
+                 "mail.google.com",
+                 flags,
+                 NULL,
+                 empty_cert_list_,
+                 &verify_result);
   EXPECT_NE(OK, error);
 }
 
@@ -493,8 +530,12 @@ TEST_F(CertVerifyProcTest, TestKnownRoot) {
   CertVerifyResult verify_result;
   // This will blow up, June 8th, 2014. Sorry! Please disable and file a bug
   // against agl. See also PublicKeyHashes.
-  int error = Verify(cert_chain, "cert.se", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(cert_chain.get(),
+                     "cert.se",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
   EXPECT_TRUE(verify_result.is_issued_by_known_root);
@@ -518,8 +559,12 @@ TEST_F(CertVerifyProcTest, PublicKeyHashes) {
 
   // This will blow up, June 8th, 2014. Sorry! Please disable and file a bug
   // against agl. See also TestKnownRoot.
-  int error = Verify(cert_chain, "cert.se", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(cert_chain.get(),
+                     "cert.se",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
   ASSERT_LE(3u, verify_result.public_key_hashes.size());
@@ -563,8 +608,12 @@ TEST_F(CertVerifyProcTest, InvalidKeyUsage) {
 
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = Verify(server_cert, "jira.aquameta.com", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(server_cert.get(),
+                     "jira.aquameta.com",
+                     flags,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
 #if defined(USE_OPENSSL) && !defined(OS_ANDROID)
   // This certificate has two errors: "invalid key usage" and "untrusted CA".
   // However, OpenSSL returns only one (the latter), and we can't detect
@@ -599,7 +648,7 @@ TEST_F(CertVerifyProcTest, VerifyReturnChainBasic) {
   intermediates.push_back(certs[1]->os_cert_handle());
   intermediates.push_back(certs[2]->os_cert_handle());
 
-  ScopedTestRoot scoped_root(certs[2]);
+  ScopedTestRoot scoped_root(certs[2].get());
 
   scoped_refptr<X509Certificate> google_full_chain =
       X509Certificate::CreateFromHandle(certs[0]->os_cert_handle(),
@@ -609,8 +658,12 @@ TEST_F(CertVerifyProcTest, VerifyReturnChainBasic) {
 
   CertVerifyResult verify_result;
   EXPECT_EQ(static_cast<X509Certificate*>(NULL), verify_result.verified_cert);
-  int error = Verify(google_full_chain, "127.0.0.1", 0, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(google_full_chain.get(),
+                     "127.0.0.1",
+                     0,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
   ASSERT_NE(static_cast<X509Certificate*>(NULL), verify_result.verified_cert);
 
@@ -643,15 +696,15 @@ TEST_F(CertVerifyProcTest, IntranetHostsRejected) {
 
   // Intranet names for public CAs should be flagged:
   verify_proc_ = new WellKnownCaCertVerifyProc(true);
-  error = Verify(cert, "intranet", 0, NULL, empty_cert_list_,
-                 &verify_result);
+  error =
+      Verify(cert.get(), "intranet", 0, NULL, empty_cert_list_, &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_TRUE(verify_result.cert_status & CERT_STATUS_NON_UNIQUE_NAME);
 
   // However, if the CA is not well known, these should not be flagged:
   verify_proc_ = new WellKnownCaCertVerifyProc(false);
-  error = Verify(cert, "intranet", 0, NULL, empty_cert_list_,
-                 &verify_result);
+  error =
+      Verify(cert.get(), "intranet", 0, NULL, empty_cert_list_, &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_FALSE(verify_result.cert_status & CERT_STATUS_NON_UNIQUE_NAME);
 }
@@ -673,7 +726,7 @@ TEST_F(CertVerifyProcTest, VerifyReturnChainProperlyOrdered) {
   intermediates.push_back(certs[2]->os_cert_handle());
   intermediates.push_back(certs[1]->os_cert_handle());
 
-  ScopedTestRoot scoped_root(certs[2]);
+  ScopedTestRoot scoped_root(certs[2].get());
 
   scoped_refptr<X509Certificate> google_full_chain =
       X509Certificate::CreateFromHandle(certs[0]->os_cert_handle(),
@@ -683,8 +736,12 @@ TEST_F(CertVerifyProcTest, VerifyReturnChainProperlyOrdered) {
 
   CertVerifyResult verify_result;
   EXPECT_EQ(static_cast<X509Certificate*>(NULL), verify_result.verified_cert);
-  int error = Verify(google_full_chain, "127.0.0.1", 0, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(google_full_chain.get(),
+                     "127.0.0.1",
+                     0,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
   ASSERT_NE(static_cast<X509Certificate*>(NULL), verify_result.verified_cert);
 
@@ -709,7 +766,7 @@ TEST_F(CertVerifyProcTest, VerifyReturnChainFiltersUnrelatedCerts) {
       certs_dir, "x509_verify_results.chain.pem",
       X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(3U, certs.size());
-  ScopedTestRoot scoped_root(certs[2]);
+  ScopedTestRoot scoped_root(certs[2].get());
 
   scoped_refptr<X509Certificate> unrelated_dod_certificate =
       ImportCertFromFile(certs_dir, "dod_ca_17_cert.der");
@@ -733,8 +790,12 @@ TEST_F(CertVerifyProcTest, VerifyReturnChainFiltersUnrelatedCerts) {
 
   CertVerifyResult verify_result;
   EXPECT_EQ(static_cast<X509Certificate*>(NULL), verify_result.verified_cert);
-  int error = Verify(google_full_chain, "127.0.0.1", 0, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(google_full_chain.get(),
+                     "127.0.0.1",
+                     0,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
   ASSERT_NE(static_cast<X509Certificate*>(NULL), verify_result.verified_cert);
 
@@ -774,8 +835,8 @@ TEST_F(CertVerifyProcTest, AdditionalTrustAnchors) {
   // list.
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = Verify(cert, "127.0.0.1", flags, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(
+      cert.get(), "127.0.0.1", flags, NULL, empty_cert_list_, &verify_result);
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, error);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, verify_result.cert_status);
   EXPECT_FALSE(verify_result.is_issued_by_additional_trust_anchor);
@@ -783,15 +844,16 @@ TEST_F(CertVerifyProcTest, AdditionalTrustAnchors) {
   // Now add the |ca_cert| to the |trust_anchors|, and verification should pass.
   CertificateList trust_anchors;
   trust_anchors.push_back(ca_cert);
-  error = Verify(cert, "127.0.0.1", flags, NULL, trust_anchors, &verify_result);
+  error = Verify(
+      cert.get(), "127.0.0.1", flags, NULL, trust_anchors, &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
   EXPECT_TRUE(verify_result.is_issued_by_additional_trust_anchor);
 
   // Clearing the |trust_anchors| makes verification fail again (the cache
   // should be skipped).
-  error = Verify(cert, "127.0.0.1", flags, NULL,
-                 empty_cert_list_, &verify_result);
+  error = Verify(
+      cert.get(), "127.0.0.1", flags, NULL, empty_cert_list_, &verify_result);
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, error);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, verify_result.cert_status);
   EXPECT_FALSE(verify_result.is_issued_by_additional_trust_anchor);
@@ -862,8 +924,12 @@ TEST_F(CertVerifyProcTest, CRLSet) {
                                         intermediates);
 
   CertVerifyResult verify_result;
-  int error = Verify(google_full_chain, "www.google.com", 0, NULL,
-                     empty_cert_list_, &verify_result);
+  int error = Verify(google_full_chain.get(),
+                     "www.google.com",
+                     0,
+                     NULL,
+                     empty_cert_list_,
+                     &verify_result);
   EXPECT_EQ(OK, error);
 
   // First test blocking by SPKI.
@@ -873,8 +939,12 @@ TEST_F(CertVerifyProcTest, CRLSet) {
   scoped_refptr<CRLSet> crl_set;
   ASSERT_TRUE(CRLSet::Parse(crl_set_bytes, &crl_set));
 
-  error = Verify(google_full_chain, "www.google.com", 0, crl_set.get(),
-                 empty_cert_list_, &verify_result);
+  error = Verify(google_full_chain.get(),
+                 "www.google.com",
+                 0,
+                 crl_set.get(),
+                 empty_cert_list_,
+                 &verify_result);
   EXPECT_EQ(ERR_CERT_REVOKED, error);
 
   // Second, test revocation by serial number of a cert directly under the
@@ -884,8 +954,12 @@ TEST_F(CertVerifyProcTest, CRLSet) {
       sizeof(kCRLSetThawteSerialBlocked));
   ASSERT_TRUE(CRLSet::Parse(crl_set_bytes, &crl_set));
 
-  error = Verify(google_full_chain, "www.google.com", 0, crl_set.get(),
-                 empty_cert_list_, &verify_result);
+  error = Verify(google_full_chain.get(),
+                 "www.google.com",
+                 0,
+                 crl_set.get(),
+                 empty_cert_list_,
+                 &verify_result);
   EXPECT_EQ(ERR_CERT_REVOKED, error);
 
   // Lastly, test revocation by serial number of a certificate not under the
@@ -895,8 +969,12 @@ TEST_F(CertVerifyProcTest, CRLSet) {
       sizeof(kCRLSetGoogleSerialBlocked));
   ASSERT_TRUE(CRLSet::Parse(crl_set_bytes, &crl_set));
 
-  error = Verify(google_full_chain, "www.google.com", 0, crl_set.get(),
-                 empty_cert_list_, &verify_result);
+  error = Verify(google_full_chain.get(),
+                 "www.google.com",
+                 0,
+                 crl_set.get(),
+                 empty_cert_list_,
+                 &verify_result);
   EXPECT_EQ(ERR_CERT_REVOKED, error);
 }
 #endif
@@ -940,7 +1018,7 @@ TEST_P(CertVerifyProcWeakDigestTest, Verify) {
      scoped_refptr<X509Certificate> root_cert =
          ImportCertFromFile(certs_dir, data.root_cert_filename);
      ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert);
-     test_root.Reset(root_cert);
+     test_root.Reset(root_cert.get());
   }
 
   scoped_refptr<X509Certificate> intermediate_cert =
@@ -960,8 +1038,12 @@ TEST_P(CertVerifyProcWeakDigestTest, Verify) {
 
   int flags = 0;
   CertVerifyResult verify_result;
-  int rv = Verify(ee_chain, "127.0.0.1", flags, NULL,
-                  empty_cert_list_, &verify_result);
+  int rv = Verify(ee_chain.get(),
+                  "127.0.0.1",
+                  flags,
+                  NULL,
+                  empty_cert_list_,
+                  &verify_result);
   EXPECT_EQ(data.expected_has_md5, verify_result.has_md5);
   EXPECT_EQ(data.expected_has_md4, verify_result.has_md4);
   EXPECT_EQ(data.expected_has_md2, verify_result.has_md2);
diff --git a/net/cert/mock_cert_verifier.cc b/net/cert/mock_cert_verifier.cc
index 976de1a..d134991 100644
--- a/net/cert/mock_cert_verifier.cc
+++ b/net/cert/mock_cert_verifier.cc
@@ -23,7 +23,7 @@ struct MockCertVerifier::Rule {
         result(result),
         rv(rv) {
     DCHECK(cert);
-    DCHECK(result.verified_cert);
+    DCHECK(result.verified_cert.get());
   }
 
   scoped_refptr<X509Certificate> cert;
diff --git a/net/cert/multi_threaded_cert_verifier.cc b/net/cert/multi_threaded_cert_verifier.cc
index 432dda05..f89454d 100644
--- a/net/cert/multi_threaded_cert_verifier.cc
+++ b/net/cert/multi_threaded_cert_verifier.cc
@@ -204,7 +204,7 @@ class CertVerifierWorker {
 
   // Returns the certificate being verified. May only be called /before/
   // Start() is called.
-  X509Certificate* certificate() const { return cert_; }
+  X509Certificate* certificate() const { return cert_.get(); }
 
   bool Start() {
     DCHECK_EQ(base::MessageLoop::current(), origin_loop_);
@@ -225,8 +225,12 @@ class CertVerifierWorker {
  private:
   void Run() {
     // Runs on a worker thread.
-    error_ = verify_proc_->Verify(cert_, hostname_, flags_, crl_set_,
-                                  additional_trust_anchors_, &verify_result_);
+    error_ = verify_proc_->Verify(cert_.get(),
+                                  hostname_,
+                                  flags_,
+                                  crl_set_.get(),
+                                  additional_trust_anchors_,
+                                  &verify_result_);
 #if defined(USE_NSS) || defined(OS_IOS)
     // Detach the thread from NSPR.
     // Calling NSS functions attaches the thread to NSPR, which stores
@@ -250,8 +254,11 @@ class CertVerifierWorker {
       // memory leaks or worse errors.
       base::AutoLock locked(lock_);
       if (!canceled_) {
-        cert_verifier_->HandleResult(cert_, hostname_, flags_,
-                                     additional_trust_anchors_, error_,
+        cert_verifier_->HandleResult(cert_.get(),
+                                     hostname_,
+                                     flags_,
+                                     additional_trust_anchors_,
+                                     error_,
                                      verify_result_);
       }
     }
@@ -448,8 +455,13 @@ int MultiThreadedCertVerifier::Verify(X509Certificate* cert,
   } else {
     // Need to make a new request.
     CertVerifierWorker* worker =
-        new CertVerifierWorker(verify_proc_, cert, hostname, flags, crl_set,
-                               additional_trust_anchors, this);
+        new CertVerifierWorker(verify_proc_.get(),
+                               cert,
+                               hostname,
+                               flags,
+                               crl_set,
+                               additional_trust_anchors,
+                               this);
     job = new CertVerifierJob(
         worker,
         BoundNetLog::Make(net_log.net_log(), NetLog::SOURCE_CERT_VERIFIER_JOB));
diff --git a/net/cert/multi_threaded_cert_verifier_unittest.cc b/net/cert/multi_threaded_cert_verifier_unittest.cc
index 19afd2e..81cff8f 100644
--- a/net/cert/multi_threaded_cert_verifier_unittest.cc
+++ b/net/cert/multi_threaded_cert_verifier_unittest.cc
@@ -86,9 +86,14 @@ TEST_F(MultiThreadedCertVerifierTest, CacheHit) {
   TestCompletionCallback callback;
   CertVerifier::RequestHandle request_handle;
 
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
   error = callback.WaitForResult();
@@ -98,9 +103,14 @@ TEST_F(MultiThreadedCertVerifierTest, CacheHit) {
   ASSERT_EQ(0u, verifier_.inflight_joins());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   // Synchronous completion.
   ASSERT_NE(ERR_IO_PENDING, error);
   ASSERT_TRUE(IsCertificateError(error));
@@ -146,9 +156,14 @@ TEST_F(MultiThreadedCertVerifierTest, DifferentCACerts) {
   TestCompletionCallback callback;
   CertVerifier::RequestHandle request_handle;
 
-  error = verifier_.Verify(cert_chain1, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(cert_chain1.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
   error = callback.WaitForResult();
@@ -158,9 +173,14 @@ TEST_F(MultiThreadedCertVerifierTest, DifferentCACerts) {
   ASSERT_EQ(0u, verifier_.inflight_joins());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
-  error = verifier_.Verify(cert_chain2, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(cert_chain2.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
   error = callback.WaitForResult();
@@ -186,14 +206,24 @@ TEST_F(MultiThreadedCertVerifierTest, InflightJoin) {
   TestCompletionCallback callback2;
   CertVerifier::RequestHandle request_handle2;
 
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
-  error = verifier_.Verify(
-      test_cert, "www.example.com", 0, NULL, &verify_result2,
-      callback2.callback(), &request_handle2, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result2,
+                           callback2.callback(),
+                           &request_handle2,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle2 != NULL);
   error = callback.WaitForResult();
@@ -216,9 +246,14 @@ TEST_F(MultiThreadedCertVerifierTest, CancelRequest) {
   CertVerifyResult verify_result;
   CertVerifier::RequestHandle request_handle;
 
-  error = verifier_.Verify(
-      test_cert, "www.example.com", 0, NULL, &verify_result,
-      base::Bind(&FailTest), &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           base::Bind(&FailTest),
+                           &request_handle,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
   verifier_.CancelRequest(request_handle);
@@ -228,9 +263,14 @@ TEST_F(MultiThreadedCertVerifierTest, CancelRequest) {
   // worker thread) is likely to complete by the end of this test.
   TestCompletionCallback callback;
   for (int i = 0; i < 5; ++i) {
-    error = verifier_.Verify(
-        test_cert, "www2.example.com", 0, NULL, &verify_result,
-        callback.callback(), &request_handle, BoundNetLog());
+    error = verifier_.Verify(test_cert.get(),
+                             "www2.example.com",
+                             0,
+                             NULL,
+                             &verify_result,
+                             callback.callback(),
+                             &request_handle,
+                             BoundNetLog());
     ASSERT_EQ(ERR_IO_PENDING, error);
     ASSERT_TRUE(request_handle != NULL);
     error = callback.WaitForResult();
@@ -250,9 +290,14 @@ TEST_F(MultiThreadedCertVerifierTest, CancelRequestThenQuit) {
   TestCompletionCallback callback;
   CertVerifier::RequestHandle request_handle;
 
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
   verifier_.CancelRequest(request_handle);
@@ -363,7 +408,7 @@ TEST_F(MultiThreadedCertVerifierTest, CertTrustAnchorProvider) {
 
   scoped_refptr<X509Certificate> test_cert(
       ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem"));
-  ASSERT_TRUE(test_cert);
+  ASSERT_TRUE(test_cert.get());
 
   const CertificateList empty_cert_list;
   CertificateList cert_list;
@@ -377,9 +422,14 @@ TEST_F(MultiThreadedCertVerifierTest, CertTrustAnchorProvider) {
   CertVerifier::RequestHandle request_handle;
   EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors())
       .WillOnce(ReturnRef(empty_cert_list));
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   Mock::VerifyAndClearExpectations(&trust_provider);
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle);
@@ -391,9 +441,14 @@ TEST_F(MultiThreadedCertVerifierTest, CertTrustAnchorProvider) {
   // The next Verify() uses the cached result.
   EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors())
       .WillOnce(ReturnRef(empty_cert_list));
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   Mock::VerifyAndClearExpectations(&trust_provider);
   EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error);
   EXPECT_FALSE(request_handle);
@@ -404,9 +459,14 @@ TEST_F(MultiThreadedCertVerifierTest, CertTrustAnchorProvider) {
   // trust anchors will not reuse the cache.
   EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors())
       .WillOnce(ReturnRef(cert_list));
-  error = verifier_.Verify(test_cert, "www.example.com", 0, NULL,
-                           &verify_result, callback.callback(),
-                           &request_handle, BoundNetLog());
+  error = verifier_.Verify(test_cert.get(),
+                           "www.example.com",
+                           0,
+                           NULL,
+                           &verify_result,
+                           callback.callback(),
+                           &request_handle,
+                           BoundNetLog());
   Mock::VerifyAndClearExpectations(&trust_provider);
   ASSERT_EQ(ERR_IO_PENDING, error);
   ASSERT_TRUE(request_handle != NULL);
diff --git a/net/cert/nss_cert_database.cc b/net/cert/nss_cert_database.cc
index df3ddc0..0845dd41 100644
--- a/net/cert/nss_cert_database.cc
+++ b/net/cert/nss_cert_database.cc
@@ -145,10 +145,10 @@ X509Certificate* NSSCertDatabase::FindRootInList(
   if (certificates.size() == 1)
     return certificates[0].get();
 
-  X509Certificate* cert0 = certificates[0];
-  X509Certificate* cert1 = certificates[1];
-  X509Certificate* certn_2 = certificates[certificates.size() - 2];
-  X509Certificate* certn_1 = certificates[certificates.size() - 1];
+  X509Certificate* cert0 = certificates[0].get();
+  X509Certificate* cert1 = certificates[1].get();
+  X509Certificate* certn_2 = certificates[certificates.size() - 2].get();
+  X509Certificate* certn_1 = certificates[certificates.size() - 1].get();
 
   if (CERT_CompareName(&cert1->os_cert_handle()->issuer,
                        &cert0->os_cert_handle()->subject) == SECEqual)
diff --git a/net/cert/nss_cert_database_unittest.cc b/net/cert/nss_cert_database_unittest.cc
index db27125..7a1b8c8 100644
--- a/net/cert/nss_cert_database_unittest.cc
+++ b/net/cert/nss_cert_database_unittest.cc
@@ -116,7 +116,7 @@ class CertDatabaseNSSTest : public testing::Test {
       if (srv != SECSuccess)
         ok = false;
 
-      if (!cert_db_->DeleteCertAndKey(certs[i]))
+      if (!cert_db_->DeleteCertAndKey(certs[i].get()))
         ok = false;
     }
     return ok;
@@ -139,7 +139,7 @@ TEST_F(CertDatabaseNSSTest, ImportFromPKCS12WrongPassword) {
   std::string pkcs12_data = ReadTestFile("client.p12");
 
   EXPECT_EQ(ERR_PKCS12_IMPORT_BAD_PASSWORD,
-            cert_db_->ImportFromPKCS12(slot_,
+            cert_db_->ImportFromPKCS12(slot_.get(),
                                        pkcs12_data,
                                        base::string16(),
                                        true,  // is_extractable
@@ -152,11 +152,12 @@ TEST_F(CertDatabaseNSSTest, ImportFromPKCS12WrongPassword) {
 TEST_F(CertDatabaseNSSTest, ImportFromPKCS12AsExtractableAndExportAgain) {
   std::string pkcs12_data = ReadTestFile("client.p12");
 
-  EXPECT_EQ(OK, cert_db_->ImportFromPKCS12(slot_,
-                                           pkcs12_data,
-                                           ASCIIToUTF16("12345"),
-                                           true,  // is_extractable
-                                           NULL));
+  EXPECT_EQ(OK,
+            cert_db_->ImportFromPKCS12(slot_.get(),
+                                       pkcs12_data,
+                                       ASCIIToUTF16("12345"),
+                                       true,  // is_extractable
+                                       NULL));
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
@@ -176,31 +177,34 @@ TEST_F(CertDatabaseNSSTest, ImportFromPKCS12AsExtractableAndExportAgain) {
 TEST_F(CertDatabaseNSSTest, ImportFromPKCS12Twice) {
   std::string pkcs12_data = ReadTestFile("client.p12");
 
-  EXPECT_EQ(OK, cert_db_->ImportFromPKCS12(slot_,
-                                           pkcs12_data,
-                                           ASCIIToUTF16("12345"),
-                                           true,  // is_extractable
-                                           NULL));
+  EXPECT_EQ(OK,
+            cert_db_->ImportFromPKCS12(slot_.get(),
+                                       pkcs12_data,
+                                       ASCIIToUTF16("12345"),
+                                       true,  // is_extractable
+                                       NULL));
   EXPECT_EQ(1U, ListCertsInSlot(slot_->os_module_handle()).size());
 
   // NSS has a SEC_ERROR_PKCS12_DUPLICATE_DATA error, but it doesn't look like
   // it's ever used.  This test verifies that.
-  EXPECT_EQ(OK, cert_db_->ImportFromPKCS12(slot_,
-                                           pkcs12_data,
-                                           ASCIIToUTF16("12345"),
-                                           true,  // is_extractable
-                                           NULL));
+  EXPECT_EQ(OK,
+            cert_db_->ImportFromPKCS12(slot_.get(),
+                                       pkcs12_data,
+                                       ASCIIToUTF16("12345"),
+                                       true,  // is_extractable
+                                       NULL));
   EXPECT_EQ(1U, ListCertsInSlot(slot_->os_module_handle()).size());
 }
 
 TEST_F(CertDatabaseNSSTest, ImportFromPKCS12AsUnextractableAndExportAgain) {
   std::string pkcs12_data = ReadTestFile("client.p12");
 
-  EXPECT_EQ(OK, cert_db_->ImportFromPKCS12(slot_,
-                                           pkcs12_data,
-                                           ASCIIToUTF16("12345"),
-                                           false,  // is_extractable
-                                           NULL));
+  EXPECT_EQ(OK,
+            cert_db_->ImportFromPKCS12(slot_.get(),
+                                       pkcs12_data,
+                                       ASCIIToUTF16("12345"),
+                                       false,  // is_extractable
+                                       NULL));
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
@@ -218,22 +222,24 @@ TEST_F(CertDatabaseNSSTest, ImportFromPKCS12AsUnextractableAndExportAgain) {
 // private key should not mark an existing private key as unextractable.
 TEST_F(CertDatabaseNSSTest, ImportFromPKCS12OnlyMarkIncludedKey) {
   std::string pkcs12_data = ReadTestFile("client.p12");
-  EXPECT_EQ(OK, cert_db_->ImportFromPKCS12(slot_,
-                                           pkcs12_data,
-                                           ASCIIToUTF16("12345"),
-                                           true,  // is_extractable
-                                           NULL));
+  EXPECT_EQ(OK,
+            cert_db_->ImportFromPKCS12(slot_.get(),
+                                       pkcs12_data,
+                                       ASCIIToUTF16("12345"),
+                                       true,  // is_extractable
+                                       NULL));
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
 
   // Now import a PKCS#12 file with just a certificate but no private key.
   pkcs12_data = ReadTestFile("client-nokey.p12");
-  EXPECT_EQ(OK, cert_db_->ImportFromPKCS12(slot_,
-                                           pkcs12_data,
-                                           ASCIIToUTF16("12345"),
-                                           false,  // is_extractable
-                                           NULL));
+  EXPECT_EQ(OK,
+            cert_db_->ImportFromPKCS12(slot_.get(),
+                                       pkcs12_data,
+                                       ASCIIToUTF16("12345"),
+                                       false,  // is_extractable
+                                       NULL));
 
   cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
@@ -249,7 +255,7 @@ TEST_F(CertDatabaseNSSTest, ImportFromPKCS12InvalidFile) {
   std::string pkcs12_data = "Foobarbaz";
 
   EXPECT_EQ(ERR_PKCS12_IMPORT_INVALID_FILE,
-            cert_db_->ImportFromPKCS12(slot_,
+            cert_db_->ImportFromPKCS12(slot_.get(),
                                        pkcs12_data,
                                        base::string16(),
                                        true,  // is_extractable
@@ -541,8 +547,12 @@ TEST_F(CertDatabaseNSSTest, DISABLED_ImportServerCert) {
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(goog_cert, "www.google.com", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(goog_cert.get(),
+                                  "www.google.com",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
 }
@@ -568,8 +578,12 @@ TEST_F(CertDatabaseNSSTest, ImportServerCert_SelfSigned) {
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(puny_cert, "xn--wgv71a119e.com", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(puny_cert.get(),
+                                  "xn--wgv71a119e.com",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, error);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, verify_result.cert_status);
 }
@@ -603,8 +617,12 @@ TEST_F(CertDatabaseNSSTest, ImportServerCert_SelfSigned_Trusted) {
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(puny_cert, "xn--wgv71a119e.com", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(puny_cert.get(),
+                                  "xn--wgv71a119e.com",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
 }
@@ -635,8 +653,12 @@ TEST_F(CertDatabaseNSSTest, ImportCaAndServerCert) {
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(certs[0].get(),
+                                  "127.0.0.1",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
 }
@@ -670,7 +692,7 @@ TEST_F(CertDatabaseNSSTest, ImportCaAndServerCert_DistrustServer) {
       certs, NSSCertDatabase::DISTRUSTED_SSL, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::DISTRUSTED_SSL,
-            cert_db_->GetCertTrust(certs[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs[0].get(), SERVER_CERT));
 
   EXPECT_EQ(unsigned(CERTDB_TERMINAL_RECORD),
             certs[0]->os_cert_handle()->trust->sslFlags);
@@ -679,8 +701,12 @@ TEST_F(CertDatabaseNSSTest, ImportCaAndServerCert_DistrustServer) {
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(certs[0].get(),
+                                  "127.0.0.1",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(ERR_CERT_REVOKED, error);
   EXPECT_EQ(CERT_STATUS_REVOKED, verify_result.cert_status);
 }
@@ -717,14 +743,18 @@ TEST_F(CertDatabaseNSSTest, TrustIntermediateCa) {
       certs, NSSCertDatabase::TRUST_DEFAULT, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::TRUST_DEFAULT,
-            cert_db_->GetCertTrust(certs[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs[0].get(), SERVER_CERT));
 
   // Server cert should verify.
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(certs[0].get(),
+                                  "127.0.0.1",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
 
@@ -736,9 +766,9 @@ TEST_F(CertDatabaseNSSTest, TrustIntermediateCa) {
 
   // Trust the root cert and distrust the intermediate.
   EXPECT_TRUE(cert_db_->SetCertTrust(
-      ca_certs[0], CA_CERT, NSSCertDatabase::TRUSTED_SSL));
+      ca_certs[0].get(), CA_CERT, NSSCertDatabase::TRUSTED_SSL));
   EXPECT_TRUE(cert_db_->SetCertTrust(
-      intermediate_certs[0], CA_CERT, NSSCertDatabase::DISTRUSTED_SSL));
+      intermediate_certs[0].get(), CA_CERT, NSSCertDatabase::DISTRUSTED_SSL));
   EXPECT_EQ(
       unsigned(CERTDB_VALID_CA | CERTDB_TRUSTED_CA | CERTDB_TRUSTED_CLIENT_CA),
       ca_certs[0]->os_cert_handle()->trust->sslFlags);
@@ -756,8 +786,12 @@ TEST_F(CertDatabaseNSSTest, TrustIntermediateCa) {
 
   // Server cert should fail to verify.
   CertVerifyResult verify_result2;
-  error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                              NULL, empty_cert_list_, &verify_result2);
+  error = verify_proc->Verify(certs[0].get(),
+                              "127.0.0.1",
+                              flags,
+                              NULL,
+                              empty_cert_list_,
+                              &verify_result2);
   EXPECT_EQ(ERR_CERT_REVOKED, error);
   EXPECT_EQ(CERT_STATUS_REVOKED, verify_result2.cert_status);
 }
@@ -791,25 +825,33 @@ TEST_F(CertDatabaseNSSTest, TrustIntermediateCa2) {
       certs, NSSCertDatabase::TRUST_DEFAULT, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::TRUST_DEFAULT,
-            cert_db_->GetCertTrust(certs[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs[0].get(), SERVER_CERT));
 
   // Server cert should verify.
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(certs[0].get(),
+                                  "127.0.0.1",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
 
   // Without explicit trust of the intermediate, verification should fail.
   EXPECT_TRUE(cert_db_->SetCertTrust(
-      intermediate_certs[0], CA_CERT, NSSCertDatabase::TRUST_DEFAULT));
+      intermediate_certs[0].get(), CA_CERT, NSSCertDatabase::TRUST_DEFAULT));
 
   // Server cert should fail to verify.
   CertVerifyResult verify_result2;
-  error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                              NULL, empty_cert_list_, &verify_result2);
+  error = verify_proc->Verify(certs[0].get(),
+                              "127.0.0.1",
+                              flags,
+                              NULL,
+                              empty_cert_list_,
+                              &verify_result2);
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, error);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, verify_result2.cert_status);
 }
@@ -853,25 +895,33 @@ TEST_F(CertDatabaseNSSTest, TrustIntermediateCa3) {
       certs, NSSCertDatabase::TRUST_DEFAULT, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::TRUST_DEFAULT,
-            cert_db_->GetCertTrust(certs[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs[0].get(), SERVER_CERT));
 
   // Server cert should verify.
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(certs[0].get(),
+                                  "127.0.0.1",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result.cert_status);
 
   // Without explicit trust of the intermediate, verification should fail.
   EXPECT_TRUE(cert_db_->SetCertTrust(
-      intermediate_certs[0], CA_CERT, NSSCertDatabase::TRUST_DEFAULT));
+      intermediate_certs[0].get(), CA_CERT, NSSCertDatabase::TRUST_DEFAULT));
 
   // Server cert should fail to verify.
   CertVerifyResult verify_result2;
-  error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                              NULL, empty_cert_list_, &verify_result2);
+  error = verify_proc->Verify(certs[0].get(),
+                              "127.0.0.1",
+                              flags,
+                              NULL,
+                              empty_cert_list_,
+                              &verify_result2);
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, error);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, verify_result2.cert_status);
 }
@@ -915,25 +965,33 @@ TEST_F(CertDatabaseNSSTest, TrustIntermediateCa4) {
       certs, NSSCertDatabase::TRUST_DEFAULT, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::TRUST_DEFAULT,
-            cert_db_->GetCertTrust(certs[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs[0].get(), SERVER_CERT));
 
   // Server cert should not verify.
   scoped_refptr<CertVerifyProc> verify_proc(new CertVerifyProcNSS());
   int flags = 0;
   CertVerifyResult verify_result;
-  int error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                                  NULL, empty_cert_list_, &verify_result);
+  int error = verify_proc->Verify(certs[0].get(),
+                                  "127.0.0.1",
+                                  flags,
+                                  NULL,
+                                  empty_cert_list_,
+                                  &verify_result);
   EXPECT_EQ(ERR_CERT_REVOKED, error);
   EXPECT_EQ(CERT_STATUS_REVOKED, verify_result.cert_status);
 
   // Without explicit distrust of the intermediate, verification should succeed.
   EXPECT_TRUE(cert_db_->SetCertTrust(
-      intermediate_certs[0], CA_CERT, NSSCertDatabase::TRUST_DEFAULT));
+      intermediate_certs[0].get(), CA_CERT, NSSCertDatabase::TRUST_DEFAULT));
 
   // Server cert should verify.
   CertVerifyResult verify_result2;
-  error = verify_proc->Verify(certs[0], "127.0.0.1", flags,
-                              NULL, empty_cert_list_, &verify_result2);
+  error = verify_proc->Verify(certs[0].get(),
+                              "127.0.0.1",
+                              flags,
+                              NULL,
+                              empty_cert_list_,
+                              &verify_result2);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0U, verify_result2.cert_status);
 }
@@ -956,7 +1014,7 @@ TEST_F(CertDatabaseNSSTest, ImportDuplicateCommonName) {
       certs, NSSCertDatabase::TRUST_DEFAULT, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::TRUST_DEFAULT,
-            cert_db_->GetCertTrust(certs[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs[0].get(), SERVER_CERT));
 
   CertificateList new_certs = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, new_certs.size());
@@ -973,7 +1031,7 @@ TEST_F(CertDatabaseNSSTest, ImportDuplicateCommonName) {
       certs2, NSSCertDatabase::TRUST_DEFAULT, &failed));
   EXPECT_EQ(0U, failed.size());
   EXPECT_EQ(NSSCertDatabase::TRUST_DEFAULT,
-            cert_db_->GetCertTrust(certs2[0], SERVER_CERT));
+            cert_db_->GetCertTrust(certs2[0].get(), SERVER_CERT));
 
   new_certs = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(2U, new_certs.size());
diff --git a/net/cert/test_root_certs.cc b/net/cert/test_root_certs.cc
index 3c77ea5..3219f1d 100644
--- a/net/cert/test_root_certs.cc
+++ b/net/cert/test_root_certs.cc
@@ -47,7 +47,7 @@ bool TestRootCerts::AddFromFile(const base::FilePath& file) {
   if (root_certs.empty() || root_certs.size() > 1)
     return false;
 
-  return Add(root_certs.front());
+  return Add(root_certs.front().get());
 }
 
 TestRootCerts::TestRootCerts() {
@@ -66,7 +66,7 @@ ScopedTestRoot::~ScopedTestRoot() {
 }
 
 void ScopedTestRoot::Reset(X509Certificate* cert) {
-  if (cert_)
+  if (cert_.get())
     TestRootCerts::GetInstance()->Clear();
   if (cert)
     TestRootCerts::GetInstance()->Add(cert);
diff --git a/net/cert/x509_certificate_unittest.cc b/net/cert/x509_certificate_unittest.cc
index 735de89..7fdc8d3 100644
--- a/net/cert/x509_certificate_unittest.cc
+++ b/net/cert/x509_certificate_unittest.cc
@@ -943,7 +943,7 @@ TEST_P(X509CertificateParseTest, CanParseFormat) {
 
     // Compare the parsed certificate with the expected certificate, by
     // comparing fingerprints.
-    const X509Certificate* cert = certs[i];
+    const X509Certificate* cert = certs[i].get();
     const SHA1HashValue& actual_fingerprint = cert->fingerprint();
     uint8* expected_fingerprint = test_data_.chain_fingerprints[i];
 
diff --git a/net/cookies/cookie_monster.cc b/net/cookies/cookie_monster.cc
index 9cb26f0..21bd117 100644
--- a/net/cookies/cookie_monster.cc
+++ b/net/cookies/cookie_monster.cc
@@ -1222,7 +1222,7 @@ void CookieMonster::EnableFileScheme() {
 
 void CookieMonster::FlushStore(const base::Closure& callback) {
   base::AutoLock autolock(lock_);
-  if (initialized_ && store_)
+  if (initialized_ && store_.get())
     store_->Flush(callback);
   else if (!callback.is_null())
     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
@@ -1341,7 +1341,7 @@ void CookieMonster::SetPriorityAwareGarbageCollection(
 }
 
 void CookieMonster::SetForceKeepSessionState() {
-  if (store_) {
+  if (store_.get()) {
     store_->SetForceKeepSessionState();
   }
 }
@@ -1353,7 +1353,7 @@ CookieMonster::~CookieMonster() {
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
-  DCHECK(!store_) << "This method is only to be used by unit-tests.";
+  DCHECK(!store_.get()) << "This method is only to be used by unit-tests.";
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
@@ -1366,7 +1366,7 @@ bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
 }
 
 void CookieMonster::InitStore() {
-  DCHECK(store_) << "Store must exist to initialize";
+  DCHECK(store_.get()) << "Store must exist to initialize";
 
   // We bind in the current time so that we can report the wall-clock time for
   // loading cookies.
@@ -1674,8 +1674,8 @@ void CookieMonster::InternalInsertCookie(const std::string& key,
                                          bool sync_to_store) {
   lock_.AssertAcquired();
 
-  if ((cc->IsPersistent() || persist_session_cookies_) &&
-      store_ && sync_to_store)
+  if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
+      sync_to_store)
     store_->AddCookie(*cc);
   cookies_.insert(CookieMap::value_type(key, cc));
   if (delegate_.get()) {
@@ -1763,7 +1763,7 @@ void CookieMonster::InternalUpdateCookieAccessTime(CanonicalCookie* cc,
       (current - cc->LastAccessDate()).InMinutes());
 
   cc->SetLastAccessDate(current);
-  if ((cc->IsPersistent() || persist_session_cookies_) && store_)
+  if ((cc->IsPersistent() || persist_session_cookies_) && store_.get())
     store_->UpdateCookieAccessTime(*cc);
 }
 
@@ -1785,8 +1785,8 @@ void CookieMonster::InternalDeleteCookie(CookieMap::iterator it,
   CanonicalCookie* cc = it->second;
   VLOG(kVlogSetCookies) << "InternalDeleteCookie() cc: " << cc->DebugString();
 
-  if ((cc->IsPersistent() || persist_session_cookies_)
-      && store_ && sync_to_store)
+  if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
+      sync_to_store)
     store_->DeleteCookie(*cc);
   if (delegate_.get()) {
     ChangeCausePair mapping = ChangeCauseMapping[deletion_cause];
diff --git a/net/cookies/cookie_monster.h b/net/cookies/cookie_monster.h
index 1f1a332..e637372 100644
--- a/net/cookies/cookie_monster.h
+++ b/net/cookies/cookie_monster.h
@@ -431,7 +431,7 @@ class NET_EXPORT CookieMonster : public CookieStore {
   // Note: this method should always be called with lock_ held.
   void InitIfNecessary() {
     if (!initialized_) {
-      if (store_) {
+      if (store_.get()) {
         InitStore();
       } else {
         loaded_ = true;
diff --git a/net/cookies/cookie_monster_perftest.cc b/net/cookies/cookie_monster_perftest.cc
index cc8604d..779f6f2 100644
--- a/net/cookies/cookie_monster_perftest.cc
+++ b/net/cookies/cookie_monster_perftest.cc
@@ -130,7 +130,7 @@ TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) {
 
   for (std::vector<std::string>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
-    setCookieCallback.SetCookie(cm, GURL(kGoogleURL), *it);
+    setCookieCallback.SetCookie(cm.get(), GURL(kGoogleURL), *it);
   }
   timer.Done();
 
@@ -139,7 +139,7 @@ TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) {
   PerfTimeLogger timer2("Cookie_monster_query_single_host");
   for (std::vector<std::string>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
-    getCookiesCallback.GetCookies(cm, GURL(kGoogleURL));
+    getCookiesCallback.GetCookies(cm.get(), GURL(kGoogleURL));
   }
   timer2.Done();
 
@@ -163,7 +163,7 @@ TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) {
   PerfTimeLogger timer("Cookie_monster_add_many_hosts");
   for (std::vector<GURL>::const_iterator it = gurls.begin();
        it != gurls.end(); ++it) {
-    setCookieCallback.SetCookie(cm, *it, cookie);
+    setCookieCallback.SetCookie(cm.get(), *it, cookie);
   }
   timer.Done();
 
@@ -172,7 +172,7 @@ TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) {
   PerfTimeLogger timer2("Cookie_monster_query_many_hosts");
   for (std::vector<GURL>::const_iterator it = gurls.begin();
        it != gurls.end(); ++it) {
-    getCookiesCallback.GetCookies(cm, *it);
+    getCookiesCallback.GetCookies(cm.get(), *it);
   }
   timer2.Done();
 
@@ -221,17 +221,17 @@ TEST_F(CookieMonsterTest, TestDomainTree) {
     GURL gurl("https://" + *it + "/");
     const std::string cookie = base::StringPrintf(domain_cookie_format_tree,
                                                   it->c_str());
-    setCookieCallback.SetCookie(cm, gurl, cookie);
+    setCookieCallback.SetCookie(cm.get(), gurl, cookie);
   }
   EXPECT_EQ(31u, cm->GetAllCookies().size());
 
   GURL probe_gurl("https://b.a.b.a.top.com/");
-  std::string cookie_line = getCookiesCallback.GetCookies(cm, probe_gurl);
-  EXPECT_EQ(5, CountInString(cookie_line, '=')) << "Cookie line: " <<
-      cookie_line;
+  std::string cookie_line = getCookiesCallback.GetCookies(cm.get(), probe_gurl);
+  EXPECT_EQ(5, CountInString(cookie_line, '='))
+      << "Cookie line: " << cookie_line;
   PerfTimeLogger timer("Cookie_monster_query_domain_tree");
   for (int i = 0; i < kNumCookies; i++) {
-    getCookiesCallback.GetCookies(cm, probe_gurl);
+    getCookiesCallback.GetCookies(cm.get(), probe_gurl);
   }
   timer.Done();
 }
@@ -263,15 +263,15 @@ TEST_F(CookieMonsterTest, TestDomainLine) {
       GURL gurl("https://" + *it + "/");
       const std::string cookie = base::StringPrintf(domain_cookie_format_line,
                                                     i, it->c_str());
-      setCookieCallback.SetCookie(cm, gurl, cookie);
+      setCookieCallback.SetCookie(cm.get(), gurl, cookie);
     }
   }
 
-  cookie_line = getCookiesCallback.GetCookies(cm, probe_gurl);
+  cookie_line = getCookiesCallback.GetCookies(cm.get(), probe_gurl);
   EXPECT_EQ(32, CountInString(cookie_line, '='));
   PerfTimeLogger timer2("Cookie_monster_query_domain_line");
   for (int i = 0; i < kNumCookies; i++) {
-    getCookiesCallback.GetCookies(cm, probe_gurl);
+    getCookiesCallback.GetCookies(cm.get(), probe_gurl);
   }
   timer2.Done();
 }
@@ -299,13 +299,13 @@ TEST_F(CookieMonsterTest, TestImport) {
 
   store->SetLoadExpectation(true, initial_cookies);
 
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   // Import will happen on first access.
   GURL gurl("www.google.com");
   CookieOptions options;
   PerfTimeLogger timer("Cookie_monster_import_from_store");
-  getCookiesCallback.GetCookies(cm, gurl);
+  getCookiesCallback.GetCookies(cm.get(), gurl);
   timer.Done();
 
   // Just confirm keys were set as expected.
@@ -373,11 +373,11 @@ TEST_F(CookieMonsterTest, TestGCTimes) {
     GURL gurl("http://google.com");
     std::string cookie_line("z=3");
     // Trigger the Garbage collection we're allowed.
-    setCookieCallback.SetCookie(cm, gurl, cookie_line);
+    setCookieCallback.SetCookie(cm.get(), gurl, cookie_line);
 
     PerfTimeLogger timer((std::string("GC_") + test_case.name).c_str());
     for (int i = 0; i < kNumCookies; i++)
-      setCookieCallback.SetCookie(cm, gurl, cookie_line);
+      setCookieCallback.SetCookie(cm.get(), gurl, cookie_line);
     timer.Done();
   }
 }
diff --git a/net/cookies/cookie_monster_store_test.cc b/net/cookies/cookie_monster_store_test.cc
index 04e39ed..14e9cc0 100644
--- a/net/cookies/cookie_monster_store_test.cc
+++ b/net/cookies/cookie_monster_store_test.cc
@@ -219,7 +219,7 @@ CookieMonster* CreateMonsterFromStoreForGC(
     store->AddCookie(cc);
   }
 
-  return new CookieMonster(store, NULL);
+  return new CookieMonster(store.get(), NULL);
 }
 
 MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {}
diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index 7b45a4b..9578840 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -222,7 +222,7 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
     GURL url_other(kOtherDomain);
 
-    DeleteAll(cm);
+    DeleteAll(cm.get());
 
     // Static population for probe:
     //    * Three levels of domain cookie (.b.a, .c.b.a, .d.c.b.a)
@@ -233,22 +233,39 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
     //    * Two host path cookies (w.c.b.a/dir1, w.c.b.a/dir1/dir2)
 
     // Domain cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_1,
-                                           "dom_1", "X", ".harvard.edu", "/",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_1,
+                                           "dom_1",
+                                           "X",
+                                           ".harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2,
-                                           "dom_2", "X", ".math.harvard.edu",
-                                           "/", base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_2,
+                                           "dom_2",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_3,
-                                           "dom_3", "X",
-                                           ".bourbaki.math.harvard.edu", "/",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_3,
+                                           "dom_3",
+                                           "X",
+                                           ".bourbaki.math.harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Host cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_1,
                                            "host_1",
                                            "X",
@@ -258,7 +275,7 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "host_2",
                                            "X",
@@ -268,7 +285,7 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_3,
                                            "host_3",
                                            "X",
@@ -280,7 +297,7 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Http_only cookie
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "httpo_check",
                                            "X",
@@ -292,12 +309,17 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Secure cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2_secure,
-                                           "sec_dom", "X", ".math.harvard.edu",
-                                           "/", base::Time(), true, false,
+                                           "sec_dom",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           true,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2_secure,
                                            "sec_host",
                                            "X",
@@ -309,19 +331,29 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Domain path cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2,
-                                           "dom_path_1", "X",
-                                           ".math.harvard.edu", "/dir1",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_2,
+                                           "dom_path_1",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/dir1",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2,
-                                           "dom_path_2", "X",
-                                           ".math.harvard.edu", "/dir1/dir2",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_2,
+                                           "dom_path_2",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/dir1/dir2",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Host path cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "host_path_1",
                                            "X",
@@ -331,7 +363,7 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "host_path_2",
                                            "X",
@@ -342,7 +374,7 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
 
-    EXPECT_EQ(13U, this->GetAllCookies(cm).size());
+    EXPECT_EQ(13U, this->GetAllCookies(cm.get()).size());
   }
 
   Time GetFirstCookieAccessDate(CookieMonster* cm) {
@@ -375,8 +407,8 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm, url_google_, cookie));
-        std::string cookies = this->GetCookies(cm, url_google_);
+        EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie));
+        std::string cookies = this->GetCookies(cm.get(), url_google_);
         // Make sure we find it in the cookies.
         EXPECT_NE(cookies.find(cookie), std::string::npos);
         // Count the number of cookies.
@@ -392,13 +424,13 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie_general = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm, url_google_, cookie_general));
+        EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie_general));
         std::string cookie_specific = base::StringPrintf("c%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm, url_google_specific, cookie_specific));
-        std::string cookies_general = this->GetCookies(cm, url_google_);
+        EXPECT_TRUE(SetCookie(cm.get(), url_google_specific, cookie_specific));
+        std::string cookies_general = this->GetCookies(cm.get(), url_google_);
         EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
         std::string cookies_specific =
-            this->GetCookies(cm, url_google_specific);
+            this->GetCookies(cm.get(), url_google_specific);
         EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos);
         EXPECT_LE((CountInString(cookies_general, '=') +
                    CountInString(cookies_specific, '=')),
@@ -406,8 +438,9 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
       }
       // After all this, there should be at least
       // kDomainMaxCookies - kDomainPurgeCookies for both URLs.
-      std::string cookies_general = this->GetCookies(cm, url_google_);
-      std::string cookies_specific = this->GetCookies(cm, url_google_specific);
+      std::string cookies_general = this->GetCookies(cm.get(), url_google_);
+      std::string cookies_specific =
+          this->GetCookies(cm.get(), url_google_specific);
       int total_cookies = (CountInString(cookies_general, '=') +
                            CountInString(cookies_specific, '='));
       EXPECT_GE(total_cookies, domain_max_cookies - domain_purge_cookies);
@@ -527,40 +560,41 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
 
     // Each test case adds 181 cookies, so 31 cookies are evicted.
     // Cookie same priority, repeated for each priority.
-    TestPriorityCookieCase(cm, "181L", 150U, 0U, 0U);
-    TestPriorityCookieCase(cm, "181M", 0U, 150U, 0U);
-    TestPriorityCookieCase(cm, "181H", 0U, 0U, 150U);
+    TestPriorityCookieCase(cm.get(), "181L", 150U, 0U, 0U);
+    TestPriorityCookieCase(cm.get(), "181M", 0U, 150U, 0U);
+    TestPriorityCookieCase(cm.get(), "181H", 0U, 0U, 150U);
 
     // Pairwise scenarios.
     // Round 1 => none; round2 => 31M; round 3 => none.
-    TestPriorityCookieCase(cm, "10H 171M", 0U, 140U, 10U);
+    TestPriorityCookieCase(cm.get(), "10H 171M", 0U, 140U, 10U);
     // Round 1 => 10L; round2 => 21M; round 3 => none.
-    TestPriorityCookieCase(cm, "141M 40L", 30U, 120U, 0U);
+    TestPriorityCookieCase(cm.get(), "141M 40L", 30U, 120U, 0U);
     // Round 1 => none; round2 => none; round 3 => 31H.
-    TestPriorityCookieCase(cm, "101H 80M", 0U, 80U, 70U);
+    TestPriorityCookieCase(cm.get(), "101H 80M", 0U, 80U, 70U);
 
     // For {low, medium} priorities right on quota, different orders.
     // Round 1 => 1L; round 2 => none, round3 => 30L.
-    TestPriorityCookieCase(cm, "31L 50M 100H", 0U, 50U, 100U);
+    TestPriorityCookieCase(cm.get(), "31L 50M 100H", 0U, 50U, 100U);
     // Round 1 => none; round 2 => 1M, round3 => 30M.
-    TestPriorityCookieCase(cm, "51M 100H 30L", 30U, 20U, 100U);
+    TestPriorityCookieCase(cm.get(), "51M 100H 30L", 30U, 20U, 100U);
     // Round 1 => none; round 2 => none; round3 => 31H.
-    TestPriorityCookieCase(cm, "101H 50M 30L", 30U, 50U, 70U);
+    TestPriorityCookieCase(cm.get(), "101H 50M 30L", 30U, 50U, 70U);
 
     // Round 1 => 10L; round 2 => 10M; round3 => 11H.
-    TestPriorityCookieCase(cm, "81H 60M 40L", 30U, 50U, 70U);
+    TestPriorityCookieCase(cm.get(), "81H 60M 40L", 30U, 50U, 70U);
 
     // More complex scenarios.
     // Round 1 => 10L; round 2 => 10M; round 3 => 11H.
-    TestPriorityCookieCase(cm, "21H 60M 40L 60H", 30U, 50U, 70U);
+    TestPriorityCookieCase(cm.get(), "21H 60M 40L 60H", 30U, 50U, 70U);
     // Round 1 => 10L; round 2 => 11M, 10L; round 3 => none.
-    TestPriorityCookieCase(cm, "11H 10M 20L 110M 20L 10H", 20U, 109U, 21U);
+    TestPriorityCookieCase(
+        cm.get(), "11H 10M 20L 110M 20L 10H", 20U, 109U, 21U);
     // Round 1 => none; round 2 => none; round 3 => 11L, 10M, 10H.
-    TestPriorityCookieCase(cm, "11L 10M 140H 10M 10L", 10U, 10U, 130U);
+    TestPriorityCookieCase(cm.get(), "11L 10M 140H 10M 10L", 10U, 10U, 130U);
     // Round 1 => none; round 2 => 1M; round 3 => 10L, 10M, 10H.
-    TestPriorityCookieCase(cm, "11M 10H 10L 60M 90H", 0U, 60U, 90U);
+    TestPriorityCookieCase(cm.get(), "11M 10H 10L 60M 90H", 0U, 60U, 90U);
     // Round 1 => none; round 2 => 10L, 21M; round 3 => none.
-    TestPriorityCookieCase(cm, "11M 10H 10L 90M 60H", 0U, 80U, 70U);
+    TestPriorityCookieCase(cm.get(), "11M 10H 10L 90M 60H", 0U, 80U, 70U);
   }
 
   // Function for creating a CM with a number of cookies in it,
@@ -765,9 +799,9 @@ class DeferredCookieTaskTest : public CookieMonsterTest {
   // Declares an expectation that PersistentCookieStore::Load will be called,
   // saving the provided callback and sending a quit to the message loop.
   void ExpectLoadCall() {
-    EXPECT_CALL(*persistent_store_, Load(testing::_)).WillOnce(testing::DoAll(
-        testing::SaveArg<0>(&loaded_callback_),
-        QuitCurrentMessageLoop()));
+    EXPECT_CALL(*persistent_store_.get(), Load(testing::_))
+        .WillOnce(testing::DoAll(testing::SaveArg<0>(&loaded_callback_),
+                                 QuitCurrentMessageLoop()));
   }
 
   // Declares an expectation that PersistentCookieStore::LoadCookiesForKey
@@ -775,20 +809,20 @@ class DeferredCookieTaskTest : public CookieMonsterTest {
   // message loop.
   void ExpectLoadForKeyCall(std::string key, bool quit_queue) {
     if (quit_queue)
-      EXPECT_CALL(*persistent_store_, LoadCookiesForKey(key, testing::_)).
-          WillOnce(testing::DoAll(
-                   PushCallbackAction(&loaded_for_key_callbacks_),
-                   QuitCurrentMessageLoop()));
+      EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
+          .WillOnce(
+               testing::DoAll(PushCallbackAction(&loaded_for_key_callbacks_),
+                              QuitCurrentMessageLoop()));
     else
-      EXPECT_CALL(*persistent_store_, LoadCookiesForKey(key, testing::_)).
-          WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
+      EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
+          .WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
   }
 
   // Invokes the initial action.
   MOCK_METHOD0(Begin, void(void));
 
   // Returns the CookieMonster instance under test.
-  CookieMonster& cookie_monster() { return *cookie_monster_; }
+  CookieMonster& cookie_monster() { return *cookie_monster_.get(); }
 
  private:
   // Declares that mock expectations in this test suite are strictly ordered.
@@ -1078,32 +1112,34 @@ TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "C=D; httponly", options));
-  EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm, url_google_, options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), url_google_, "C=D; httponly", options));
+  EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm.get(), url_google_, options));
 
-  EXPECT_EQ(2, DeleteAll(cm));
-  EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
+  EXPECT_EQ(2, DeleteAll(cm.get()));
+  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), url_google_, options));
   EXPECT_EQ(0u, store->commands().size());
 
   // Create a persistent cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        std::string(kValidCookieLine) +
-                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(SetCookie(
+      cm.get(),
+      url_google_,
+      std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
 
-  EXPECT_EQ(1, DeleteAll(cm));  // sync_to_store = true.
+  EXPECT_EQ(1, DeleteAll(cm.get()));  // sync_to_store = true.
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
-  EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
+  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), url_google_, options));
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
@@ -1111,8 +1147,9 @@ TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
   Time now = Time::Now();
 
   // Nothing has been added so nothing should be deleted.
-  EXPECT_EQ(0, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
-                                       Time()));
+  EXPECT_EQ(
+      0,
+      DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), Time()));
 
   // Create 3 cookies with creation date of today, yesterday and the day before.
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-0=Now", now));
@@ -1126,23 +1163,25 @@ TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
                                             now - TimeDelta::FromDays(7)));
 
   // Try to delete threedays and the daybefore.
-  EXPECT_EQ(2, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(3),
-                                       now - TimeDelta::FromDays(1)));
+  EXPECT_EQ(2,
+            DeleteAllCreatedBetween(cm.get(),
+                                    now - TimeDelta::FromDays(3),
+                                    now - TimeDelta::FromDays(1)));
 
   // Try to delete yesterday, also make sure that delete_end is not
   // inclusive.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(2),
-                                       now));
+  EXPECT_EQ(
+      1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(2), now));
 
   // Make sure the delete_begin is inclusive.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(7),
-                                       now));
+  EXPECT_EQ(
+      1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
 
   // Delete the last (now) item.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time()));
+  EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
 
   // Really make sure everything is gone.
-  EXPECT_EQ(0, DeleteAll(cm));
+  EXPECT_EQ(0, DeleteAll(cm.get()));
 }
 
 static const int kAccessDelayMs = kLastAccessThresholdMilliseconds + 20;
@@ -1151,19 +1190,19 @@ TEST_F(CookieMonsterTest, TestLastAccess) {
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  const Time last_access_date(GetFirstCookieAccessDate(cm));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   // Reading the cookie again immediately shouldn't update the access date,
   // since we're inside the threshold.
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
-  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 
   // Reading after a short wait should update the access date.
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kAccessDelayMs));
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
-  EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
@@ -1177,16 +1216,16 @@ TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollection) {
 TEST_F(CookieMonsterTest, TestDeleteSingleCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "C=D"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "E=F"));
-  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
 
-  EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
 
-  EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
 }
 
 TEST_F(CookieMonsterTest, SetCookieableSchemes) {
@@ -1200,10 +1239,10 @@ TEST_F(CookieMonsterTest, SetCookieableSchemes) {
   GURL foo_url("foo://host/path");
   GURL http_url("http://host/path");
 
-  EXPECT_TRUE(SetCookie(cm, http_url, "x=1"));
-  EXPECT_FALSE(SetCookie(cm, foo_url, "x=1"));
-  EXPECT_TRUE(SetCookie(cm_foo, foo_url, "x=1"));
-  EXPECT_FALSE(SetCookie(cm_foo, http_url, "x=1"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_url, "x=1"));
+  EXPECT_FALSE(SetCookie(cm.get(), foo_url, "x=1"));
+  EXPECT_TRUE(SetCookie(cm_foo.get(), foo_url, "x=1"));
+  EXPECT_FALSE(SetCookie(cm_foo.get(), http_url, "x=1"));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
@@ -1214,21 +1253,22 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B; httponly", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
-                                   "C=D; domain=.google.izzle",
-                                   options));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_secure_,
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), url_google_, "A=B; httponly", options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), url_google_, "C=D; domain=.google.izzle", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(),
+                                   url_google_secure_,
                                    "E=F; domain=.google.izzle; secure",
                                    options));
 
-  const Time last_access_date(GetFirstCookieAccessDate(cm));
+  const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kAccessDelayMs));
 
   // Check cookies for url.
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1243,7 +1283,7 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
 
   // Check cookies for url excluding http-only cookies.
   cookies =
-      GetAllCookiesForURLWithOptions(cm, url_google_, CookieOptions());
+      GetAllCookiesForURLWithOptions(cm.get(), url_google_, CookieOptions());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1253,7 +1293,7 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
   ASSERT_TRUE(++it == cookies.end());
 
   // Test secure cookies.
-  cookies = GetAllCookiesForURL(cm, url_google_secure_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1271,21 +1311,20 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
   ASSERT_TRUE(++it == cookies.end());
 
   // Reading after a short wait should not update the access date.
-  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm));
+  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
 
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_foo_,
-                                   "A=B; path=/foo;", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_bar_,
-                                   "C=D; path=/bar;", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
-                                   "E=F;", options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), url_google_foo_, "A=B; path=/foo;", options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), url_google_bar_, "C=D; path=/bar;", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "E=F;", options));
 
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1298,7 +1337,7 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm, url_google_bar_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1315,16 +1354,16 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
 TEST_F(CookieMonsterTest, DeleteCookieByName) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=A1; path=/"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=A2; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=A3; path=/bar"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "B=B1; path=/"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "B=B2; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "B=B3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B3; path=/bar"));
 
-  DeleteCookie(cm, GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
+  DeleteCookie(cm.get(), GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
 
-  CookieList cookies = GetAllCookies(cm);
+  CookieList cookies = GetAllCookies(cm.get());
   size_t expected_size = 4;
   EXPECT_EQ(expected_size, cookies.size());
   for (CookieList::iterator it = cookies.begin();
@@ -1348,10 +1387,10 @@ TEST_F(CookieMonsterTest, InitializeFromCookieMonster) {
                                                "A3=F;",
                                                options));
 
-  CookieList cookies_1 = GetAllCookies(cm_1);
+  CookieList cookies_1 = GetAllCookies(cm_1.get());
   scoped_refptr<CookieMonster> cm_2(new CookieMonster(NULL, NULL));
   ASSERT_TRUE(cm_2->InitializeFrom(cookies_1));
-  CookieList cookies_2 = GetAllCookies(cm_2);
+  CookieList cookies_2 = GetAllCookies(cm_2.get());
 
   size_t expected_size = 3;
   EXPECT_EQ(expected_size, cookies_2.size());
@@ -1435,16 +1474,16 @@ TEST_F(CookieMonsterTest, DontImportDuplicateCookies) {
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, initial_cookies);
 
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   // Verify that duplicates were not imported for path "/".
   // (If this had failed, GetCookies() would have also returned X=1, X=2, X=4).
-  EXPECT_EQ("X=3; Y=a", GetCookies(cm, GURL("http://www.google.com/")));
+  EXPECT_EQ("X=3; Y=a", GetCookies(cm.get(), GURL("http://www.google.com/")));
 
   // Verify that same-named cookie on a different path ("/x2") didn't get
   // messed up.
   EXPECT_EQ("X=a1; X=3; Y=a",
-            GetCookies(cm, GURL("http://www.google.com/2/x")));
+            GetCookies(cm.get(), GURL("http://www.google.com/2/x")));
 
   // Verify that the PersistentCookieStore was told to kill its 4 duplicates.
   ASSERT_EQ(4u, store->commands().size());
@@ -1484,9 +1523,9 @@ TEST_F(CookieMonsterTest, DontImportDuplicateCreationTimes) {
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, initial_cookies);
 
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
-  CookieList list(GetAllCookies(cm));
+  CookieList list(GetAllCookies(cm.get()));
   EXPECT_EQ(2U, list.size());
   // Confirm that we have one of each.
   std::string name1(list[0].Name());
@@ -1501,12 +1540,13 @@ TEST_F(CookieMonsterTest, Delegate) {
       new MockPersistentCookieStore);
   scoped_refptr<MockCookieMonsterDelegate> delegate(
       new MockCookieMonsterDelegate);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, delegate));
+  scoped_refptr<CookieMonster> cm(
+      new CookieMonster(store.get(), delegate.get()));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "C=D"));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "E=F"));
-  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(3u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
@@ -1522,8 +1562,8 @@ TEST_F(CookieMonsterTest, Delegate) {
   EXPECT_EQ("F", delegate->changes()[2].first.Value());
   delegate->reset();
 
-  EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(1u, delegate->changes().size());
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_TRUE(delegate->changes()[0].second);
@@ -1531,14 +1571,15 @@ TEST_F(CookieMonsterTest, Delegate) {
   EXPECT_EQ("D", delegate->changes()[0].first.Value());
   delegate->reset();
 
-  EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(0u, delegate->changes().size());
 
   // Insert a cookie "a" for path "/path1"
-  EXPECT_TRUE(
-      SetCookie(cm, url_google_, "a=val1; path=/path1; "
-                                "expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        url_google_,
+                        "a=val1; path=/path1; "
+                        "expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   ASSERT_EQ(1u, delegate->changes().size());
@@ -1552,11 +1593,11 @@ TEST_F(CookieMonsterTest, Delegate) {
   // overwrite the non-http-only version.
   CookieOptions allow_httponly;
   allow_httponly.set_include_httponly();
-  EXPECT_TRUE(
-    SetCookieWithOptions(cm, url_google_,
-                         "a=val2; path=/path1; httponly; "
-                         "expires=Mon, 18-Apr-22 22:50:14 GMT",
-                         allow_httponly));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(),
+                                   url_google_,
+                                   "a=val2; path=/path1; httponly; "
+                                   "expires=Mon, 18-Apr-22 22:50:14 GMT",
+                                   allow_httponly));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
@@ -1575,34 +1616,90 @@ TEST_F(CookieMonsterTest, Delegate) {
 TEST_F(CookieMonsterTest, SetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_foo_, "A", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_bar_, "C", "D", "google.izzle", "/bar", base::Time(),
-      false, true, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_, "E", "F", std::string(), std::string(), base::Time(),
-      true, false, COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_foo_,
+                                   "A",
+                                   "B",
+                                   std::string(),
+                                   "/foo",
+                                   base::Time(),
+                                   false,
+                                   false,
+                                   COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_bar_,
+                                   "C",
+                                   "D",
+                                   "google.izzle",
+                                   "/bar",
+                                   base::Time(),
+                                   false,
+                                   true,
+                                   COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_,
+                                   "E",
+                                   "F",
+                                   std::string(),
+                                   std::string(),
+                                   base::Time(),
+                                   true,
+                                   false,
+                                   COOKIE_PRIORITY_DEFAULT));
 
   // Test that malformed attributes fail to set the cookie.
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, " A", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A;", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A=", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A", "B", "google.ozzzzzzle", "foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A=", "B", std::string(), "foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_);
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    " A",
+                                    "B",
+                                    std::string(),
+                                    "/foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A;",
+                                    "B",
+                                    std::string(),
+                                    "/foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A=",
+                                    "B",
+                                    std::string(),
+                                    "/foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A",
+                                    "B",
+                                    "google.ozzzzzzle",
+                                    "foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A=",
+                                    "B",
+                                    std::string(),
+                                    "foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+
+  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1616,7 +1713,7 @@ TEST_F(CookieMonsterTest, SetCookieWithDetails) {
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm, url_google_bar_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1629,7 +1726,7 @@ TEST_F(CookieMonsterTest, SetCookieWithDetails) {
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm, url_google_secure_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ -1656,53 +1753,63 @@ TEST_F(CookieMonsterTest, DeleteAllForHost) {
   // this call, and domain cookies arent touched.
   PopulateCmForDeleteAllForHost(cm);
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; host_path_2=X; dom_path_1=X; host_path_1=X; "
             "dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 
-  EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2)));
-  EXPECT_EQ(8U, GetAllCookies(cm).size());
+  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2)));
+  EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
 
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 
   PopulateCmForDeleteAllForHost(cm);
-  EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ(8U, GetAllCookies(cm).size());
+  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
 
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 
   PopulateCmForDeleteAllForHost(cm);
-  EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2Secure +
-                                         std::string("/dir1/xxx"))));
-  EXPECT_EQ(8U, GetAllCookies(cm).size());
+  EXPECT_EQ(5,
+            DeleteAllForHost(
+                cm.get(),
+                GURL(kTopLevelDomainPlus2Secure + std::string("/dir1/xxx"))));
+  EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
 
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 }
 
 TEST_F(CookieMonsterTest, UniqueCreationTime) {
@@ -1719,26 +1826,50 @@ TEST_F(CookieMonsterTest, UniqueCreationTime) {
 
   // SetCookie, SetCookieWithOptions, SetCookieWithDetails
 
-  SetCookie(cm, url_google_, "SetCookie1=A");
-  SetCookie(cm, url_google_, "SetCookie2=A");
-  SetCookie(cm, url_google_, "SetCookie3=A");
-
-  SetCookieWithOptions(cm, url_google_, "setCookieWithOptions1=A", options);
-  SetCookieWithOptions(cm, url_google_, "setCookieWithOptions2=A", options);
-  SetCookieWithOptions(cm, url_google_, "setCookieWithOptions3=A", options);
-
-  SetCookieWithDetails(cm, url_google_, "setCookieWithDetails1", "A",
-                       ".google.com", "/", Time(), false, false,
+  SetCookie(cm.get(), url_google_, "SetCookie1=A");
+  SetCookie(cm.get(), url_google_, "SetCookie2=A");
+  SetCookie(cm.get(), url_google_, "SetCookie3=A");
+
+  SetCookieWithOptions(
+      cm.get(), url_google_, "setCookieWithOptions1=A", options);
+  SetCookieWithOptions(
+      cm.get(), url_google_, "setCookieWithOptions2=A", options);
+  SetCookieWithOptions(
+      cm.get(), url_google_, "setCookieWithOptions3=A", options);
+
+  SetCookieWithDetails(cm.get(),
+                       url_google_,
+                       "setCookieWithDetails1",
+                       "A",
+                       ".google.com",
+                       "/",
+                       Time(),
+                       false,
+                       false,
                        COOKIE_PRIORITY_DEFAULT);
-  SetCookieWithDetails(cm, url_google_, "setCookieWithDetails2", "A",
-                       ".google.com", "/", Time(), false, false,
+  SetCookieWithDetails(cm.get(),
+                       url_google_,
+                       "setCookieWithDetails2",
+                       "A",
+                       ".google.com",
+                       "/",
+                       Time(),
+                       false,
+                       false,
                        COOKIE_PRIORITY_DEFAULT);
-  SetCookieWithDetails(cm, url_google_, "setCookieWithDetails3", "A",
-                       ".google.com", "/", Time(), false, false,
+  SetCookieWithDetails(cm.get(),
+                       url_google_,
+                       "setCookieWithDetails3",
+                       "A",
+                       ".google.com",
+                       "/",
+                       Time(),
+                       false,
+                       false,
                        COOKIE_PRIORITY_DEFAULT);
 
   // Now we check
-  CookieList cookie_list(GetAllCookies(cm));
+  CookieList cookie_list(GetAllCookies(cm.get()));
   typedef std::map<int64, CanonicalCookie> TimeCookieMap;
   TimeCookieMap check_map;
   for (CookieList::const_iterator it = cookie_list.begin();
@@ -1807,22 +1938,30 @@ TEST_F(CookieMonsterTest, BackingStoreCommunication) {
 
   // Create new cookies and flush them to the store.
   {
-    scoped_refptr<CookieMonster> cmout(new CookieMonster(store, NULL));
+    scoped_refptr<CookieMonster> cmout(new CookieMonster(store.get(), NULL));
     for (const CookiesInputInfo* p = input_info;
-         p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
-      EXPECT_TRUE(SetCookieWithDetails(cmout, p->url, p->name, p->value,
-                                       p->domain, p->path, p->expiration_time,
-                                       p->secure, p->http_only, p->priority));
+         p < &input_info[ARRAYSIZE_UNSAFE(input_info)];
+         p++) {
+      EXPECT_TRUE(SetCookieWithDetails(cmout.get(),
+                                       p->url,
+                                       p->name,
+                                       p->value,
+                                       p->domain,
+                                       p->path,
+                                       p->expiration_time,
+                                       p->secure,
+                                       p->http_only,
+                                       p->priority));
     }
     GURL del_url(input_info[INPUT_DELETE].url.Resolve(
                      input_info[INPUT_DELETE].path).spec());
-    DeleteCookie(cmout, del_url, input_info[INPUT_DELETE].name);
+    DeleteCookie(cmout.get(), del_url, input_info[INPUT_DELETE].name);
   }
 
   // Create a new cookie monster and make sure that everything is correct
   {
-    scoped_refptr<CookieMonster> cmin(new CookieMonster(store, NULL));
-    CookieList cookies(GetAllCookies(cmin));
+    scoped_refptr<CookieMonster> cmin(new CookieMonster(store.get(), NULL));
+    CookieList cookies(GetAllCookies(cmin.get()));
     ASSERT_EQ(2u, cookies.size());
     // Ordering is path length, then creation time.  So second cookie
     // will come first, and we need to swap them.
@@ -1851,22 +1990,25 @@ TEST_F(CookieMonsterTest, CookieListOrdering) {
   // Put a random set of cookies into a monster and make sure
   // they're returned in the right order.
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, GURL("http://d.c.b.a.google.com/aa/x.html"),
-                        "c=1"));
-  EXPECT_TRUE(SetCookie(cm, GURL("http://b.a.google.com/aa/bb/cc/x.html"),
+  EXPECT_TRUE(
+      SetCookie(cm.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1"));
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        GURL("http://b.a.google.com/aa/bb/cc/x.html"),
                         "d=1; domain=b.a.google.com"));
-  EXPECT_TRUE(SetCookie(cm, GURL("http://b.a.google.com/aa/bb/cc/x.html"),
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        GURL("http://b.a.google.com/aa/bb/cc/x.html"),
                         "a=4; domain=b.a.google.com"));
-  EXPECT_TRUE(SetCookie(cm, GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
                         "e=1; domain=c.b.a.google.com"));
-  EXPECT_TRUE(SetCookie(cm, GURL("http://d.c.b.a.google.com/aa/bb/x.html"),
-                        "b=1"));
-  EXPECT_TRUE(SetCookie(cm, GURL("http://news.bbc.co.uk/midpath/x.html"),
-                        "g=10"));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), GURL("http://news.bbc.co.uk/midpath/x.html"), "g=10"));
   {
     unsigned int i = 0;
     CookieList cookies(GetAllCookiesForURL(
-        cm, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
+        cm.get(), GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
     ASSERT_EQ(5u, cookies.size());
     EXPECT_EQ("d", cookies[i++].Name());
     EXPECT_EQ("a", cookies[i++].Name());
@@ -1877,7 +2019,7 @@ TEST_F(CookieMonsterTest, CookieListOrdering) {
 
   {
     unsigned int i = 0;
-    CookieList cookies(GetAllCookies(cm));
+    CookieList cookies(GetAllCookies(cm.get()));
     ASSERT_EQ(6u, cookies.size());
     EXPECT_EQ("d", cookies[i++].Name());
     EXPECT_EQ("a", cookies[i++].Name());
@@ -1908,9 +2050,10 @@ TEST_F(CookieMonsterTest, MAYBE_GarbageCollectionTriggers) {
   {
     scoped_refptr<CookieMonster> cm(
         CreateMonsterForGC(CookieMonster::kMaxCookies * 2));
-    EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm).size());
-    SetCookie(cm, GURL("http://newdomain.com"), "b=2");
-    EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1, GetAllCookies(cm).size());
+    EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm.get()).size());
+    SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
+    EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1,
+              GetAllCookies(cm.get()).size());
   }
 
   // Now we explore a series of relationships between cookie last access
@@ -1957,12 +2100,12 @@ TEST_F(CookieMonsterTest, MAYBE_GarbageCollectionTriggers) {
         CreateMonsterFromStoreForGC(
             test_case->num_cookies, test_case->num_old_cookies,
             CookieMonster::kSafeFromGlobalPurgeDays * 2));
-    EXPECT_EQ(test_case->expected_initial_cookies, GetAllCookies(cm).size())
-        << "For test case " << ci;
+    EXPECT_EQ(test_case->expected_initial_cookies,
+              GetAllCookies(cm.get()).size()) << "For test case " << ci;
     // Will trigger GC
-    SetCookie(cm, GURL("http://newdomain.com"), "b=2");
-    EXPECT_EQ(test_case->expected_cookies_after_set, GetAllCookies(cm).size())
-        << "For test case " << ci;
+    SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
+    EXPECT_EQ(test_case->expected_cookies_after_set,
+              GetAllCookies(cm.get()).size()) << "For test case " << ci;
   }
 }
 
@@ -1974,23 +2117,25 @@ TEST_F(CookieMonsterTest, KeepExpiredCookies) {
 
   // Set a persistent cookie.
   ASSERT_TRUE(SetCookieWithOptions(
-      cm, url_google_,
+      cm.get(),
+      url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT",
       options));
 
   // Get the canonical cookie.
-  CookieList cookie_list = GetAllCookies(cm);
+  CookieList cookie_list = GetAllCookies(cm.get());
   ASSERT_EQ(1U, cookie_list.size());
 
   // Use a past expiry date to delete the cookie.
   ASSERT_TRUE(SetCookieWithOptions(
-      cm, url_google_,
+      cm.get(),
+      url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       options));
 
   // Check that the cookie with the past expiry date is still there.
   // GetAllCookies() also triggers garbage collection.
-  cookie_list = GetAllCookies(cm);
+  cookie_list = GetAllCookies(cm.get());
   ASSERT_EQ(1U, cookie_list.size());
   ASSERT_TRUE(cookie_list[0].IsExpired(Time::Now()));
 }
@@ -2063,7 +2208,7 @@ class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> {
 TEST_F(CookieMonsterTest, FlushStore) {
   scoped_refptr<CallbackCounter> counter(new CallbackCounter());
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   ASSERT_EQ(0, store->flush_count());
   ASSERT_EQ(0, counter->callback_count());
@@ -2083,7 +2228,7 @@ TEST_F(CookieMonsterTest, FlushStore) {
   ASSERT_EQ(1, counter->callback_count());
 
   // After initialization, FlushStore() should delegate to the store.
-  GetAllCookies(cm);  // Force init.
+  GetAllCookies(cm.get());  // Force init.
   cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
   base::MessageLoop::current()->RunUntilIdle();
 
@@ -2099,7 +2244,7 @@ TEST_F(CookieMonsterTest, FlushStore) {
 
   // If there's no backing store, FlushStore() is always a safe no-op.
   cm = new CookieMonster(NULL, NULL);
-  GetAllCookies(cm);  // Force init.
+  GetAllCookies(cm.get());  // Force init.
   cm->FlushStore(base::Closure());
   base::MessageLoop::current()->RunUntilIdle();
 
@@ -2123,17 +2268,24 @@ TEST_F(CookieMonsterTest, HistogramCheck) {
 
   scoped_ptr<base::HistogramSamples> samples1(
       expired_histogram->SnapshotSamples());
-  ASSERT_TRUE(SetCookieWithDetails(
-      cm, GURL("http://fake.a.url"), "a", "b", "a.url", "/",
-      base::Time::Now() + base::TimeDelta::FromMinutes(59),
-      false, false, COOKIE_PRIORITY_DEFAULT));
+  ASSERT_TRUE(
+      SetCookieWithDetails(cm.get(),
+                           GURL("http://fake.a.url"),
+                           "a",
+                           "b",
+                           "a.url",
+                           "/",
+                           base::Time::Now() + base::TimeDelta::FromMinutes(59),
+                           false,
+                           false,
+                           COOKIE_PRIORITY_DEFAULT));
 
   scoped_ptr<base::HistogramSamples> samples2(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount());
 
   // kValidCookieLine creates a session cookie.
-  ASSERT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
+  ASSERT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
 
   scoped_ptr<base::HistogramSamples> samples3(
       expired_histogram->SnapshotSamples());
@@ -2231,8 +2383,8 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  CookieList cookies = GetAllCookies(cm);
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  CookieList cookies = GetAllCookies(cm.get());
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("www.google.izzle", it->Domain());
@@ -2254,8 +2406,8 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_);
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("www.google.izzle", it->Domain());
@@ -2277,10 +2429,10 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
   CookieOptions options;
   CookieList cookies =
-      GetAllCookiesForURLWithOptions(cm, url_google_, options);
+      GetAllCookiesForURLWithOptions(cm.get(), url_google_, options);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("www.google.izzle", it->Domain());
@@ -2302,10 +2454,16 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_foo_,
-      "A", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_foo_,
+                                   "A",
+                                   "B",
+                                   std::string(),
+                                   "/foo",
+                                   base::Time(),
+                                   false,
+                                   false,
+                                   COOKIE_PRIORITY_DEFAULT));
   BoolResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
@@ -2320,10 +2478,11 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   Time now = Time::Now();
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
-                                       Time()));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_EQ(
+      1,
+      DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), Time()));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   IntResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
@@ -2338,9 +2497,9 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  EXPECT_EQ(1, DeleteAllForHost(cm, url_google_));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_EQ(1, DeleteAllForHost(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   IntResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
@@ -2354,14 +2513,14 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  CookieList cookies = GetAllCookies(cm);
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  CookieList cookies = GetAllCookies(cm.get());
   CookieList::iterator it = cookies.begin();
-  EXPECT_TRUE(DeleteCanonicalCookie(cm, *it));
+  EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   BoolResultCookieCallback callback(&other_thread_);
-  cookies = GetAllCookies(cm);
+  cookies = GetAllCookies(cm.get());
   it = cookies.begin();
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
@@ -2386,12 +2545,12 @@ TEST_F(CookieMonsterTest, InvalidExpiryTime) {
 TEST_F(CookieMonsterTest, PersistSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   cm->SetPersistSessionCookies(true);
 
   // All cookies set with SetCookie are session cookies.
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
 
   // The cookie was written to the backing store.
   EXPECT_EQ(1u, store->commands().size());
@@ -2400,8 +2559,8 @@ TEST_F(CookieMonsterTest, PersistSessionCookies) {
   EXPECT_EQ("B", store->commands()[0].cookie.Value());
 
   // Modify the cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=C"));
-  EXPECT_EQ("A=C", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=C"));
+  EXPECT_EQ("A=C", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ("A", store->commands()[1].cookie.Name());
@@ -2411,8 +2570,8 @@ TEST_F(CookieMonsterTest, PersistSessionCookies) {
   EXPECT_EQ("C", store->commands()[2].cookie.Value());
 
   // Delete the cookie.
-  DeleteCookie(cm, url_google_, "A");
-  EXPECT_EQ("", GetCookies(cm, url_google_));
+  DeleteCookie(cm.get(), url_google_, "A");
+  EXPECT_EQ("", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ("A", store->commands()[3].cookie.Name());
@@ -2423,38 +2582,38 @@ TEST_F(CookieMonsterTest, PersistSessionCookies) {
 TEST_F(CookieMonsterTest, PersisentCookieStorageTest) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), url_google_, "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   // Remove it.
-  EXPECT_TRUE(SetCookie(cm, url_google_,"A=B; max-age=0"));
-  this->MatchCookieLines(std::string(), GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B; max-age=0"));
+  this->MatchCookieLines(std::string(), GetCookies(cm.get(), url_google_));
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), url_google_, "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   // Overwrite it.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
-  this->MatchCookieLines("A=Foo", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), url_google_, "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  this->MatchCookieLines("A=Foo", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(5u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
-  EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar"));
-  this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=Bar"));
+  this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(5u, store->commands().size());
 }
 
diff --git a/net/cookies/cookie_store_test_helpers.cc b/net/cookies/cookie_store_test_helpers.cc
index dfd1abc..114e42d 100644
--- a/net/cookies/cookie_store_test_helpers.cc
+++ b/net/cookies/cookie_store_test_helpers.cc
@@ -118,7 +118,7 @@ void DelayedCookieMonster::DeleteSessionCookiesAsync(const DeleteCallback&) {
 }
 
 CookieMonster* DelayedCookieMonster::GetCookieMonster() {
-  return cookie_monster_;
+  return cookie_monster_.get();
 }
 
 }  // namespace net
diff --git a/net/cookies/cookie_store_unittest.h b/net/cookies/cookie_store_unittest.h
index 1ff1d29..a4a05e4 100644
--- a/net/cookies/cookie_store_unittest.h
+++ b/net/cookies/cookie_store_unittest.h
@@ -252,52 +252,55 @@ TYPED_TEST_P(CookieStoreTest, TypeTest) {
 
 TYPED_TEST_P(CookieStoreTest, DomainTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              "C=D; domain=.google.izzle"));
-  this->MatchCookieLines("A=B; C=D", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), this->url_google_, "C=D; domain=.google.izzle"));
+  this->MatchCookieLines("A=B; C=D",
+                         this->GetCookies(cs.get(), this->url_google_));
 
   // Verify that A=B was set as a host cookie rather than a domain
   // cookie -- should not be accessible from a sub sub-domain.
-  this->MatchCookieLines("C=D",
-      this->GetCookies(cs, GURL("http://foo.www.google.izzle")));
+  this->MatchCookieLines(
+      "C=D", this->GetCookies(cs.get(), GURL("http://foo.www.google.izzle")));
 
   // Test and make sure we find domain cookies on the same domain.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              "E=F; domain=.www.google.izzle"));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), this->url_google_, "E=F; domain=.www.google.izzle"));
   this->MatchCookieLines("A=B; C=D; E=F",
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 
   // Test setting a domain= that doesn't start w/ a dot, should
   // treat it as a domain cookie, as if there was a pre-pended dot.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              "G=H; domain=www.google.izzle"));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), this->url_google_, "G=H; domain=www.google.izzle"));
   this->MatchCookieLines("A=B; C=D; E=F; G=H",
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 
   // Test domain enforcement, should fail on a sub-domain or something too deep.
-  EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "I=J; domain=.izzle"));
+  EXPECT_FALSE(
+      this->SetCookie(cs.get(), this->url_google_, "I=J; domain=.izzle"));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, GURL("http://a.izzle")));
+                         this->GetCookies(cs.get(), GURL("http://a.izzle")));
   EXPECT_FALSE(this->SetCookie(
-      cs, this->url_google_, "K=L; domain=.bla.www.google.izzle"));
-  this->MatchCookieLines("C=D; E=F; G=H",
-      this->GetCookies(cs, GURL("http://bla.www.google.izzle")));
+      cs.get(), this->url_google_, "K=L; domain=.bla.www.google.izzle"));
+  this->MatchCookieLines(
+      "C=D; E=F; G=H",
+      this->GetCookies(cs.get(), GURL("http://bla.www.google.izzle")));
   this->MatchCookieLines("A=B; C=D; E=F; G=H",
-      this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 }
 
 // FireFox recognizes domains containing trailing periods as valid.
 // IE and Safari do not. Assert the expected policy here.
 TYPED_TEST_P(CookieStoreTest, DomainWithTrailingDotTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  EXPECT_FALSE(this->SetCookie(cs, this->url_google_,
-                               "a=1; domain=.www.google.com."));
-  EXPECT_FALSE(this->SetCookie(cs, this->url_google_,
-                               "b=2; domain=.www.google.com.."));
+  EXPECT_FALSE(this->SetCookie(
+      cs.get(), this->url_google_, "a=1; domain=.www.google.com."));
+  EXPECT_FALSE(this->SetCookie(
+      cs.get(), this->url_google_, "b=2; domain=.www.google.com.."));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 }
 
 // Test that cookies can bet set on higher level domains.
@@ -309,22 +312,23 @@ TYPED_TEST_P(CookieStoreTest, ValidSubdomainTest) {
   GURL url_cd("http://c.d.com");
   GURL url_d("http://d.com");
 
-  EXPECT_TRUE(this->SetCookie(cs, url_abcd, "a=1; domain=.a.b.c.d.com"));
-  EXPECT_TRUE(this->SetCookie(cs, url_abcd, "b=2; domain=.b.c.d.com"));
-  EXPECT_TRUE(this->SetCookie(cs, url_abcd, "c=3; domain=.c.d.com"));
-  EXPECT_TRUE(this->SetCookie(cs, url_abcd, "d=4; domain=.d.com"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "a=1; domain=.a.b.c.d.com"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "b=2; domain=.b.c.d.com"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "c=3; domain=.c.d.com"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "d=4; domain=.d.com"));
 
-  this->MatchCookieLines("a=1; b=2; c=3; d=4", this->GetCookies(cs, url_abcd));
-  this->MatchCookieLines("b=2; c=3; d=4", this->GetCookies(cs, url_bcd));
-  this->MatchCookieLines("c=3; d=4", this->GetCookies(cs, url_cd));
-  this->MatchCookieLines("d=4", this->GetCookies(cs, url_d));
+  this->MatchCookieLines("a=1; b=2; c=3; d=4",
+                         this->GetCookies(cs.get(), url_abcd));
+  this->MatchCookieLines("b=2; c=3; d=4", this->GetCookies(cs.get(), url_bcd));
+  this->MatchCookieLines("c=3; d=4", this->GetCookies(cs.get(), url_cd));
+  this->MatchCookieLines("d=4", this->GetCookies(cs.get(), url_d));
 
   // Check that the same cookie can exist on different sub-domains.
-  EXPECT_TRUE(this->SetCookie(cs, url_bcd, "X=bcd; domain=.b.c.d.com"));
-  EXPECT_TRUE(this->SetCookie(cs, url_bcd, "X=cd; domain=.c.d.com"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url_bcd, "X=bcd; domain=.b.c.d.com"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url_bcd, "X=cd; domain=.c.d.com"));
   this->MatchCookieLines("b=2; c=3; d=4; X=bcd; X=cd",
-                         this->GetCookies(cs, url_bcd));
-  this->MatchCookieLines("c=3; d=4; X=cd", this->GetCookies(cs, url_cd));
+                         this->GetCookies(cs.get(), url_bcd));
+  this->MatchCookieLines("c=3; d=4; X=cd", this->GetCookies(cs.get(), url_cd));
 }
 
 // Test that setting a cookie which specifies an invalid domain has
@@ -337,41 +341,45 @@ TYPED_TEST_P(CookieStoreTest, InvalidDomainTest) {
     GURL url_foobar("http://foo.bar.com");
 
     // More specific sub-domain than allowed.
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "a=1; domain=.yo.foo.bar.com"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "a=1; domain=.yo.foo.bar.com"));
 
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "b=2; domain=.foo.com"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "c=3; domain=.bar.foo.com"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "b=2; domain=.foo.com"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "c=3; domain=.bar.foo.com"));
 
     // Different TLD, but the rest is a substring.
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "d=4; domain=.foo.bar.com.net"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "d=4; domain=.foo.bar.com.net"));
 
     // A substring that isn't really a parent domain.
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "e=5; domain=ar.com"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "e=5; domain=ar.com"));
 
     // Completely invalid domains:
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "f=6; domain=."));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "g=7; domain=/"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "h=8; domain=http://foo.bar.com"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "i=9; domain=..foo.bar.com"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar, "j=10; domain=..bar.com"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "f=6; domain=."));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "g=7; domain=/"));
+    EXPECT_FALSE(this->SetCookie(
+        cs.get(), url_foobar, "h=8; domain=http://foo.bar.com"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "i=9; domain=..foo.bar.com"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "j=10; domain=..bar.com"));
 
     // Make sure there isn't something quirky in the domain canonicalization
     // that supports full URL semantics.
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "k=11; domain=.foo.bar.com?blah"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "l=12; domain=.foo.bar.com/blah"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "m=13; domain=.foo.bar.com:80"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "n=14; domain=.foo.bar.com:"));
-    EXPECT_FALSE(this->SetCookie(cs, url_foobar,
-                                 "o=15; domain=.foo.bar.com#sup"));
-
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_foobar));
+    EXPECT_FALSE(this->SetCookie(
+        cs.get(), url_foobar, "k=11; domain=.foo.bar.com?blah"));
+    EXPECT_FALSE(this->SetCookie(
+        cs.get(), url_foobar, "l=12; domain=.foo.bar.com/blah"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "m=13; domain=.foo.bar.com:80"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "n=14; domain=.foo.bar.com:"));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foobar, "o=15; domain=.foo.bar.com#sup"));
+
+    this->MatchCookieLines(std::string(),
+                           this->GetCookies(cs.get(), url_foobar));
   }
 
   {
@@ -380,9 +388,10 @@ TYPED_TEST_P(CookieStoreTest, InvalidDomainTest) {
     // hosts below have the same domain + registry.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url_foocom("http://foo.com.com");
-    EXPECT_FALSE(this->SetCookie(cs, url_foocom,
-                                 "a=1; domain=.foo.com.com.com"));
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_foocom));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_foocom, "a=1; domain=.foo.com.com.com"));
+    this->MatchCookieLines(std::string(),
+                           this->GetCookies(cs.get(), url_foocom));
   }
 }
 
@@ -394,21 +403,23 @@ TYPED_TEST_P(CookieStoreTest, DomainWithoutLeadingDotTest) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url_hosted("http://manage.hosted.filefront.com");
     GURL url_filefront("http://www.filefront.com");
-    EXPECT_TRUE(this->SetCookie(cs, url_hosted,
-                                "sawAd=1; domain=filefront.com"));
-    this->MatchCookieLines("sawAd=1", this->GetCookies(cs, url_hosted));
-    this->MatchCookieLines("sawAd=1", this->GetCookies(cs, url_filefront));
+    EXPECT_TRUE(
+        this->SetCookie(cs.get(), url_hosted, "sawAd=1; domain=filefront.com"));
+    this->MatchCookieLines("sawAd=1", this->GetCookies(cs.get(), url_hosted));
+    this->MatchCookieLines("sawAd=1",
+                           this->GetCookies(cs.get(), url_filefront));
   }
 
   {  // Even when the domains match exactly, don't consider it host cookie.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://www.google.com");
-    EXPECT_TRUE(this->SetCookie(cs, url, "a=1; domain=www.google.com"));
-    this->MatchCookieLines("a=1", this->GetCookies(cs, url));
-    this->MatchCookieLines("a=1",
-        this->GetCookies(cs, GURL("http://sub.www.google.com")));
+    EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1; domain=www.google.com"));
+    this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url));
+    this->MatchCookieLines(
+        "a=1", this->GetCookies(cs.get(), GURL("http://sub.www.google.com")));
     this->MatchCookieLines(
-        std::string(), this->GetCookies(cs, GURL("http://something-else.com")));
+        std::string(),
+        this->GetCookies(cs.get(), GURL("http://something-else.com")));
   }
 }
 
@@ -417,30 +428,30 @@ TYPED_TEST_P(CookieStoreTest, DomainWithoutLeadingDotTest) {
 TYPED_TEST_P(CookieStoreTest, CaseInsensitiveDomainTest) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
   GURL url("http://www.google.com");
-  EXPECT_TRUE(this->SetCookie(cs, url, "a=1; domain=.GOOGLE.COM"));
-  EXPECT_TRUE(this->SetCookie(cs, url, "b=2; domain=.wWw.gOOgLE.coM"));
-  this->MatchCookieLines("a=1; b=2", this->GetCookies(cs, url));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1; domain=.GOOGLE.COM"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url, "b=2; domain=.wWw.gOOgLE.coM"));
+  this->MatchCookieLines("a=1; b=2", this->GetCookies(cs.get(), url));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestIpAddress) {
   GURL url_ip("http://1.2.3.4/weee");
   {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
-    EXPECT_TRUE(this->SetCookie(cs, url_ip, kValidCookieLine));
-    this->MatchCookieLines("A=B", this->GetCookies(cs, url_ip));
+    EXPECT_TRUE(this->SetCookie(cs.get(), url_ip, kValidCookieLine));
+    this->MatchCookieLines("A=B", this->GetCookies(cs.get(), url_ip));
   }
 
   {  // IP addresses should not be able to set domain cookies.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
-    EXPECT_FALSE(this->SetCookie(cs, url_ip, "b=2; domain=.1.2.3.4"));
-    EXPECT_FALSE(this->SetCookie(cs, url_ip, "c=3; domain=.3.4"));
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_ip));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_ip, "b=2; domain=.1.2.3.4"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_ip, "c=3; domain=.3.4"));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url_ip));
     // It should be allowed to set a cookie if domain= matches the IP address
     // exactly.  This matches IE/Firefox, even though it seems a bit wrong.
-    EXPECT_FALSE(this->SetCookie(cs, url_ip, "b=2; domain=1.2.3.3"));
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_ip));
-    EXPECT_TRUE(this->SetCookie(cs, url_ip, "b=2; domain=1.2.3.4"));
-    this->MatchCookieLines("b=2", this->GetCookies(cs, url_ip));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url_ip, "b=2; domain=1.2.3.3"));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url_ip));
+    EXPECT_TRUE(this->SetCookie(cs.get(), url_ip, "b=2; domain=1.2.3.4"));
+    this->MatchCookieLines("b=2", this->GetCookies(cs.get(), url_ip));
   }
 }
 
@@ -450,18 +461,18 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://com/");
     // Allow setting on "com", (but only as a host cookie).
-    EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.com"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "c=3; domain=com"));
-    this->MatchCookieLines("a=1", this->GetCookies(cs, url));
+    EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=.com"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "c=3; domain=com"));
+    this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url));
     // Make sure it doesn't show up for a normal .com, it should be a host
     // not a domain cookie.
     this->MatchCookieLines(
         std::string(),
-        this->GetCookies(cs, GURL("http://hopefully-no-cookies.com/")));
+        this->GetCookies(cs.get(), GURL("http://hopefully-no-cookies.com/")));
     if (TypeParam::supports_non_dotted_domains) {
       this->MatchCookieLines(std::string(),
-                             this->GetCookies(cs, GURL("http://.com/")));
+                             this->GetCookies(cs.get(), GURL("http://.com/")));
     }
   }
 
@@ -470,52 +481,54 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://com./index.html");
     if (TypeParam::supports_trailing_dots) {
-      EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
-      this->MatchCookieLines("a=1", this->GetCookies(cs, url));
+      EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1"));
+      this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url));
       this->MatchCookieLines(
           std::string(),
-          this->GetCookies(cs, GURL("http://hopefully-no-cookies.com./")));
+          this->GetCookies(cs.get(),
+                           GURL("http://hopefully-no-cookies.com./")));
     } else {
-      EXPECT_FALSE(this->SetCookie(cs, url, "a=1"));
+      EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1"));
     }
   }
 
   {  // Should not be able to set host cookie from a subdomain.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://a.b");
-    EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.b"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=b"));
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1; domain=.b"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=b"));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url));
   }
 
   {  // Same test as above, but explicitly on a known TLD (com).
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://google.com");
-    EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.com"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=com"));
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1; domain=.com"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=com"));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url));
   }
 
   {  // Make sure can't set cookie on TLD which is dotted.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://google.co.uk");
-    EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.co.uk"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.uk"));
-    this->MatchCookieLines(std::string(), this->GetCookies(cs, url));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1; domain=.co.uk"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=.uk"));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url));
     this->MatchCookieLines(
         std::string(),
-        this->GetCookies(cs, GURL("http://something-else.co.uk")));
+        this->GetCookies(cs.get(), GURL("http://something-else.co.uk")));
     this->MatchCookieLines(
-        std::string(), this->GetCookies(cs, GURL("http://something-else.uk")));
+        std::string(),
+        this->GetCookies(cs.get(), GURL("http://something-else.uk")));
   }
 
   {  // Intranet URLs should only be able to set host cookies.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://b");
-    EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.b"));
-    EXPECT_FALSE(this->SetCookie(cs, url, "c=3; domain=b"));
-    this->MatchCookieLines("a=1", this->GetCookies(cs, url));
+    EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=.b"));
+    EXPECT_FALSE(this->SetCookie(cs.get(), url, "c=3; domain=b"));
+    this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url));
   }
 }
 
@@ -525,28 +538,31 @@ TYPED_TEST_P(CookieStoreTest, TestHostEndsWithDot) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   GURL url("http://www.google.com");
   GURL url_with_dot("http://www.google.com.");
-  EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
-  this->MatchCookieLines("a=1", this->GetCookies(cs, url));
+  EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1"));
+  this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url));
 
   if (TypeParam::supports_trailing_dots) {
     // Do not share cookie space with the dot version of domain.
     // Note: this is not what FireFox does, but it _is_ what IE+Safari do.
-    EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.www.google.com."));
-    this->MatchCookieLines("a=1", this->GetCookies(cs, url));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url, "b=2; domain=.www.google.com."));
+    this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url));
 
-    EXPECT_TRUE(this->SetCookie(cs, url_with_dot, "b=2; domain=.google.com."));
-    this->MatchCookieLines("b=2", this->GetCookies(cs, url_with_dot));
+    EXPECT_TRUE(
+        this->SetCookie(cs.get(), url_with_dot, "b=2; domain=.google.com."));
+    this->MatchCookieLines("b=2", this->GetCookies(cs.get(), url_with_dot));
   } else {
-    EXPECT_TRUE(this->SetCookie(cs, url, "b=2; domain=.www.google.com."));
-    EXPECT_FALSE(this->SetCookie(cs, url_with_dot, "b=2; domain=.google.com."));
+    EXPECT_TRUE(this->SetCookie(cs.get(), url, "b=2; domain=.www.google.com."));
+    EXPECT_FALSE(
+        this->SetCookie(cs.get(), url_with_dot, "b=2; domain=.google.com."));
   }
 
   // Make sure there weren't any side effects.
   this->MatchCookieLines(
       std::string(),
-      this->GetCookies(cs, GURL("http://hopefully-no-cookies.com/")));
+      this->GetCookies(cs.get(), GURL("http://hopefully-no-cookies.com/")));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, GURL("http://.com/")));
+                         this->GetCookies(cs.get(), GURL("http://.com/")));
 }
 
 TYPED_TEST_P(CookieStoreTest, InvalidScheme) {
@@ -554,7 +570,7 @@ TYPED_TEST_P(CookieStoreTest, InvalidScheme) {
     return;
 
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  EXPECT_FALSE(this->SetCookie(cs, GURL(kUrlFtp), kValidCookieLine));
+  EXPECT_FALSE(this->SetCookie(cs.get(), GURL(kUrlFtp), kValidCookieLine));
 }
 
 TYPED_TEST_P(CookieStoreTest, InvalidScheme_Read) {
@@ -562,28 +578,34 @@ TYPED_TEST_P(CookieStoreTest, InvalidScheme_Read) {
     return;
 
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  EXPECT_TRUE(this->SetCookie(cs, GURL(kUrlGoogle), kValidDomainCookieLine));
-  this->MatchCookieLines(std::string(), this->GetCookies(cs, GURL(kUrlFtp)));
+  EXPECT_TRUE(
+      this->SetCookie(cs.get(), GURL(kUrlGoogle), kValidDomainCookieLine));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs.get(), GURL(kUrlFtp)));
 }
 
 TYPED_TEST_P(CookieStoreTest, PathTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   std::string url("http://www.google.izzle");
-  EXPECT_TRUE(this->SetCookie(cs, GURL(url), "A=B; path=/wee"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee")));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee/")));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee/war")));
+  EXPECT_TRUE(this->SetCookie(cs.get(), GURL(url), "A=B; path=/wee"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), GURL(url + "/wee")));
+  this->MatchCookieLines("A=B",
+                         this->GetCookies(cs.get(), GURL(url + "/wee/")));
   this->MatchCookieLines("A=B",
-      this->GetCookies(cs, GURL(url + "/wee/war/more/more")));
+                         this->GetCookies(cs.get(), GURL(url + "/wee/war")));
+  this->MatchCookieLines(
+      "A=B", this->GetCookies(cs.get(), GURL(url + "/wee/war/more/more")));
   if (!TypeParam::has_path_prefix_bug)
     this->MatchCookieLines(std::string(),
-                           this->GetCookies(cs, GURL(url + "/weehee")));
-  this->MatchCookieLines(std::string(), this->GetCookies(cs, GURL(url + "/")));
+                           this->GetCookies(cs.get(), GURL(url + "/weehee")));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs.get(), GURL(url + "/")));
 
   // If we add a 0 length path, it should default to /
-  EXPECT_TRUE(this->SetCookie(cs, GURL(url), "A=C; path="));
-  this->MatchCookieLines("A=B; A=C", this->GetCookies(cs, GURL(url + "/wee")));
-  this->MatchCookieLines("A=C", this->GetCookies(cs, GURL(url + "/")));
+  EXPECT_TRUE(this->SetCookie(cs.get(), GURL(url), "A=C; path="));
+  this->MatchCookieLines("A=B; A=C",
+                         this->GetCookies(cs.get(), GURL(url + "/wee")));
+  this->MatchCookieLines("A=C", this->GetCookies(cs.get(), GURL(url + "/")));
 }
 
 TYPED_TEST_P(CookieStoreTest, EmptyExpires) {
@@ -596,19 +618,19 @@ TYPED_TEST_P(CookieStoreTest, EmptyExpires) {
       "ACSTM=20130308043820420042; path=/; domain=ipdl.inpit.go.jp; Expires=";
   std::string cookie_line = "ACSTM=20130308043820420042";
 
-  this->SetCookieWithOptions( cs, url, set_cookie_line, options);
+  this->SetCookieWithOptions(cs.get(), url, set_cookie_line, options);
   this->MatchCookieLines(cookie_line,
-                         this->GetCookiesWithOptions(cs, url, options));
+                         this->GetCookiesWithOptions(cs.get(), url, options));
 
   options.set_server_time(base::Time::Now() - base::TimeDelta::FromHours(1));
-  this->SetCookieWithOptions( cs, url, set_cookie_line, options);
+  this->SetCookieWithOptions(cs.get(), url, set_cookie_line, options);
   this->MatchCookieLines(cookie_line,
-                         this->GetCookiesWithOptions(cs, url, options));
+                         this->GetCookiesWithOptions(cs.get(), url, options));
 
   options.set_server_time(base::Time::Now() + base::TimeDelta::FromHours(1));
-  this->SetCookieWithOptions( cs, url, set_cookie_line, options);
+  this->SetCookieWithOptions(cs.get(), url, set_cookie_line, options);
   this->MatchCookieLines(cookie_line,
-                         this->GetCookiesWithOptions(cs, url, options));
+                         this->GetCookiesWithOptions(cs.get(), url, options));
 }
 
 TYPED_TEST_P(CookieStoreTest, HttpOnlyTest) {
@@ -620,107 +642,117 @@ TYPED_TEST_P(CookieStoreTest, HttpOnlyTest) {
   options.set_include_httponly();
 
   // Create a httponly cookie.
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B; httponly",
-                                         options));
+  EXPECT_TRUE(this->SetCookieWithOptions(
+      cs.get(), this->url_google_, "A=B; httponly", options));
 
   // Check httponly read protection.
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
   this->MatchCookieLines(
-      "A=B", this->GetCookiesWithOptions(cs, this->url_google_, options));
+      "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options));
 
   // Check httponly overwrite protection.
-  EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "A=C"));
+  EXPECT_FALSE(this->SetCookie(cs.get(), this->url_google_, "A=C"));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
   this->MatchCookieLines(
-      "A=B", this->GetCookiesWithOptions(cs, this->url_google_, options));
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=C",
-                                         options));
-  this->MatchCookieLines("A=C", this->GetCookies(cs, this->url_google_));
+      "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options));
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(), this->url_google_, "A=C", options));
+  this->MatchCookieLines("A=C", this->GetCookies(cs.get(), this->url_google_));
 
   // Check httponly create protection.
-  EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "B=A; httponly"));
-  this->MatchCookieLines("A=C",
-      this->GetCookiesWithOptions(cs, this->url_google_, options));
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "B=A; httponly",
-                                         options));
-  this->MatchCookieLines("A=C; B=A",
-      this->GetCookiesWithOptions(cs, this->url_google_, options));
-  this->MatchCookieLines("A=C", this->GetCookies(cs, this->url_google_));
+  EXPECT_FALSE(this->SetCookie(cs.get(), this->url_google_, "B=A; httponly"));
+  this->MatchCookieLines(
+      "A=C", this->GetCookiesWithOptions(cs.get(), this->url_google_, options));
+  EXPECT_TRUE(this->SetCookieWithOptions(
+      cs.get(), this->url_google_, "B=A; httponly", options));
+  this->MatchCookieLines(
+      "A=C; B=A",
+      this->GetCookiesWithOptions(cs.get(), this->url_google_, options));
+  this->MatchCookieLines("A=C", this->GetCookies(cs.get(), this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
   // Create a session cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, kValidCookieLine));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, kValidCookieLine));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Delete it via Max-Age.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              this->url_google_,
                               std::string(kValidCookieLine) + "; max-age=0"));
-  this->MatchCookieLineWithTimeout(cs, this->url_google_, std::string());
+  this->MatchCookieLineWithTimeout(cs.get(), this->url_google_, std::string());
 
   // Create a session cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, kValidCookieLine));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, kValidCookieLine));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Delete it via Expires.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              this->url_google_,
                               std::string(kValidCookieLine) +
-                              "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
+                                  "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 
   // Create a persistent cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              std::string(kValidCookieLine) +
-                              "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(),
+      this->url_google_,
+      std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
 
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Delete it via Max-Age.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              this->url_google_,
                               std::string(kValidCookieLine) + "; max-age=0"));
-  this->MatchCookieLineWithTimeout(cs, this->url_google_, std::string());
+  this->MatchCookieLineWithTimeout(cs.get(), this->url_google_, std::string());
 
   // Create a persistent cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              std::string(kValidCookieLine) +
-                              "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(),
+      this->url_google_,
+      std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Delete it via Expires.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              this->url_google_,
                               std::string(kValidCookieLine) +
-                              "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
+                                  "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 
   // Create a persistent cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              std::string(kValidCookieLine) +
-                              "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(),
+      this->url_google_,
+      std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Check that it is not deleted with significant enough clock skew.
   base::Time server_time;
   EXPECT_TRUE(base::Time::FromString("Sun, 17-Apr-1977 22:50:13 GMT",
                                      &server_time));
   EXPECT_TRUE(this->SetCookieWithServerTime(
-      cs, this->url_google_,
-      std::string(kValidCookieLine) +
-      "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
+      cs.get(),
+      this->url_google_,
+      std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       server_time));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
 
   // Create a persistent cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              std::string(kValidCookieLine) +
-                              "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(),
+      this->url_google_,
+      std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Delete it via Expires, with a unix epoch of 0.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              this->url_google_,
                               std::string(kValidCookieLine) +
-                              "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
+                                  "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) {
@@ -735,58 +767,63 @@ TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) {
                                 base::TimeDelta::FromDays(30);
 
   // Add a cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
-   // Check that the cookie is in the store.
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
+  // Check that the cookie is in the store.
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
 
   // Remove cookies in empty intervals.
-  EXPECT_EQ(0, this->DeleteCreatedBetween(cs, last_month, last_minute));
-  EXPECT_EQ(0, this->DeleteCreatedBetween(cs, next_minute, next_month));
+  EXPECT_EQ(0, this->DeleteCreatedBetween(cs.get(), last_month, last_minute));
+  EXPECT_EQ(0, this->DeleteCreatedBetween(cs.get(), next_minute, next_month));
   // Check that the cookie is still there.
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
 
   // Remove the cookie with an interval defined by two dates.
-  EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, next_minute));
+  EXPECT_EQ(1, this->DeleteCreatedBetween(cs.get(), last_minute, next_minute));
   // Check that the cookie disappeared.
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 
   // Add another cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "C=D"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "C=D"));
   // Check that the cookie is in the store.
-  this->MatchCookieLines("C=D", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines("C=D", this->GetCookies(cs.get(), this->url_google_));
 
   // Remove the cookie with a null ending time.
-  EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, base::Time()));
+  EXPECT_EQ(1, this->DeleteCreatedBetween(cs.get(), last_minute, base::Time()));
   // Check that the cookie disappeared.
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestSecure) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_secure_));
+    EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
+    this->MatchCookieLines("A=B",
+                           this->GetCookies(cs.get(), this->url_google_));
+    this->MatchCookieLines(
+        "A=B", this->GetCookies(cs.get(), this->url_google_secure_));
 
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "A=B; secure"));
+  EXPECT_TRUE(
+      this->SetCookie(cs.get(), this->url_google_secure_, "A=B; secure"));
   // The secure should overwrite the non-secure.
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_secure_));
+                         this->GetCookies(cs.get(), this->url_google_));
+  this->MatchCookieLines("A=B",
+                         this->GetCookies(cs.get(), this->url_google_secure_));
 
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "D=E; secure"));
+  EXPECT_TRUE(
+      this->SetCookie(cs.get(), this->url_google_secure_, "D=E; secure"));
   this->MatchCookieLines(std::string(),
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
   this->MatchCookieLines("A=B; D=E",
-                         this->GetCookies(cs, this->url_google_secure_));
+                         this->GetCookies(cs.get(), this->url_google_secure_));
 
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "A=B"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_secure_, "A=B"));
   // The non-secure should overwrite the secure.
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   this->MatchCookieLines("D=E; A=B",
-                         this->GetCookies(cs, this->url_google_secure_));
+                         this->GetCookies(cs.get(), this->url_google_secure_));
 }
 
 static const int kLastAccessThresholdMilliseconds = 200;
@@ -797,15 +834,15 @@ TYPED_TEST_P(CookieStoreTest, NetUtilCookieTest) {
 
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
-  EXPECT_TRUE(this->SetCookie(cs, test_url, "foo=bar"));
-  std::string value = this->GetCookies(cs, test_url);
+  EXPECT_TRUE(this->SetCookie(cs.get(), test_url, "foo=bar"));
+  std::string value = this->GetCookies(cs.get(), test_url);
   this->MatchCookieLines("foo=bar", value);
 
   // test that we can retrieve all cookies:
-  EXPECT_TRUE(this->SetCookie(cs, test_url, "x=1"));
-  EXPECT_TRUE(this->SetCookie(cs, test_url, "y=2"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), test_url, "x=1"));
+  EXPECT_TRUE(this->SetCookie(cs.get(), test_url, "y=2"));
 
-  std::string result = this->GetCookies(cs, test_url);
+  std::string result = this->GetCookies(cs.get(), test_url);
   EXPECT_FALSE(result.empty());
   EXPECT_NE(result.find("x=1"), std::string::npos) << result;
   EXPECT_NE(result.find("y=2"), std::string::npos) << result;
@@ -817,54 +854,62 @@ TYPED_TEST_P(CookieStoreTest, OverwritePersistentCookie) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
   // Insert a cookie "a" for path "/path1"
-  EXPECT_TRUE(
-      this->SetCookie(cs, url_google, "a=val1; path=/path1; "
-                      "expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              url_google,
+                              "a=val1; path=/path1; "
+                              "expires=Mon, 18-Apr-22 22:50:13 GMT"));
 
   // Insert a cookie "b" for path "/path1"
-  EXPECT_TRUE(
-      this->SetCookie(cs, url_google, "b=val1; path=/path1; "
-                      "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              url_google,
+                              "b=val1; path=/path1; "
+                              "expires=Mon, 18-Apr-22 22:50:14 GMT"));
 
   // Insert a cookie "b" for path "/path1", that is httponly. This should
   // overwrite the non-http-only version.
   CookieOptions allow_httponly;
   allow_httponly.set_include_httponly();
-  EXPECT_TRUE(
-    this->SetCookieWithOptions(cs, url_google,
-                               "b=val2; path=/path1; httponly; "
-                               "expires=Mon, 18-Apr-22 22:50:14 GMT",
-                               allow_httponly));
+  EXPECT_TRUE(this->SetCookieWithOptions(cs.get(),
+                                         url_google,
+                                         "b=val2; path=/path1; httponly; "
+                                         "expires=Mon, 18-Apr-22 22:50:14 GMT",
+                                         allow_httponly));
 
   // Insert a cookie "a" for path "/path1". This should overwrite.
-  EXPECT_TRUE(this->SetCookie(cs, url_google,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              url_google,
                               "a=val33; path=/path1; "
                               "expires=Mon, 18-Apr-22 22:50:14 GMT"));
 
   // Insert a cookie "a" for path "/path2". This should NOT overwrite
   // cookie "a", since the path is different.
-  EXPECT_TRUE(this->SetCookie(cs, url_google,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              url_google,
                               "a=val9; path=/path2; "
                               "expires=Mon, 18-Apr-22 22:50:14 GMT"));
 
   // Insert a cookie "a" for path "/path1", but this time for "chromium.org".
   // Although the name and path match, the hostnames do not, so shouldn't
   // overwrite.
-  EXPECT_TRUE(this->SetCookie(cs, url_chromium,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              url_chromium,
                               "a=val99; path=/path1; "
                               "expires=Mon, 18-Apr-22 22:50:14 GMT"));
 
   if (TypeParam::supports_http_only) {
-    this->MatchCookieLines("a=val33",
-        this->GetCookies(cs, GURL("http://www.google.com/path1")));
+    this->MatchCookieLines(
+        "a=val33",
+        this->GetCookies(cs.get(), GURL("http://www.google.com/path1")));
   } else {
-    this->MatchCookieLines("a=val33; b=val2",
-        this->GetCookies(cs, GURL("http://www.google.com/path1")));
+    this->MatchCookieLines(
+        "a=val33; b=val2",
+        this->GetCookies(cs.get(), GURL("http://www.google.com/path1")));
   }
-  this->MatchCookieLines("a=val9",
-      this->GetCookies(cs, GURL("http://www.google.com/path2")));
-  this->MatchCookieLines("a=val99",
-      this->GetCookies(cs, GURL("http://chromium.org/path1")));
+  this->MatchCookieLines(
+      "a=val9",
+      this->GetCookies(cs.get(), GURL("http://www.google.com/path2")));
+  this->MatchCookieLines(
+      "a=val99", this->GetCookies(cs.get(), GURL("http://chromium.org/path1")));
 }
 
 TYPED_TEST_P(CookieStoreTest, CookieOrdering) {
@@ -872,42 +917,45 @@ TYPED_TEST_P(CookieStoreTest, CookieOrdering) {
   // the right order.
   // Cookies should be sorted by path length and creation time, as per RFC6265.
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  EXPECT_TRUE(this->SetCookie(cs, GURL("http://d.c.b.a.google.com/aa/x.html"),
-                              "c=1"));
-  EXPECT_TRUE(this->SetCookie(cs, GURL("http://b.a.google.com/aa/bb/cc/x.html"),
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1"));
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              GURL("http://b.a.google.com/aa/bb/cc/x.html"),
                               "d=1; domain=b.a.google.com"));
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
       TypeParam::creation_time_granularity_in_ms));
-  EXPECT_TRUE(this->SetCookie(cs, GURL("http://b.a.google.com/aa/bb/cc/x.html"),
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              GURL("http://b.a.google.com/aa/bb/cc/x.html"),
                               "a=4; domain=b.a.google.com"));
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
       TypeParam::creation_time_granularity_in_ms));
-  EXPECT_TRUE(this->SetCookie(cs,
+  EXPECT_TRUE(this->SetCookie(cs.get(),
                               GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
                               "e=1; domain=c.b.a.google.com"));
-  EXPECT_TRUE(this->SetCookie(cs,
-                              GURL("http://d.c.b.a.google.com/aa/bb/x.html"),
-                              "b=1"));
-  EXPECT_TRUE(this->SetCookie(cs, GURL("http://news.bbc.co.uk/midpath/x.html"),
-                              "g=10"));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), GURL("http://news.bbc.co.uk/midpath/x.html"), "g=10"));
   EXPECT_EQ("d=1; a=4; e=1; b=1; c=1",
-      this->GetCookies(cs, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
+            this->GetCookies(cs.get(),
+                             GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
 }
 
 TYPED_TEST_P(CookieStoreTest, DeleteSessionCookie) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   // Create a session cookie and a persistent cookie.
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
-                              std::string(kValidCookieLine)));
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
+  EXPECT_TRUE(this->SetCookie(
+      cs.get(), this->url_google_, std::string(kValidCookieLine)));
+  EXPECT_TRUE(this->SetCookie(cs.get(),
+                              this->url_google_,
                               "C=D; path=/; domain=google.izzle;"
                               "expires=Mon, 18-Apr-22 22:50:13 GMT"));
   this->MatchCookieLines("A=B; C=D",
-                         this->GetCookies(cs, this->url_google_));
+                         this->GetCookies(cs.get(), this->url_google_));
   // Delete the session cookie.
-  this->DeleteSessionCookies(cs);
+  this->DeleteSessionCookies(cs.get());
   // Check that the session cookie has been deleted but not the persistent one.
-  EXPECT_EQ("C=D", this->GetCookies(cs, this->url_google_));
+  EXPECT_EQ("C=D", this->GetCookies(cs.get(), this->url_google_));
 }
 
 REGISTER_TYPED_TEST_CASE_P(CookieStoreTest,
@@ -1008,8 +1056,8 @@ TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest);
 // thread).
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
-  this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesTask,
@@ -1025,9 +1073,9 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookiesWithOptions) {
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
-  EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
-  this->MatchCookieLines("A=B",
-      this->GetCookiesWithOptions(cs, this->url_google_, options));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
+  this->MatchCookieLines(
+      "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options));
   StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesWithOptionsTask,
@@ -1043,8 +1091,8 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) {
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B",
-                                         options));
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   BoolResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::SetCookieWithOptionsTask,
@@ -1060,11 +1108,11 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteCookie) {
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B",
-                                         options));
-  this->DeleteCookie(cs, this->url_google_, "A");
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B",
-                                         options));
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
+  this->DeleteCookie(cs.get(), this->url_google_, "A");
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   NoResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteCookieTask,
@@ -1079,14 +1127,17 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) {
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_,
-                                         "A=B", options));
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_,
-      "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT", options));
-  EXPECT_EQ(1, this->DeleteSessionCookies(cs));
-  EXPECT_EQ(0, this->DeleteSessionCookies(cs));
-  EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_,
-                                         "A=B", options));
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(),
+                                 this->url_google_,
+                                 "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT",
+                                 options));
+  EXPECT_EQ(1, this->DeleteSessionCookies(cs.get()));
+  EXPECT_EQ(0, this->DeleteSessionCookies(cs.get()));
+  EXPECT_TRUE(
+      this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   IntResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteSessionCookiesTask,
diff --git a/net/disk_cache/backend_impl.cc b/net/disk_cache/backend_impl.cc
index 5c89376..80d4f32c 100644
--- a/net/disk_cache/backend_impl.cc
+++ b/net/disk_cache/backend_impl.cc
@@ -607,7 +607,7 @@ EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   cache_entry->BeginLogging(net_log_, true);
 
   // We are not failing the operation; let's add this to the map.
-  open_entries_[entry_address.value()] = cache_entry;
+  open_entries_[entry_address.value()] = cache_entry.get();
 
   // Save the entry.
   cache_entry->entry()->Store();
@@ -623,7 +623,7 @@ EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   }
 
   // Link this entry through the lists.
-  eviction_.OnCreateEntry(cache_entry);
+  eviction_.OnCreateEntry(cache_entry.get());
 
   CACHE_UMA(AGE_MS, "CreateTime", 0, start);
   stats_.OnEvent(Stats::CREATE_HIT);
@@ -1146,7 +1146,7 @@ int BackendImpl::SelfCheck() {
 }
 
 void BackendImpl::FlushIndex() {
-  if (index_ && !disabled_)
+  if (index_.get() && !disabled_)
     index_->Flush();
 }
 
@@ -1157,7 +1157,7 @@ net::CacheType BackendImpl::GetCacheType() const {
 }
 
 int32 BackendImpl::GetEntryCount() const {
-  if (!index_ || disabled_)
+  if (!index_.get() || disabled_)
     return 0;
   // num_entries includes entries already evicted.
   int32 not_deleted = data_->header.num_entries -
@@ -1294,7 +1294,7 @@ bool BackendImpl::InitBackingStore(bool* file_created) {
 
   bool ret = true;
   if (*file_created)
-    ret = CreateBackingStore(file);
+    ret = CreateBackingStore(file.get());
 
   file = NULL;
   if (!ret)
@@ -1524,7 +1524,7 @@ int BackendImpl::NewEntry(Addr address, EntryImpl** entry) {
           address.value());
   }
 
-  open_entries_[address.value()] = cache_entry;
+  open_entries_[address.value()] = cache_entry.get();
 
   cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
@@ -1570,7 +1570,7 @@ EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
       if (!error)
         child.set_value(cache_entry->GetNextAddress());
 
-      if (parent_entry) {
+      if (parent_entry.get()) {
         parent_entry->SetNextAddress(child);
         parent_entry = NULL;
       } else {
@@ -1583,7 +1583,7 @@ EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
       if (!error) {
         // It is important to call DestroyInvalidEntry after removing this
         // entry from the table.
-        DestroyInvalidEntry(cache_entry);
+        DestroyInvalidEntry(cache_entry.get());
         cache_entry = NULL;
       } else {
         Trace("NewEntry failed on MatchEntry 0x%x", address.value());
@@ -1611,21 +1611,21 @@ EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
       cache_entry = NULL;
     parent_entry = cache_entry;
     cache_entry = NULL;
-    if (!parent_entry)
+    if (!parent_entry.get())
       break;
 
     address.set_value(parent_entry->GetNextAddress());
   }
 
-  if (parent_entry && (!find_parent || !found))
+  if (parent_entry.get() && (!find_parent || !found))
     parent_entry = NULL;
 
-  if (find_parent && entry_addr.is_initialized() && !cache_entry) {
+  if (find_parent && entry_addr.is_initialized() && !cache_entry.get()) {
     *match_error = true;
     parent_entry = NULL;
   }
 
-  if (cache_entry && (find_parent || !found))
+  if (cache_entry.get() && (find_parent || !found))
     cache_entry = NULL;
 
   find_parent ? parent_entry.swap(&tmp) : cache_entry.swap(&tmp);
diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index ecec7b7..3779b22 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -295,7 +295,7 @@ TEST_F(DiskCacheBackendTest, ExternalFiles) {
   // Now let's create a file with the cache.
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
-  ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1, 0, false));
+  ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
   entry->Close();
 
   // And verify that the first file is still there.
@@ -336,7 +336,8 @@ void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
       // We are using the current thread as the cache thread because we want to
       // be able to call directly this method to make sure that the OS (instead
       // of us switching thread) is returning IO pending.
-      rv = entry->WriteDataImpl(0, i, buffer, kSize, cb.callback(), false);
+      rv =
+          entry->WriteDataImpl(0, i, buffer.get(), kSize, cb.callback(), false);
       if (rv == net::ERR_IO_PENDING)
         break;
       EXPECT_EQ(kSize, rv);
@@ -496,21 +497,23 @@ void DiskCacheBackendTest::BackendSetSize() {
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(cache_size));
   memset(buffer->data(), 0, cache_size);
-  EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,
-                                       false)) << "normal file";
+  EXPECT_EQ(cache_size / 10,
+            WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false))
+      << "normal file";
 
-  EXPECT_EQ(net::ERR_FAILED, WriteData(entry, 1, 0, buffer, cache_size / 5,
-                                       false)) << "file size above the limit";
+  EXPECT_EQ(net::ERR_FAILED,
+            WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false))
+      << "file size above the limit";
 
   // By doubling the total size, we make this file cacheable.
   SetMaxSize(cache_size * 2);
-  EXPECT_EQ(cache_size / 5, WriteData(entry, 1, 0, buffer, cache_size / 5,
-                                      false));
+  EXPECT_EQ(cache_size / 5,
+            WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false));
 
   // Let's fill up the cache!.
   SetMaxSize(cache_size * 10);
-  EXPECT_EQ(cache_size * 3 / 4, WriteData(entry, 0, 0, buffer,
-                                          cache_size * 3 / 4, false));
+  EXPECT_EQ(cache_size * 3 / 4,
+            WriteData(entry, 0, 0, buffer.get(), cache_size * 3 / 4, false));
   entry->Close();
   FlushQueueForTest();
 
@@ -519,13 +522,13 @@ void DiskCacheBackendTest::BackendSetSize() {
   // The cache is 95% full.
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
-  EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,
-                                       false));
+  EXPECT_EQ(cache_size / 10,
+            WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false));
 
   disk_cache::Entry* entry2;
   ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
-  EXPECT_EQ(cache_size / 10, WriteData(entry2, 0, 0, buffer, cache_size / 10,
-                                       false));
+  EXPECT_EQ(cache_size / 10,
+            WriteData(entry2, 0, 0, buffer.get(), cache_size / 10, false));
   entry2->Close();  // This will trigger the cache trim.
 
   EXPECT_NE(net::OK, OpenEntry(first, &entry2));
@@ -696,7 +699,7 @@ void DiskCacheBackendTest::BackendValidEntry() {
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
   entry->Close();
   SimulateCrash();
 
@@ -704,7 +707,7 @@ void DiskCacheBackendTest::BackendValidEntry() {
 
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   memset(buffer2->data(), 0, kSize);
-  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2.get(), kSize));
   entry->Close();
   EXPECT_STREQ(buffer1->data(), buffer2->data());
 }
@@ -732,7 +735,7 @@ void DiskCacheBackendTest::BackendInvalidEntry() {
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
   base::strlcpy(buffer->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   SimulateCrash();
 
   EXPECT_NE(net::OK, OpenEntry(key, &entry));
@@ -779,10 +782,10 @@ void DiskCacheBackendTest::BackendInvalidEntryRead() {
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
   base::strlcpy(buffer->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
 
   SimulateCrash();
 
@@ -905,13 +908,13 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry() {
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 
   // Simulate a crash.
   SimulateCrash();
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 
   EXPECT_EQ(2, cache_->GetEntryCount());
   SetMaxSize(kSize);
@@ -960,7 +963,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
   for (int i = 0; i < 32; i++) {
     std::string key(base::StringPrintf("some key %d", i));
     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
-    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
     // Note that we are not closing the entries.
@@ -970,7 +973,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
   SimulateCrash();
 
   ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 
   FlushQueueForTest();
   EXPECT_EQ(33, cache_->GetEntryCount());
@@ -1163,7 +1166,7 @@ TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
   entry2->Close();
@@ -1174,7 +1177,7 @@ TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
   AddDelay();
 
   // Read from the last item in the LRU.
-  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1, kSize));
+  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
   entry1->Close();
 
   void* iter = NULL;
@@ -1197,10 +1200,10 @@ void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
   entry1->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
-  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1, kSize));
+  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
 
   std::string key2("Another key");
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
@@ -2401,8 +2404,8 @@ void DiskCacheBackendTest::BackendDisable4() {
   const int kBufSize = 20000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufSize));
   memset(buf->data(), 0, kBufSize);
-  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
-  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
+  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
+  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
 
   // This line should disable the cache but not delete it.
   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry4));
@@ -2410,13 +2413,13 @@ void DiskCacheBackendTest::BackendDisable4() {
 
   EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
 
-  EXPECT_EQ(100, ReadData(entry2, 0, 0, buf, 100));
-  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
-  EXPECT_EQ(100, WriteData(entry2, 1, 0, buf, 100, false));
+  EXPECT_EQ(100, ReadData(entry2, 0, 0, buf.get(), 100));
+  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
+  EXPECT_EQ(100, WriteData(entry2, 1, 0, buf.get(), 100, false));
 
-  EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf, kBufSize));
-  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
-  EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf, kBufSize, false));
+  EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf.get(), kBufSize));
+  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
+  EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf.get(), kBufSize, false));
 
   std::string key = entry2->GetKey();
   EXPECT_EQ(sizeof(key2) - 1, key.size());
@@ -2675,14 +2678,16 @@ TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
   for (int i = 0; i < 10; i++) {
     SCOPED_TRACE(i);
     // Allocate 2MB for this entry.
-    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, true));
-    EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer, kSize, true));
-    EXPECT_EQ(kSize, WriteData(entry, 0, 1024 * 1024, buffer, kSize, false));
-    EXPECT_EQ(kSize, WriteData(entry, 1, 1024 * 1024, buffer, kSize, false));
+    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, true));
+    EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, true));
+    EXPECT_EQ(kSize,
+              WriteData(entry, 0, 1024 * 1024, buffer.get(), kSize, false));
+    EXPECT_EQ(kSize,
+              WriteData(entry, 1, 1024 * 1024, buffer.get(), kSize, false));
 
     // Delete one of the buffers and truncate the other.
-    EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
-    EXPECT_EQ(0, WriteData(entry, 1, 10, buffer, 0, true));
+    EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
+    EXPECT_EQ(0, WriteData(entry, 1, 10, buffer.get(), 0, true));
 
     // Delete the second buffer, writing 10 bytes to disk.
     entry->Close();
@@ -2974,7 +2979,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
-  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer, 0, false));
+  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
   entry->Close();
   delete cache_;
   cache_ = NULL;
@@ -3005,7 +3010,7 @@ TEST_F(DiskCacheBackendTest, BlockfileCacheOverSimpleCache) {
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
-  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer, 0, false));
+  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
   entry->Close();
   delete cache_;
   cache_ = NULL;
diff --git a/net/disk_cache/block_files.cc b/net/disk_cache/block_files.cc
index 0e55521..97985ca 100644
--- a/net/disk_cache/block_files.cc
+++ b/net/disk_cache/block_files.cc
@@ -450,7 +450,7 @@ bool BlockFiles::OpenBlockFile(int index) {
 
   if (header->updating || !ValidateCounters(header)) {
     // Last instance was not properly shutdown, or counters are out of sync.
-    if (!FixBlockFileHeader(file)) {
+    if (!FixBlockFileHeader(file.get())) {
       LOG(ERROR) << "Unable to fix block file " << name.value();
       return false;
     }
@@ -469,7 +469,7 @@ bool BlockFiles::OpenBlockFile(int index) {
       return false;
   }
 
-  ScopedFlush flush(file);
+  ScopedFlush flush(file.get());
   DCHECK(!block_files_[index]);
   file.swap(&block_files_[index]);
   return true;
diff --git a/net/disk_cache/cache_creator.cc b/net/disk_cache/cache_creator.cc
index 5a903ae..ac49a3d 100644
--- a/net/disk_cache/cache_creator.cc
+++ b/net/disk_cache/cache_creator.cc
@@ -84,14 +84,14 @@ int CacheCreator::Run() {
   // appropriate.
   if (backend_type_ == net::CACHE_BACKEND_SIMPLE && type_ == net::DISK_CACHE) {
     disk_cache::SimpleBackendImpl* simple_cache =
-        new disk_cache::SimpleBackendImpl(path_, max_bytes_, type_, thread_,
-                                          net_log_);
+        new disk_cache::SimpleBackendImpl(
+            path_, max_bytes_, type_, thread_.get(), net_log_);
     created_cache_ = simple_cache;
     return simple_cache->Init(
         base::Bind(&CacheCreator::OnIOComplete, base::Unretained(this)));
   }
   disk_cache::BackendImpl* new_cache =
-      new disk_cache::BackendImpl(path_, thread_, net_log_);
+      new disk_cache::BackendImpl(path_, thread_.get(), net_log_);
   created_cache_ = new_cache;
   new_cache->SetMaxSize(max_bytes_);
   new_cache->SetType(type_);
diff --git a/net/disk_cache/disk_cache_perftest.cc b/net/disk_cache/disk_cache_perftest.cc
index 97b5655..ce1d486 100644
--- a/net/disk_cache/disk_cache_perftest.cc
+++ b/net/disk_cache/disk_cache_perftest.cc
@@ -67,16 +67,24 @@ bool TimeWrite(int num_entries, disk_cache::Backend* cache,
     if (net::OK != cb.GetResult(rv))
       break;
     int ret = cache_entry->WriteData(
-        0, 0, buffer1, kSize1,
-        base::Bind(&CallbackTest::Run, base::Unretained(&callback)), false);
+        0,
+        0,
+        buffer1.get(),
+        kSize1,
+        base::Bind(&CallbackTest::Run, base::Unretained(&callback)),
+        false);
     if (net::ERR_IO_PENDING == ret)
       expected++;
     else if (kSize1 != ret)
       break;
 
     ret = cache_entry->WriteData(
-        1, 0, buffer2, entry.data_len,
-        base::Bind(&CallbackTest::Run, base::Unretained(&callback)), false);
+        1,
+        0,
+        buffer2.get(),
+        entry.data_len,
+        base::Bind(&CallbackTest::Run, base::Unretained(&callback)),
+        false);
     if (net::ERR_IO_PENDING == ret)
       expected++;
     else if (entry.data_len != ret)
@@ -116,7 +124,10 @@ bool TimeRead(int num_entries, disk_cache::Backend* cache,
     if (net::OK != cb.GetResult(rv))
       break;
     int ret = cache_entry->ReadData(
-        0, 0, buffer1, kSize1,
+        0,
+        0,
+        buffer1.get(),
+        kSize1,
         base::Bind(&CallbackTest::Run, base::Unretained(&callback)));
     if (net::ERR_IO_PENDING == ret)
       expected++;
@@ -124,7 +135,10 @@ bool TimeRead(int num_entries, disk_cache::Backend* cache,
       break;
 
     ret = cache_entry->ReadData(
-        1, 0, buffer2, entries[i].data_len,
+        1,
+        0,
+        buffer2.get(),
+        entries[i].data_len,
         base::Bind(&CallbackTest::Run, base::Unretained(&callback)));
     if (net::ERR_IO_PENDING == ret)
       expected++;
diff --git a/net/disk_cache/entry_impl.cc b/net/disk_cache/entry_impl.cc
index 0d140f2..185a5a1 100644
--- a/net/disk_cache/entry_impl.cc
+++ b/net/disk_cache/entry_impl.cc
@@ -1206,7 +1206,7 @@ void EntryImpl::DeleteData(Addr address, int index) {
       LOG(ERROR) << "Failed to delete " <<
           backend_->GetFileName(address).value() << " from the cache.";
     }
-    if (files_[index])
+    if (files_[index].get())
       files_[index] = NULL;  // Releases the object.
   } else {
     backend_->DeleteBlock(address, true);
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index 9af6e65..4a2cf67 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -68,14 +68,17 @@ void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
-  EXPECT_EQ(0, entry->ReadData(
-      0, 0, buffer1, kSize1, net::CompletionCallback()));
+  EXPECT_EQ(
+      0,
+      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  EXPECT_EQ(10, entry->WriteData(
-      0, 0, buffer1, kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(10,
+            entry->WriteData(
+                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
   memset(buffer1->data(), 0, kSize1);
-  EXPECT_EQ(10, entry->ReadData(
-      0, 0, buffer1, kSize1, net::CompletionCallback()));
+  EXPECT_EQ(
+      10,
+      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
   EXPECT_STREQ("the data", buffer1->data());
 
   const int kSize2 = 5000;
@@ -85,26 +88,35 @@ void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
   memset(buffer3->data(), 0, kSize3);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  EXPECT_EQ(5000, entry->WriteData(
-      1, 1500, buffer2, kSize2, net::CompletionCallback(), false));
+  EXPECT_EQ(
+      5000,
+      entry->WriteData(
+          1, 1500, buffer2.get(), kSize2, net::CompletionCallback(), false));
   memset(buffer2->data(), 0, kSize2);
-  EXPECT_EQ(4989, entry->ReadData(
-      1, 1511, buffer2, kSize2, net::CompletionCallback()));
+  EXPECT_EQ(4989,
+            entry->ReadData(
+                1, 1511, buffer2.get(), kSize2, net::CompletionCallback()));
   EXPECT_STREQ("big data goes here", buffer2->data());
-  EXPECT_EQ(5000, entry->ReadData(
-      1, 0, buffer2, kSize2, net::CompletionCallback()));
+  EXPECT_EQ(
+      5000,
+      entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
-  EXPECT_EQ(1500, entry->ReadData(
-      1, 5000, buffer2, kSize2, net::CompletionCallback()));
-
-  EXPECT_EQ(0, entry->ReadData(
-      1, 6500, buffer2, kSize2, net::CompletionCallback()));
-  EXPECT_EQ(6500, entry->ReadData(
-      1, 0, buffer3, kSize3, net::CompletionCallback()));
-  EXPECT_EQ(8192, entry->WriteData(
-      1, 0, buffer3, 8192, net::CompletionCallback(), false));
-  EXPECT_EQ(8192, entry->ReadData(
-      1, 0, buffer3, kSize3, net::CompletionCallback()));
+  EXPECT_EQ(1500,
+            entry->ReadData(
+                1, 5000, buffer2.get(), kSize2, net::CompletionCallback()));
+
+  EXPECT_EQ(0,
+            entry->ReadData(
+                1, 6500, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(
+      6500,
+      entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
+  EXPECT_EQ(8192,
+            entry->WriteData(
+                1, 0, buffer3.get(), 8192, net::CompletionCallback(), false));
+  EXPECT_EQ(
+      8192,
+      entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
   EXPECT_EQ(8192, entry->GetDataSize(1));
 
   // We need to delete the memory buffer on this thread.
@@ -187,14 +199,22 @@ void DiskCacheEntryTest::InternalAsyncIO() {
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   CacheTestFillBuffer(buffer3->data(), kSize3, false);
 
-  EXPECT_EQ(0, entry->ReadData(
-      0, 15 * 1024, buffer1, kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
+  EXPECT_EQ(0,
+            entry->ReadData(
+                0,
+                15 * 1024,
+                buffer1.get(),
+                kSize1,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
   base::strlcpy(buffer1->data(), "the data", kSize1);
   int expected = 0;
   int ret = entry->WriteData(
-      0, 0, buffer1, kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback2)), false);
+      0,
+      0,
+      buffer1.get(),
+      kSize1,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
+      false);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
@@ -202,7 +222,10 @@ void DiskCacheEntryTest::InternalAsyncIO() {
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   memset(buffer2->data(), 0, kSize2);
   ret = entry->ReadData(
-      0, 0, buffer2, kSize1,
+      0,
+      0,
+      buffer2.get(),
+      kSize1,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback3)));
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -213,8 +236,12 @@ void DiskCacheEntryTest::InternalAsyncIO() {
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
   ret = entry->WriteData(
-      1, 1500, buffer2, kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback4)), true);
+      1,
+      1500,
+      buffer2.get(),
+      kSize2,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
+      true);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
@@ -222,7 +249,10 @@ void DiskCacheEntryTest::InternalAsyncIO() {
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   memset(buffer3->data(), 0, kSize3);
   ret = entry->ReadData(
-      1, 1511, buffer3, kSize2,
+      1,
+      1511,
+      buffer3.get(),
+      kSize2,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
   EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -231,7 +261,10 @@ void DiskCacheEntryTest::InternalAsyncIO() {
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("big data goes here", buffer3->data());
   ret = entry->ReadData(
-      1, 0, buffer2, kSize2,
+      1,
+      0,
+      buffer2.get(),
+      kSize2,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -242,29 +275,42 @@ void DiskCacheEntryTest::InternalAsyncIO() {
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
   ret = entry->ReadData(
-      1, 5000, buffer2, kSize2,
+      1,
+      5000,
+      buffer2.get(),
+      kSize2,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback7)));
   EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   ret = entry->ReadData(
-      1, 0, buffer3, kSize3,
+      1,
+      0,
+      buffer3.get(),
+      kSize3,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback9)));
   EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   ret = entry->WriteData(
-      1, 0, buffer3, 8192,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback10)), true);
+      1,
+      0,
+      buffer3.get(),
+      8192,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback10)),
+      true);
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   ret = entry->ReadData(
-      1, 0, buffer3, kSize3,
+      1,
+      0,
+      buffer3.get(),
+      kSize3,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback11)));
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -273,14 +319,20 @@ void DiskCacheEntryTest::InternalAsyncIO() {
   EXPECT_EQ(8192, entry->GetDataSize(1));
 
   ret = entry->ReadData(
-      0, 0, buffer1, kSize1,
+      0,
+      0,
+      buffer1.get(),
+      kSize1,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback12)));
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   ret = entry->ReadData(
-      1, 0, buffer2, kSize2,
+      1,
+      0,
+      buffer2.get(),
+      kSize2,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback13)));
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -316,32 +368,43 @@ void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) {
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  EXPECT_EQ(17000, entry->WriteData(
-      0, 0, buffer1, kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(17000,
+            entry->WriteData(
+                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
   memset(buffer1->data(), 0, kSize1);
-  EXPECT_EQ(17000, entry->ReadData(
-      0, 0, buffer1, kSize1, net::CompletionCallback()));
+  EXPECT_EQ(
+      17000,
+      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
   EXPECT_STREQ("the data", buffer1->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  EXPECT_EQ(25000, entry->WriteData(
-      1, 10000, buffer2, kSize2, net::CompletionCallback(), false));
+  EXPECT_EQ(
+      25000,
+      entry->WriteData(
+          1, 10000, buffer2.get(), kSize2, net::CompletionCallback(), false));
   memset(buffer2->data(), 0, kSize2);
-  EXPECT_EQ(24989, entry->ReadData(
-      1, 10011, buffer2, kSize2, net::CompletionCallback()));
+  EXPECT_EQ(24989,
+            entry->ReadData(
+                1, 10011, buffer2.get(), kSize2, net::CompletionCallback()));
   EXPECT_STREQ("big data goes here", buffer2->data());
-  EXPECT_EQ(25000, entry->ReadData(
-      1, 0, buffer2, kSize2, net::CompletionCallback()));
+  EXPECT_EQ(
+      25000,
+      entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer2->data(), 10000));
-  EXPECT_EQ(5000, entry->ReadData(
-      1, 30000, buffer2, kSize2, net::CompletionCallback()));
-
-  EXPECT_EQ(0, entry->ReadData(
-      1, 35000, buffer2, kSize2, net::CompletionCallback()));
-  EXPECT_EQ(17000, entry->ReadData(
-      1, 0, buffer1, kSize1, net::CompletionCallback()));
-  EXPECT_EQ(17000, entry->WriteData(
-      1, 20000, buffer1, kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(5000,
+            entry->ReadData(
+                1, 30000, buffer2.get(), kSize2, net::CompletionCallback()));
+
+  EXPECT_EQ(0,
+            entry->ReadData(
+                1, 35000, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(
+      17000,
+      entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_EQ(
+      17000,
+      entry->WriteData(
+          1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false));
   EXPECT_EQ(37000, entry->GetDataSize(1));
 
   // We need to delete the memory buffer on this thread.
@@ -412,8 +475,12 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
   CacheTestFillBuffer(buffer3->data(), kSize3, false);
   base::strlcpy(buffer1->data(), "the data", kSize1);
   int ret = entry->WriteData(
-      0, 0, buffer1, kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback1)), false);
+      0,
+      0,
+      buffer1.get(),
+      kSize1,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback1)),
+      false);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
@@ -422,7 +489,10 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
 
   memset(buffer2->data(), 0, kSize1);
   ret = entry->ReadData(
-      0, 0, buffer2, kSize1,
+      0,
+      0,
+      buffer2.get(),
+      kSize1,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback2)));
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -433,8 +503,12 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
   ret = entry->WriteData(
-      1, 10000, buffer2, kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback3)), false);
+      1,
+      10000,
+      buffer2.get(),
+      kSize2,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback3)),
+      false);
   EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
@@ -443,7 +517,10 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
 
   memset(buffer3->data(), 0, kSize3);
   ret = entry->ReadData(
-      1, 10011, buffer3, kSize3,
+      1,
+      10011,
+      buffer3.get(),
+      kSize3,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback4)));
   EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -452,7 +529,10 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("big data goes here", buffer3->data());
   ret = entry->ReadData(
-      1, 0, buffer2, kSize2,
+      1,
+      0,
+      buffer2.get(),
+      kSize2,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
   EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ -462,24 +542,38 @@ void DiskCacheEntryTest::ExternalAsyncIO() {
   memset(buffer3->data(), 0, kSize3);
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000));
   ret = entry->ReadData(
-      1, 30000, buffer2, kSize2,
+      1,
+      30000,
+      buffer2.get(),
+      kSize2,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  EXPECT_EQ(0, entry->ReadData(
-      1, 35000, buffer2, kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback7))));
+  EXPECT_EQ(0,
+            entry->ReadData(
+                1,
+                35000,
+                buffer2.get(),
+                kSize2,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback7))));
   ret = entry->ReadData(
-      1, 0, buffer1, kSize1,
+      1,
+      0,
+      buffer1.get(),
+      kSize1,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback8)));
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
   ret = entry->WriteData(
-      1, 20000, buffer3, kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback9)), false);
+      1,
+      20000,
+      buffer3.get(),
+      kSize1,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback9)),
+      false);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
@@ -522,8 +616,9 @@ void DiskCacheEntryTest::ReleaseBuffer() {
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(buffer->data(), kBufferSize, false);
 
-  net::ReleaseBufferCompletionCallback cb(buffer);
-  int rv = entry->WriteData(0, 0, buffer, kBufferSize, cb.callback(), false);
+  net::ReleaseBufferCompletionCallback cb(buffer.get());
+  int rv =
+      entry->WriteData(0, 0, buffer.get(), kBufferSize, cb.callback(), false);
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
   entry->Close();
 }
@@ -554,15 +649,16 @@ void DiskCacheEntryTest::StreamAccess() {
   }
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
   for (int i = 0; i < kNumStreams; i++) {
-    EXPECT_EQ(kBufferSize, WriteData(entry, i, 0, reference_buffers[i],
-                                     kBufferSize, false));
+    EXPECT_EQ(
+        kBufferSize,
+        WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false));
     memset(buffer1->data(), 0, kBufferSize);
-    EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1, kBufferSize));
-    EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer1->data(),
-                        kBufferSize));
+    EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize));
+    EXPECT_EQ(
+        0, memcmp(reference_buffers[i]->data(), buffer1->data(), kBufferSize));
   }
   EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
-            ReadData(entry, kNumStreams, 0, buffer1, kBufferSize));
+            ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize));
   entry->Close();
 
   // Open the entry and read it in chunks, including a read past the end.
@@ -574,15 +670,20 @@ void DiskCacheEntryTest::StreamAccess() {
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize));
   for (int i = 0; i < kNumStreams; i++) {
     memset(buffer2->data(), 0, kReadBufferSize);
-    EXPECT_EQ(kReadBufferSize, ReadData(entry, i, 0, buffer2, kReadBufferSize));
-    EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer2->data(),
-                        kReadBufferSize));
+    EXPECT_EQ(kReadBufferSize,
+              ReadData(entry, i, 0, buffer2.get(), kReadBufferSize));
+    EXPECT_EQ(
+        0,
+        memcmp(reference_buffers[i]->data(), buffer2->data(), kReadBufferSize));
 
     memset(buffer2->data(), 0, kReadBufferSize);
-    EXPECT_EQ(kFinalReadSize, ReadData(entry, i, kReadBufferSize,
-                                       buffer2, kReadBufferSize));
-    EXPECT_EQ(0, memcmp(reference_buffers[i]->data() + kReadBufferSize,
-                        buffer2->data(), kFinalReadSize));
+    EXPECT_EQ(
+        kFinalReadSize,
+        ReadData(entry, i, kReadBufferSize, buffer2.get(), kReadBufferSize));
+    EXPECT_EQ(0,
+              memcmp(reference_buffers[i]->data() + kReadBufferSize,
+                     buffer2->data(),
+                     kFinalReadSize));
   }
 
   entry->Close();
@@ -678,7 +779,7 @@ void DiskCacheEntryTest::GetTimes() {
   EXPECT_TRUE(t3 > t2);
   const int kSize = 200;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
-  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
   if (type_ == net::APP_CACHE) {
     EXPECT_TRUE(entry->GetLastUsed() < t2);
     EXPECT_TRUE(entry->GetLastModified() < t2);
@@ -727,43 +828,43 @@ void DiskCacheEntryTest::GrowData() {
   memset(buffer2->data(), 0, kSize);
 
   base::strlcpy(buffer1->data(), "the data", kSize);
-  EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
-  EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2, 10));
+  EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false));
+  EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2.get(), 10));
   EXPECT_STREQ("the data", buffer2->data());
   EXPECT_EQ(10, entry->GetDataSize(0));
 
-  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
   EXPECT_EQ(2000, entry->GetDataSize(0));
-  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
+  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
 
-  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
   EXPECT_EQ(20000, entry->GetDataSize(0));
-  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
+  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
   entry->Close();
 
   memset(buffer2->data(), 0, kSize);
   std::string key2("Second key");
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
-  EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
+  EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false));
   EXPECT_EQ(10, entry->GetDataSize(0));
   entry->Close();
 
   // Go from an internal address to a bigger block size.
   ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
-  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
   EXPECT_EQ(2000, entry->GetDataSize(0));
-  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
+  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
   entry->Close();
   memset(buffer2->data(), 0, kSize);
 
   // Go from an internal address to an external one.
   ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
-  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
   EXPECT_EQ(20000, entry->GetDataSize(0));
-  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
+  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
   entry->Close();
 
@@ -772,7 +873,7 @@ void DiskCacheEntryTest::GrowData() {
   EXPECT_EQ(20000, entry->GetDataSize(0));
 
   // Now extend the entry without actual data.
-  EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1, 0, false));
+  EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1.get(), 0, false));
   entry->Close();
 
   // And check again from disk.
@@ -812,47 +913,47 @@ void DiskCacheEntryTest::TruncateData() {
   memset(buffer2->data(), 0, kSize2);
 
   // Simple truncation:
-  EXPECT_EQ(200, WriteData(entry, 0, 0, buffer1, 200, false));
+  EXPECT_EQ(200, WriteData(entry, 0, 0, buffer1.get(), 200, false));
   EXPECT_EQ(200, entry->GetDataSize(0));
-  EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, false));
+  EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, false));
   EXPECT_EQ(200, entry->GetDataSize(0));
-  EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, true));
+  EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, true));
   EXPECT_EQ(100, entry->GetDataSize(0));
-  EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1, 0, true));
+  EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1.get(), 0, true));
   EXPECT_EQ(50, entry->GetDataSize(0));
-  EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1, 0, true));
+  EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true));
   EXPECT_EQ(0, entry->GetDataSize(0));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // Go to an external file.
-  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, 20000, true));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true));
   EXPECT_EQ(20000, entry->GetDataSize(0));
-  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, 20000));
+  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), 20000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
   memset(buffer2->data(), 0, kSize2);
 
   // External file truncation
-  EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1, 18000, false));
+  EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, false));
   EXPECT_EQ(20000, entry->GetDataSize(0));
-  EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1, 18000, true));
+  EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, true));
   EXPECT_EQ(18000, entry->GetDataSize(0));
-  EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1, 0, true));
+  EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1.get(), 0, true));
   EXPECT_EQ(17500, entry->GetDataSize(0));
 
   // And back to an internal block.
-  EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
+  EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true));
   EXPECT_EQ(1600, entry->GetDataSize(0));
-  EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2, 600));
+  EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2.get(), 600));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600));
-  EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2, 1000));
-  EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000)) <<
-      "Preserves previous data";
+  EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2.get(), 1000));
+  EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000))
+      << "Preserves previous data";
 
   // Go from external file to zero length.
-  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, 20000, true));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true));
   EXPECT_EQ(20000, entry->GetDataSize(0));
-  EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1, 0, true));
+  EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true));
   EXPECT_EQ(0, entry->GetDataSize(0));
 
   entry->Close();
@@ -899,15 +1000,15 @@ void DiskCacheEntryTest::ZeroLengthIO() {
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
 
   CacheTestFillBuffer(buffer->data(), kSize, false);
-  EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
 
   CacheTestFillBuffer(buffer->data(), kSize, false);
-  EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
 
   CacheTestFillBuffer(buffer->data(), kSize, false);
-  EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
 
   entry->Close();
@@ -943,66 +1044,66 @@ void DiskCacheEntryTest::Buffering() {
   CacheTestFillBuffer(buffer1->data(), kSize, true);
   CacheTestFillBuffer(buffer2->data(), kSize, true);
 
-  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
   entry->Close();
 
   // Write a little more and read what we wrote before.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1, kSize, false));
-  EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   // Now go to an external file.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false));
   entry->Close();
 
   // Write something else and verify old data.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   // Extend the file some more.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false));
   entry->Close();
 
   // And now make sure that we can deal with data in both places (ram/disk).
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false));
 
   // We should not overwrite the data at 18000 with this.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
-  EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2, kSize));
+  EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
 
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2, kSize));
+  EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
 
   // Extend the file again and read before without closing the entry.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, false));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   entry->Close();
@@ -1056,56 +1157,57 @@ void DiskCacheEntryTest::SizeChanges() {
   CacheTestFillBuffer(buffer1->data(), kSize, true);
   CacheTestFillBuffer(buffer2->data(), kSize, true);
 
-  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1, kSize, true));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, true));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, true));
   entry->Close();
 
   // Extend the file and read between the old size and the new write.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(23000 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true));
   EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));
 
   // Read at the end of the old file size.
-  EXPECT_EQ(kSize, ReadData(entry, 1, 23000 + kSize - 35, buffer2, kSize));
+  EXPECT_EQ(kSize,
+            ReadData(entry, 1, 23000 + kSize - 35, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35));
 
   // Read slightly before the last write.
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
   EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
   // Extend the entry a little more.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1.get(), kSize, true));
   EXPECT_EQ(26000 + kSize, entry->GetDataSize(1));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
-  EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
   EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
   // And now reduce the size.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true));
   EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2, kSize));
+  EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28));
 
   // Reduce the size with a buffer that is not extending the size.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1.get(), kSize, false));
   EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1.get(), kSize, true));
   EXPECT_EQ(24500 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
   EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
   // And now reduce the size below the old size.
-  EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, true));
   EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
   EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
@@ -1115,8 +1217,8 @@ void DiskCacheEntryTest::SizeChanges() {
   EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
 
   // Extend the newly opened file with a zero length write, expect zero fill.
-  EXPECT_EQ(0, WriteData(entry, 1, 20000 + kSize, buffer1, 0, false));
-  EXPECT_EQ(kSize, ReadData(entry, 1, 19000 + kSize, buffer1, kSize));
+  EXPECT_EQ(0, WriteData(entry, 1, 20000 + kSize, buffer1.get(), 0, false));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 19000 + kSize, buffer1.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize));
 
   entry->Close();
@@ -1148,8 +1250,8 @@ void DiskCacheEntryTest::ReuseEntry(int size) {
   CacheTestFillBuffer(buffer->data(), size, false);
 
   for (int i = 0; i < 15; i++) {
-    EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
-    EXPECT_EQ(size, WriteData(entry, 0, 0, buffer, size, false));
+    EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
+    EXPECT_EQ(size, WriteData(entry, 0, 0, buffer.get(), size, false));
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   }
@@ -1202,49 +1304,49 @@ void DiskCacheEntryTest::InvalidData() {
   memset(buffer2->data(), 0, kSize2);
 
   // Simple data grow:
-  EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1, 200, false));
+  EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1.get(), 200, false));
   EXPECT_EQ(600, entry->GetDataSize(0));
-  EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3, 100));
+  EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // The entry is now on disk. Load it and extend it.
-  EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1, 200, false));
+  EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1.get(), 200, false));
   EXPECT_EQ(1000, entry->GetDataSize(0));
-  EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3, 100));
+  EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // This time using truncate.
-  EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1, 200, true));
+  EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1.get(), 200, true));
   EXPECT_EQ(2000, entry->GetDataSize(0));
-  EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3, 100));
+  EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
 
   // Go to an external file.
-  EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1, 200, false));
+  EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1.get(), 200, false));
   EXPECT_EQ(20000, entry->GetDataSize(0));
-  EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3, 4000));
+  EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3.get(), 4000));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000));
 
   // And back to an internal block.
-  EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
+  EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true));
   EXPECT_EQ(1600, entry->GetDataSize(0));
-  EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3, 600));
+  EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3.get(), 600));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600));
 
   // Extend it again.
-  EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1, 600, false));
+  EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1.get(), 600, false));
   EXPECT_EQ(2600, entry->GetDataSize(0));
-  EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3, 200));
+  EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3.get(), 200));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
 
   // And again (with truncation flag).
-  EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1, 600, true));
+  EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1.get(), 600, true));
   EXPECT_EQ(3600, entry->GetDataSize(0));
-  EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3, 200));
+  EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3.get(), 200));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
 
   entry->Close();
@@ -1279,7 +1381,7 @@ void DiskCacheEntryTest::ReadWriteDestroyBuffer() {
 
   net::TestCompletionCallback cb;
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->WriteData(0, 0, buffer, kSize, cb.callback(), false));
+            entry->WriteData(0, 0, buffer.get(), kSize, cb.callback(), false));
 
   // Release our reference to the buffer.
   buffer = NULL;
@@ -1290,7 +1392,7 @@ void DiskCacheEntryTest::ReadWriteDestroyBuffer() {
   CacheTestFillBuffer(buffer->data(), kSize, false);
 
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0, 0, buffer, kSize, cb.callback()));
+            entry->ReadData(0, 0, buffer.get(), kSize, cb.callback()));
   buffer = NULL;
   EXPECT_EQ(kSize, cb.WaitForResult());
 
@@ -1316,8 +1418,8 @@ void DiskCacheEntryTest::DoomNormalEntry() {
 
   key = buffer->data();
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
-  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer, kSize, false));
-  EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer, kSize, false));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false));
+  EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false));
   entry->Doom();
   entry->Close();
 
@@ -1397,8 +1499,8 @@ void DiskCacheEntryTest::DoomedEntry() {
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   memset(buffer2->data(), 0, kSize2);
 
-  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
-  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
+  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
+  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1));
   EXPECT_EQ(key, entry->GetKey());
   EXPECT_TRUE(initial < entry->GetLastModified());
@@ -1430,7 +1532,7 @@ TEST_F(DiskCacheEntryTest, MissingData) {
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   entry->Close();
   FlushQueueForTest();
 
@@ -1440,7 +1542,8 @@ TEST_F(DiskCacheEntryTest, MissingData) {
 
   // Attempt to read the data.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(net::ERR_FILE_NOT_FOUND, ReadData(entry, 0, 0, buffer, kSize));
+  EXPECT_EQ(net::ERR_FILE_NOT_FOUND,
+            ReadData(entry, 0, 0, buffer.get(), kSize));
   entry->Close();
 
   // The entry should be gone.
@@ -1462,12 +1565,14 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
   ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry));
 
   // Writes to the parent entry.
-  EXPECT_EQ(kSize, parent_entry->WriteSparseData(0, buf, kSize,
-                                                 net::CompletionCallback()));
+  EXPECT_EQ(kSize,
+            parent_entry->WriteSparseData(
+                0, buf.get(), kSize, net::CompletionCallback()));
 
   // This write creates a child entry and writes to it.
-  EXPECT_EQ(kSize, parent_entry->WriteSparseData(8192, buf, kSize,
-                                                 net::CompletionCallback()));
+  EXPECT_EQ(kSize,
+            parent_entry->WriteSparseData(
+                8192, buf.get(), kSize, net::CompletionCallback()));
 
   parent_entry->Close();
 
@@ -1512,7 +1617,7 @@ void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
 
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
   memset(buf_1->data(), 0, size);
-  int ret = entry->ReadSparseData(offset, buf_1, size, cb.callback());
+  int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
@@ -1528,13 +1633,13 @@ void DiskCacheEntryTest::BasicSparseIO() {
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0.
-  VerifySparseIO(entry, 0, buf_1, kSize, buf_2);
+  VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get());
 
   // Write at offset 0x400000 (4 MB).
-  VerifySparseIO(entry, 0x400000, buf_1, kSize, buf_2);
+  VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get());
 
   // Write at offset 0x800000000 (32 GB).
-  VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, buf_2);
+  VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get());
 
   entry->Close();
 
@@ -1569,7 +1674,7 @@ void DiskCacheEntryTest::HugeSparseIO() {
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB).
-  VerifySparseIO(entry, 0x20F0000, buf_1, kSize, buf_2);
+  VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get());
   entry->Close();
 
   // Check it again.
@@ -1599,8 +1704,8 @@ void DiskCacheEntryTest::GetAvailableRange() {
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
-  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));
 
   // We stop at the first empty block.
   int64 start;
@@ -1624,14 +1729,14 @@ void DiskCacheEntryTest::GetAvailableRange() {
   start = -1;
   rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
-  rv = entry->ReadSparseData(start, buf, kSize, cb.callback());
+  rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   start = 0;
   rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
   EXPECT_EQ(0x2000, cb.GetResult(rv));
   EXPECT_EQ(0x20F2000, start);
-  EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf, kSize));
+  EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize));
 
   // Make sure that we respect the |len| argument.
   start = 0;
@@ -1664,7 +1769,7 @@ void DiskCacheEntryTest::CouldBeSparse() {
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB).
-  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
 
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
@@ -1678,9 +1783,9 @@ void DiskCacheEntryTest::CouldBeSparse() {
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_FALSE(entry->CouldBeSparse());
 
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf, kSize, false));
-  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf, kSize, false));
-  EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false));
 
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
@@ -1718,8 +1823,8 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
   for (int i = 0; i < kSize; i += 1024) {
     scoped_refptr<net::WrappedIOBuffer> buf_3(
       new net::WrappedIOBuffer(buf_1->data() + i));
-    VerifySparseIO(entry, i, buf_3, 1024, buf_2);
-    VerifySparseIO(entry, 9000 + i, buf_3, 1024, buf_2);
+    VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
+    VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
   }
 
   // Make sure we have data written.
@@ -1727,7 +1832,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
   VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);
 
   // This tests a large write that spans 3 entries from a misaligned offset.
-  VerifySparseIO(entry, 20481, buf_1, 8192, buf_2);
+  VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get());
 
   entry->Close();
 }
@@ -1745,16 +1850,20 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // Writes in the middle of an entry.
-  EXPECT_EQ(1024, entry->WriteSparseData(
-      0, buf, 1024, net::CompletionCallback()));
-  EXPECT_EQ(1024, entry->WriteSparseData(
-      5120, buf, 1024, net::CompletionCallback()));
-  EXPECT_EQ(1024, entry->WriteSparseData(
-      10000, buf, 1024, net::CompletionCallback()));
+  EXPECT_EQ(
+      1024,
+      entry->WriteSparseData(0, buf.get(), 1024, net::CompletionCallback()));
+  EXPECT_EQ(
+      1024,
+      entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback()));
+  EXPECT_EQ(1024,
+            entry->WriteSparseData(
+                10000, buf.get(), 1024, net::CompletionCallback()));
 
   // Writes in the middle of an entry and spans 2 child entries.
-  EXPECT_EQ(8192, entry->WriteSparseData(
-      50000, buf, 8192, net::CompletionCallback()));
+  EXPECT_EQ(8192,
+            entry->WriteSparseData(
+                50000, buf.get(), 8192, net::CompletionCallback()));
 
   int64 start;
   net::TestCompletionCallback cb;
@@ -1805,12 +1914,12 @@ void DiskCacheEntryTest::UpdateSparseEntry() {
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0.
-  VerifySparseIO(entry1, 0, buf_1, kSize, buf_2);
+  VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get());
   entry1->Close();
 
   // Write at offset 2048.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
-  VerifySparseIO(entry1, 2048, buf_1, kSize, buf_2);
+  VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get());
 
   disk_cache::Entry* entry2;
   ASSERT_EQ(net::OK, CreateEntry("the second key", &entry2));
@@ -1851,12 +1960,14 @@ void DiskCacheEntryTest::DoomSparseEntry() {
   int64 offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
-    EXPECT_EQ(kSize, entry1->WriteSparseData(offset, buf, kSize,
-                                             net::CompletionCallback()));
+    EXPECT_EQ(kSize,
+              entry1->WriteSparseData(
+                  offset, buf.get(), kSize, net::CompletionCallback()));
     // Keep the second map under the default size.
     if (i < 9) {
-      EXPECT_EQ(kSize, entry2->WriteSparseData(offset, buf, kSize,
-                                               net::CompletionCallback()));
+      EXPECT_EQ(kSize,
+                entry2->WriteSparseData(
+                    offset, buf.get(), kSize, net::CompletionCallback()));
     }
 
     offset *= 4;
@@ -1942,8 +2053,9 @@ TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
   int64 offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
-    EXPECT_EQ(kSize, entry->WriteSparseData(offset, buf, kSize,
-                                            net::CompletionCallback()));
+    EXPECT_EQ(kSize,
+              entry->WriteSparseData(
+                  offset, buf.get(), kSize, net::CompletionCallback()));
     offset *= 4;
   }
   EXPECT_EQ(9, cache_->GetEntryCount());
@@ -1973,24 +2085,25 @@ void DiskCacheEntryTest::PartialSparseEntry() {
   // The first write is just to extend the entry. The third write occupies
   // a 1KB block partially, it may not be written internally depending on the
   // implementation.
-  EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1, kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1, kSize));
-  EXPECT_EQ(kSmallSize, WriteSparseData(entry, 1080321, buf1, kSmallSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize));
+  EXPECT_EQ(kSmallSize,
+            WriteSparseData(entry, 1080321, buf1.get(), kSmallSize));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
   memset(buf2->data(), 0, kSize);
-  EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2, kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize));
 
-  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
+  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
-  EXPECT_EQ(0, ReadSparseData(entry, 0, buf2, kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize));
 
   // This read should not change anything.
-  EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2, kSize));
-  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
-  EXPECT_EQ(0, ReadSparseData(entry, 99, buf2, kSize));
+  EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize));
+  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize));
 
   int rv;
   int64 start;
@@ -2031,11 +2144,11 @@ void DiskCacheEntryTest::PartialSparseEntry() {
   EXPECT_EQ(4600, start);
 
   // Now make another write and verify that there is no hole in between.
-  EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1.get(), kSize));
   rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback());
   EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv));
   EXPECT_EQ(1024, start);
-  EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2, kSize));
+  EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2.get(), kSize));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
   EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500));
 
@@ -2065,9 +2178,9 @@ TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
   CacheTestFillBuffer(buf1->data(), kSize, false);
 
   const int k1Meg = 1024 * 1024;
-  EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1, kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1, kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
   entry->Close();
   EXPECT_EQ(4, cache_->GetEntryCount());
 
@@ -2084,7 +2197,7 @@ TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
   for (int i = 0; i < 2; i++) {
     ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
     // Overwrite the header's magic and signature.
-    EXPECT_EQ(12, WriteData(entry, 2, 0, buf1, 12, false));
+    EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false));
     entry->Close();
   }
 
@@ -2092,12 +2205,12 @@ TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // Two children should be gone. One while reading and one while writing.
-  EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1, kSize));
-  EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1, kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
 
   // We never touched this one.
-  EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1, kSize));
+  EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize));
   entry->Close();
 
   // We re-created one of the corrupt children.
@@ -2118,7 +2231,7 @@ TEST_F(DiskCacheEntryTest, CancelSparseIO) {
   // This will open and write two "real" entries.
   net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
   int rv = entry->WriteSparseData(
-      1024 * 1024 - 4096, buf, kSize, cb1.callback());
+      1024 * 1024 - 4096, buf.get(), kSize, cb1.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   int64 offset = 0;
@@ -2139,11 +2252,11 @@ TEST_F(DiskCacheEntryTest, CancelSparseIO) {
 
   if (!cb1.have_result()) {
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
-              entry->ReadSparseData(offset, buf, kSize,
-                                    net::CompletionCallback()));
+              entry->ReadSparseData(
+                  offset, buf.get(), kSize, net::CompletionCallback()));
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
-              entry->WriteSparseData(offset, buf, kSize,
-                                     net::CompletionCallback()));
+              entry->WriteSparseData(
+                  offset, buf.get(), kSize, net::CompletionCallback()));
   }
 
   // Now see if we receive all notifications. Note that we should not be able
@@ -2311,7 +2424,7 @@ void DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const char* key) {
   std::copy(data.begin(), data.end(), buffer->data());
 
   ASSERT_EQ(implicit_cast<int>(data.size()),
-            WriteData(entry, 0, 0, buffer, data.size(), false));
+            WriteData(entry, 0, 0, buffer.get(), data.size(), false));
   entry->Close();
   entry = NULL;
 
@@ -2350,7 +2463,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum) {
   EXPECT_GE(kReadBufferSize, entry->GetDataSize(0));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
-            ReadData(entry, 0, 0, read_buffer, kReadBufferSize));
+            ReadData(entry, 0, 0, read_buffer.get(), kReadBufferSize));
 
   entry->Close();
 }
@@ -2372,7 +2485,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) {
   EXPECT_GE(kReadBufferSize, entry->GetDataSize(0));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
-            ReadData(entry, 0, 0, read_buffer, kReadBufferSize));
+            ReadData(entry, 0, 0, read_buffer.get(), kReadBufferSize));
 
   entry->Doom();  // Should not crash.
   entry->Close();
@@ -2457,16 +2570,24 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) {
   // This write may or may not be optimistic (it depends if the previous
   // optimistic create already finished by the time we call the write here).
   int ret = entry->WriteData(
-      0, 0, buffer1, kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback2)), false);
+      0,
+      0,
+      buffer1.get(),
+      kSize1,
+      base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
+      false);
   EXPECT_TRUE(kSize1 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   // This Read must not be optimistic, since we don't support that yet.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadData(
-      0, 0, buffer1_read, kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback3))));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            entry->ReadData(
+                0,
+                0,
+                buffer1_read.get(),
+                kSize1,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback3))));
   expected++;
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));
@@ -2475,15 +2596,22 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) {
   // should be empty, so the next Write operation must run as optimistic.
   EXPECT_EQ(kSize2,
             entry->WriteData(
-                0, 0, buffer2, kSize2,
-                base::Bind(&CallbackTest::Run,
-                           base::Unretained(&callback4)), false));
+                0,
+                0,
+                buffer2.get(),
+                kSize2,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
+                false));
 
   // Lets do another read so we block until both the write and the read
   // operation finishes and we can then test for HasOneRef() below.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadData(
-      0, 0, buffer2_read, kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback5))));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            entry->ReadData(
+                0,
+                0,
+                buffer2_read.get(),
+                kSize2,
+                base::Bind(&CallbackTest::Run, base::Unretained(&callback5))));
   expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
@@ -2586,8 +2714,9 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) {
 
   // Lets do a Write so we block until both the Close and the Write
   // operation finishes. Write must fail since we are writing in a closed entry.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->WriteData(
-      0, 0, buffer1, kSize1, cb.callback(), false));
+  EXPECT_EQ(
+      net::ERR_IO_PENDING,
+      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(net::ERR_FAILED, cb.GetResult(net::ERR_IO_PENDING));
 
   // Finish running the pending tasks so that we fully complete the close
@@ -2614,13 +2743,14 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) {
   // twice, so the next Write operation must succeed and it must be able to
   // perform it optimistically, since there is no operation running on this
   // entry.
-  EXPECT_EQ(kSize1, entry2->WriteData(
-      0, 0, buffer1, kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(kSize1,
+            entry2->WriteData(
+                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
 
   // Lets do another read so we block until both the write and the read
   // operation finishes and we can then test for HasOneRef() below.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry2->ReadData(
-      0, 0, buffer1, kSize1, cb.callback()));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            entry2->ReadData(0, 0, buffer1.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
@@ -2650,12 +2780,13 @@ TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheOptimistic5) {
   EXPECT_NE(null, entry);
   entry->Doom();
 
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->WriteData(
-      0, 0, buffer1, kSize1, cb.callback(), false));
+  EXPECT_EQ(
+      net::ERR_IO_PENDING,
+      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadData(
-      0, 0, buffer1, kSize1, cb.callback()));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            entry->ReadData(0, 0, buffer1.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
@@ -2683,16 +2814,17 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) {
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
 
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->WriteData(
-      0, 0, buffer1, kSize1, cb.callback(), false));
+  EXPECT_EQ(
+      net::ERR_IO_PENDING,
+      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   entry->Doom();
   entry->Doom();
 
   // This Read must not be optimistic, since we don't support that yet.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadData(
-      0, 0, buffer1_read, kSize1, cb.callback()));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            entry->ReadData(0, 0, buffer1_read.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));
 
@@ -2761,8 +2893,9 @@ TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheCreateDoomRace) {
   // Lets do a Write so we block until all operations are done, so we can check
   // the HasOneRef() below. This call can't be optimistic and we are checking
   // that here.
-  EXPECT_EQ(net::ERR_IO_PENDING, entry->WriteData(
-      0, 0, buffer1, kSize1, cb.callback(), false));
+  EXPECT_EQ(
+      net::ERR_IO_PENDING,
+      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
@@ -2833,13 +2966,15 @@ TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) {
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kWriteSize));
   CacheTestFillBuffer(buffer->data(), kWriteSize, false);
-  EXPECT_EQ(kWriteSize, WriteData(entry, 0, 0, buffer, kWriteSize, false));
+  EXPECT_EQ(kWriteSize,
+            WriteData(entry, 0, 0, buffer.get(), kWriteSize, false));
   entry->Close();
 
   std::string key2("the key prefix");
   for (int i = 0; i < kNumExtraEntries; i++) {
     ASSERT_EQ(net::OK, CreateEntry(key2 + base::StringPrintf("%d", i), &entry));
-    EXPECT_EQ(kWriteSize, WriteData(entry, 0, 0, buffer, kWriteSize, false));
+    EXPECT_EQ(kWriteSize,
+              WriteData(entry, 0, 0, buffer.get(), kWriteSize, false));
     entry->Close();
   }
 
@@ -2876,7 +3011,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate)  {
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   EXPECT_EQ(kBufferSize,
-            WriteData(entry, 0, 0, write_buffer, kBufferSize, false));
+            WriteData(entry, 0, 0, write_buffer.get(), kBufferSize, false));
   entry->Close();
   entry = NULL;
 
@@ -2890,7 +3025,10 @@ TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate)  {
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   CallbackTest read_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0, 0, read_buffer, kReadBufferSize,
+            entry->ReadData(0,
+                            0,
+                            read_buffer.get(),
+                            kReadBufferSize,
                             base::Bind(&CallbackTest::Run,
                                        base::Unretained(&read_callback))));
   ++expected;
@@ -2901,7 +3039,10 @@ TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate)  {
   CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false);
   CallbackTest truncate_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->WriteData(0, 0, truncate_buffer, kReadBufferSize,
+            entry->WriteData(0,
+                             0,
+                             truncate_buffer.get(),
+                             kReadBufferSize,
                              base::Bind(&CallbackTest::Run,
                                         base::Unretained(&truncate_callback)),
                              true));
@@ -2938,7 +3079,10 @@ TEST_F(DiskCacheEntryTest, SimpleCacheInFlightRead) {
 
   CallbackTest write_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->WriteData(0, 0, write_buffer, kBufferSize,
+            entry->WriteData(0,
+                             0,
+                             write_buffer.get(),
+                             kBufferSize,
                              base::Bind(&CallbackTest::Run,
                                         base::Unretained(&write_callback)),
                              true));
@@ -2947,7 +3091,10 @@ TEST_F(DiskCacheEntryTest, SimpleCacheInFlightRead) {
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kBufferSize));
   CallbackTest read_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0, 0, read_buffer, kBufferSize,
+            entry->ReadData(0,
+                            0,
+                            read_buffer.get(),
+                            kBufferSize,
                             base::Bind(&CallbackTest::Run,
                                        base::Unretained(&read_callback))));
   ++expected;
diff --git a/net/disk_cache/file_posix.cc b/net/disk_cache/file_posix.cc
index 0295c0d..2ad3db9 100644
--- a/net/disk_cache/file_posix.cc
+++ b/net/disk_cache/file_posix.cc
@@ -118,7 +118,7 @@ void FileInFlightIO::PostRead(disk_cache::File *file, void* buf, size_t buf_len,
 
   base::WorkerPool::PostTask(FROM_HERE,
       base::Bind(&FileBackgroundIO::Read, operation.get()), true);
-  OnOperationPosted(operation);
+  OnOperationPosted(operation.get());
 }
 
 void FileInFlightIO::PostWrite(disk_cache::File* file, const void* buf,
@@ -130,7 +130,7 @@ void FileInFlightIO::PostWrite(disk_cache::File* file, const void* buf,
 
   base::WorkerPool::PostTask(FROM_HERE,
       base::Bind(&FileBackgroundIO::Write, operation.get()), true);
-  OnOperationPosted(operation);
+  OnOperationPosted(operation.get());
 }
 
 // Runs on the IO thread.
diff --git a/net/disk_cache/flash/flash_entry_impl.cc b/net/disk_cache/flash/flash_entry_impl.cc
index 3d64b03..01224029 100644
--- a/net/disk_cache/flash/flash_entry_impl.cc
+++ b/net/disk_cache/flash/flash_entry_impl.cc
@@ -31,14 +31,15 @@ FlashEntryImpl::FlashEntryImpl(int32 id,
 }
 
 int FlashEntryImpl::Init(const CompletionCallback& callback) {
-  if (new_internal_entry_) {
+  if (new_internal_entry_.get()) {
     DCHECK(callback.is_null());
     init_ = true;
     return net::OK;
   }
-  DCHECK(!callback.is_null() && old_internal_entry_);
+  DCHECK(!callback.is_null() && old_internal_entry_.get());
   callback_ = callback;
-  PostTaskAndReplyWithResult(cache_thread_, FROM_HERE,
+  PostTaskAndReplyWithResult(cache_thread_.get(),
+                             FROM_HERE,
                              Bind(&InternalEntry::Init, old_internal_entry_),
                              Bind(&FlashEntryImpl::OnInitComplete, this));
   return net::ERR_IO_PENDING;
diff --git a/net/disk_cache/flash/internal_entry.cc b/net/disk_cache/flash/internal_entry.cc
index 14659732..c6bae89 100644
--- a/net/disk_cache/flash/internal_entry.cc
+++ b/net/disk_cache/flash/internal_entry.cc
@@ -71,13 +71,13 @@ void InternalEntry::Close() {
 bool InternalEntry::WriteKey(LogStoreEntry* entry, const std::string& key) {
   int key_size = static_cast<int>(key.size());
   scoped_refptr<IOBuffer> key_buf(new StringIOBuffer(key));
-  return entry->WriteData(0, 0, key_buf, key_size) == key_size;
+  return entry->WriteData(0, 0, key_buf.get(), key_size) == key_size;
 }
 
 bool InternalEntry::ReadKey(LogStoreEntry* entry, std::string* key) {
   int key_size = entry->GetDataSize(0);
   scoped_refptr<net::IOBuffer> key_buf(new net::IOBuffer(key_size));
-  if (entry->ReadData(0, 0, key_buf, key_size) != key_size)
+  if (entry->ReadData(0, 0, key_buf.get(), key_size) != key_size)
     return false;
   key->assign(key_buf->data(), key_size);
   return true;
diff --git a/net/disk_cache/flash/log_store_entry_unittest.cc b/net/disk_cache/flash/log_store_entry_unittest.cc
index d15616f..100c9a8 100644
--- a/net/disk_cache/flash/log_store_entry_unittest.cc
+++ b/net/disk_cache/flash/log_store_entry_unittest.cc
@@ -29,7 +29,7 @@ TEST_F(FlashCacheTest, LogStoreEntryEmpty) {
     const int kSize = 1024;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
     EXPECT_EQ(0, entry->GetDataSize(i));
-    EXPECT_EQ(0, entry->ReadData(i, 0, buf, kSize));
+    EXPECT_EQ(0, entry->ReadData(i, 0, buf.get(), kSize));
   }
   EXPECT_TRUE(entry->Close());
   ASSERT_TRUE(log_store.Close());
@@ -49,7 +49,7 @@ TEST_F(FlashCacheTest, LogStoreEntryWriteRead) {
   for (int i = 0; i < disk_cache::kFlashLogStoreEntryNumStreams; ++i) {
     buffers[i] = new net::IOBuffer(sizes[i]);
     CacheTestFillBuffer(buffers[i]->data(), sizes[i], false);
-    EXPECT_EQ(sizes[i], entry->WriteData(i, 0, buffers[i], sizes[i]));
+    EXPECT_EQ(sizes[i], entry->WriteData(i, 0, buffers[i].get(), sizes[i]));
   }
   EXPECT_TRUE(entry->Close());
 
@@ -60,7 +60,7 @@ TEST_F(FlashCacheTest, LogStoreEntryWriteRead) {
   for (int i = 0; i < disk_cache::kFlashLogStoreEntryNumStreams; ++i) {
     EXPECT_EQ(sizes[i], entry->GetDataSize(i));
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(sizes[i]));
-    EXPECT_EQ(sizes[i], entry->ReadData(i, 0, buffer, sizes[i]));
+    EXPECT_EQ(sizes[i], entry->ReadData(i, 0, buffer.get(), sizes[i]));
     EXPECT_EQ(0, memcmp(buffers[i]->data(), buffer->data(), sizes[i]));
   }
   EXPECT_TRUE(entry->Close());
diff --git a/net/disk_cache/in_flight_backend_io.cc b/net/disk_cache/in_flight_backend_io.cc
index b5b0c8e..bc7a335 100644
--- a/net/disk_cache/in_flight_backend_io.cc
+++ b/net/disk_cache/in_flight_backend_io.cc
@@ -287,24 +287,34 @@ void BackendIO::ExecuteBackendOperation() {
 void BackendIO::ExecuteEntryOperation() {
   switch (operation_) {
     case OP_READ:
-      result_ = entry_->ReadDataImpl(
-          index_, offset_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, this));
+      result_ =
+          entry_->ReadDataImpl(index_,
+                               offset_,
+                               buf_.get(),
+                               buf_len_,
+                               base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_WRITE:
-      result_ = entry_->WriteDataImpl(
-          index_, offset_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, this),
-          truncate_);
+      result_ =
+          entry_->WriteDataImpl(index_,
+                                offset_,
+                                buf_.get(),
+                                buf_len_,
+                                base::Bind(&BackendIO::OnIOComplete, this),
+                                truncate_);
       break;
     case OP_READ_SPARSE:
       result_ = entry_->ReadSparseDataImpl(
-          offset64_, buf_, buf_len_,
+          offset64_,
+          buf_.get(),
+          buf_len_,
           base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_WRITE_SPARSE:
       result_ = entry_->WriteSparseDataImpl(
-          offset64_, buf_, buf_len_,
+          offset64_,
+          buf_.get(),
+          buf_len_,
           base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_GET_RANGE:
@@ -340,35 +350,35 @@ InFlightBackendIO::~InFlightBackendIO() {
 void InFlightBackendIO::Init(const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->Init();
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenEntry(const std::string& key, Entry** entry,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenEntry(key, entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CreateEntry(const std::string& key, Entry** entry,
                                     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->CreateEntry(key, entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntry(const std::string& key,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntry(key);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomAllEntries(
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomAllEntries();
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time,
@@ -376,69 +386,69 @@ void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time,
                         const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesBetween(initial_time, end_time);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesSince(
     const base::Time initial_time, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesSince(initial_time);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
                                       const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenNextEntry(iter, next_entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenPrevEntry(void** iter, Entry** prev_entry,
                                       const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenPrevEntry(iter, prev_entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::EndEnumeration(void* iterator) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->EndEnumeration(iterator);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OnExternalCacheHit(const std::string& key) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->OnExternalCacheHit(key);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CloseEntryImpl(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->CloseEntryImpl(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->DoomEntryImpl(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::FlushQueue(const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->FlushQueue();
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::RunTask(
     const base::Closure& task, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->RunTask(task);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset,
@@ -446,7 +456,7 @@ void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset,
                                  const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadData(entry, index, offset, buf, buf_len);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
@@ -455,7 +465,7 @@ void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteData(entry, index, offset, buf, buf_len, truncate);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadSparseData(
@@ -463,7 +473,7 @@ void InFlightBackendIO::ReadSparseData(
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadSparseData(entry, offset, buf, buf_len);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteSparseData(
@@ -471,7 +481,7 @@ void InFlightBackendIO::WriteSparseData(
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteSparseData(entry, offset, buf, buf_len);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::GetAvailableRange(
@@ -479,21 +489,21 @@ void InFlightBackendIO::GetAvailableRange(
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->GetAvailableRange(entry, offset, len, start);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->CancelSparseIO(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadyForSparseIO(
     EntryImpl* entry, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadyForSparseIO(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WaitForPendingIO() {
diff --git a/net/disk_cache/in_flight_io.cc b/net/disk_cache/in_flight_io.cc
index 51ad986..467814f 100644
--- a/net/disk_cache/in_flight_io.cc
+++ b/net/disk_cache/in_flight_io.cc
@@ -52,14 +52,14 @@ void InFlightIO::WaitForPendingIO() {
   while (!io_list_.empty()) {
     // Block the current thread until all pending IO completes.
     IOList::iterator it = io_list_.begin();
-    InvokeCallback(*it, true);
+    InvokeCallback(it->get(), true);
   }
 }
 
 void InFlightIO::DropPendingIO() {
   while (!io_list_.empty()) {
     IOList::iterator it = io_list_.begin();
-    BackgroundIO* operation = *it;
+    BackgroundIO* operation = it->get();
     operation->Cancel();
     DCHECK(io_list_.find(operation) != io_list_.end());
     io_list_.erase(make_scoped_refptr(operation));
diff --git a/net/disk_cache/mem_entry_impl.cc b/net/disk_cache/mem_entry_impl.cc
index 0d3b00a..9294212 100644
--- a/net/disk_cache/mem_entry_impl.cc
+++ b/net/disk_cache/mem_entry_impl.cc
@@ -378,8 +378,11 @@ int MemEntryImpl::InternalReadSparseData(int64 offset, IOBuffer* buf,
           CreateNetLogSparseReadWriteCallback(child->net_log().source(),
                                               io_buf->BytesRemaining()));
     }
-    int ret = child->ReadData(kSparseData, child_offset, io_buf,
-                              io_buf->BytesRemaining(), CompletionCallback());
+    int ret = child->ReadData(kSparseData,
+                              child_offset,
+                              io_buf.get(),
+                              io_buf->BytesRemaining(),
+                              CompletionCallback());
     if (net_log_.IsLoggingAllEvents()) {
       net_log_.EndEventWithNetErrorCode(
           net::NetLog::TYPE_SPARSE_READ_CHILD_DATA, ret);
@@ -440,8 +443,12 @@ int MemEntryImpl::InternalWriteSparseData(int64 offset, IOBuffer* buf,
     // previously written.
     // TODO(hclam): if there is data in the entry and this write is not
     // continuous we may want to discard this write.
-    int ret = child->WriteData(kSparseData, child_offset, io_buf, write_len,
-                               CompletionCallback(), true);
+    int ret = child->WriteData(kSparseData,
+                               child_offset,
+                               io_buf.get(),
+                               write_len,
+                               CompletionCallback(),
+                               true);
     if (net_log_.IsLoggingAllEvents()) {
       net_log_.EndEventWithNetErrorCode(
           net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA, ret);
diff --git a/net/disk_cache/sparse_control.cc b/net/disk_cache/sparse_control.cc
index 8c3d5dd..9f13678 100644
--- a/net/disk_cache/sparse_control.cc
+++ b/net/disk_cache/sparse_control.cc
@@ -255,7 +255,7 @@ int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
   if (offset + buf_len >= 0x1000000000LL || offset + buf_len < 0)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
-  DCHECK(!user_buf_);
+  DCHECK(!user_buf_.get());
   DCHECK(user_callback_.is_null());
 
   if (!buf && (op == kReadOperation || op == kWriteOperation))
@@ -383,9 +383,12 @@ int SparseControl::CreateSparseEntry() {
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
-  int rv = entry_->WriteData(
-      kSparseIndex, 0, buf, sizeof(sparse_header_), CompletionCallback(),
-      false);
+  int rv = entry_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(sparse_header_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(sparse_header_)) {
     DLOG(ERROR) << "Unable to save sparse_header_";
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
@@ -416,7 +419,7 @@ int SparseControl::OpenSparseEntry(int data_len) {
 
   // Read header.
   int rv = entry_->ReadData(
-      kSparseIndex, 0, buf, sizeof(sparse_header_), CompletionCallback());
+      kSparseIndex, 0, buf.get(), sizeof(sparse_header_), CompletionCallback());
   if (rv != static_cast<int>(sizeof(sparse_header_)))
     return net::ERR_CACHE_READ_FAILURE;
 
@@ -429,7 +432,10 @@ int SparseControl::OpenSparseEntry(int data_len) {
 
   // Read the actual bitmap.
   buf = new net::IOBuffer(map_len);
-  rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf, map_len,
+  rv = entry_->ReadData(kSparseIndex,
+                        sizeof(sparse_header_),
+                        buf.get(),
+                        map_len,
                         CompletionCallback());
   if (rv != map_len)
     return net::ERR_CACHE_READ_FAILURE;
@@ -472,8 +478,8 @@ bool SparseControl::OpenChild() {
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Read signature.
-  int rv = child_->ReadData(kSparseIndex, 0, buf, sizeof(child_data_),
-                            CompletionCallback());
+  int rv = child_->ReadData(
+      kSparseIndex, 0, buf.get(), sizeof(child_data_), CompletionCallback());
   if (rv != sizeof(child_data_))
     return KillChildAndContinue(key, true);  // This is a fatal failure.
 
@@ -496,9 +502,12 @@ void SparseControl::CloseChild() {
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Save the allocation bitmap before closing the child entry.
-  int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
+  int rv = child_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(child_data_),
                              CompletionCallback(),
-      false);
+                             false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   child_->Release();
@@ -567,8 +576,12 @@ void SparseControl::WriteSparseData() {
       reinterpret_cast<const char*>(children_map_.GetMap())));
 
   int len = children_map_.ArraySize() * 4;
-  int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf, len,
-                             CompletionCallback(), false);
+  int rv = entry_->WriteData(kSparseIndex,
+                             sizeof(sparse_header_),
+                             buf.get(),
+                             len,
+                             CompletionCallback(),
+                             false);
   if (rv != len) {
     DLOG(ERROR) << "Unable to save sparse map";
   }
@@ -671,8 +684,12 @@ void SparseControl::InitChildData() {
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
-  int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
-                             CompletionCallback(), false);
+  int rv = child_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(child_data_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   SetChildBit(true);
@@ -727,8 +744,8 @@ bool SparseControl::DoChildIO() {
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
-      rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_,
-                                child_len_, callback);
+      rv = child_->ReadDataImpl(
+          kSparseData, child_offset_, user_buf_.get(), child_len_, callback);
       break;
     case kWriteOperation:
       if (entry_->net_log().IsLoggingAllEvents()) {
@@ -737,8 +754,12 @@ bool SparseControl::DoChildIO() {
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
-      rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_,
-                                 child_len_, callback, false);
+      rv = child_->WriteDataImpl(kSparseData,
+                                 child_offset_,
+                                 user_buf_.get(),
+                                 child_len_,
+                                 callback,
+                                 false);
       break;
     case kGetRangeOperation:
       rv = DoGetAvailableRange();
@@ -827,7 +848,7 @@ void SparseControl::DoChildIOCompleted(int result) {
   buf_len_ -= result;
 
   // We'll be reusing the user provided buffer for the next chunk.
-  if (buf_len_ && user_buf_)
+  if (buf_len_ && user_buf_.get())
     user_buf_->DidConsume(result);
 }
 
diff --git a/net/disk_cache/storage_block_unittest.cc b/net/disk_cache/storage_block_unittest.cc
index 1aca003..6ad8189 100644
--- a/net/disk_cache/storage_block_unittest.cc
+++ b/net/disk_cache/storage_block_unittest.cc
@@ -15,7 +15,7 @@ TEST_F(DiskCacheTest, StorageBlock_LoadStore) {
   ASSERT_TRUE(CreateCacheTestFile(filename));
   ASSERT_TRUE(file->Init(filename, 8192));
 
-  disk_cache::CacheEntryBlock entry1(file, disk_cache::Addr(0xa0010001));
+  disk_cache::CacheEntryBlock entry1(file.get(), disk_cache::Addr(0xa0010001));
   memset(entry1.Data(), 0, sizeof(disk_cache::EntryStore));
   entry1.Data()->hash = 0xaa5555aa;
   entry1.Data()->rankings_node = 0xa0010002;
@@ -35,10 +35,10 @@ TEST_F(DiskCacheTest, StorageBlock_SetData) {
   ASSERT_TRUE(CreateCacheTestFile(filename));
   ASSERT_TRUE(file->Init(filename, 8192));
 
-  disk_cache::CacheEntryBlock entry1(file, disk_cache::Addr(0xa0010001));
+  disk_cache::CacheEntryBlock entry1(file.get(), disk_cache::Addr(0xa0010001));
   entry1.Data()->hash = 0xaa5555aa;
 
-  disk_cache::CacheEntryBlock entry2(file, disk_cache::Addr(0xa0010002));
+  disk_cache::CacheEntryBlock entry2(file.get(), disk_cache::Addr(0xa0010002));
   EXPECT_TRUE(entry2.Load());
   EXPECT_TRUE(entry2.Data() != NULL);
   EXPECT_TRUE(0 == entry2.Data()->hash);
@@ -56,14 +56,14 @@ TEST_F(DiskCacheTest, StorageBlock_SetModified) {
   ASSERT_TRUE(file->Init(filename, 8192));
 
   disk_cache::CacheEntryBlock* entry1 =
-      new disk_cache::CacheEntryBlock(file, disk_cache::Addr(0xa0010003));
+      new disk_cache::CacheEntryBlock(file.get(), disk_cache::Addr(0xa0010003));
   EXPECT_TRUE(entry1->Load());
   EXPECT_TRUE(0 == entry1->Data()->hash);
   entry1->Data()->hash = 0x45687912;
   entry1->set_modified();
   delete entry1;
 
-  disk_cache::CacheEntryBlock entry2(file, disk_cache::Addr(0xa0010003));
+  disk_cache::CacheEntryBlock entry2(file.get(), disk_cache::Addr(0xa0010003));
   EXPECT_TRUE(entry2.Load());
   EXPECT_TRUE(0x45687912 == entry2.Data()->hash);
 }
diff --git a/net/disk_cache/stress_cache.cc b/net/disk_cache/stress_cache.cc
index 59abe2a..d5cbd98a 100644
--- a/net/disk_cache/stress_cache.cc
+++ b/net/disk_cache/stress_cache.cc
@@ -168,7 +168,8 @@ void StressTheCache(int iteration) {
     base::snprintf(buffer->data(), kSize,
                    "i: %d iter: %d, size: %d, truncate: %d     ", i, iteration,
                    size, truncate ? 1 : 0);
-    rv = entries[slot]->WriteData(0, 0, buffer, size, cb.callback(), truncate);
+    rv = entries[slot]
+        ->WriteData(0, 0, buffer.get(), size, cb.callback(), truncate);
     CHECK_EQ(size, cb.GetResult(rv));
 
     if (rand() % 100 > 80) {
diff --git a/net/dns/dns_client.cc b/net/dns/dns_client.cc
index 7d8d42b..976f153 100644
--- a/net/dns/dns_client.cc
+++ b/net/dns/dns_client.cc
@@ -36,7 +36,7 @@ class DnsClientImpl : public DnsClient {
                                 socket_pool.Pass(),
                                 base::Bind(&base::RandInt),
                                 net_log_);
-      factory_ = DnsTransactionFactory::CreateFactory(session_);
+      factory_ = DnsTransactionFactory::CreateFactory(session_.get());
     }
   }
 
diff --git a/net/dns/dns_query.h b/net/dns/dns_query.h
index dc5f8e8..a2ed868 100644
--- a/net/dns/dns_query.h
+++ b/net/dns/dns_query.h
@@ -36,7 +36,7 @@ class NET_EXPORT_PRIVATE DnsQuery {
   base::StringPiece question() const;
 
   // IOBuffer accessor to be used for writing out the query.
-  IOBufferWithSize* io_buffer() const { return io_buffer_; }
+  IOBufferWithSize* io_buffer() const { return io_buffer_.get(); }
 
  private:
   DnsQuery(const DnsQuery& orig, uint16 id);
diff --git a/net/dns/dns_transaction.cc b/net/dns/dns_transaction.cc
index e13f118..8001b0a 100644
--- a/net/dns/dns_transaction.cc
+++ b/net/dns/dns_transaction.cc
@@ -394,7 +394,8 @@ class DnsTCPAttempt : public DnsAttempt {
       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;
   }
@@ -407,10 +408,10 @@ class DnsTCPAttempt : public DnsAttempt {
     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());
@@ -426,12 +427,13 @@ class DnsTCPAttempt : public DnsAttempt {
     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;
   }
@@ -444,10 +446,10 @@ class DnsTCPAttempt : public DnsAttempt {
     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.)
@@ -468,10 +470,10 @@ class DnsTCPAttempt : public DnsAttempt {
     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;
@@ -534,7 +536,7 @@ class DnsTransactionImpl : public DnsTransaction,
       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_));
@@ -937,11 +939,8 @@ class DnsTransactionFactoryImpl : public DnsTransactionFactory {
       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:
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index 0f00ceb..7845e0b 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -562,10 +562,10 @@ class HostResolverImpl::ProcTask
         completed_attempt_error_(ERR_UNEXPECTED),
         had_non_speculative_request_(false),
         net_log_(job_net_log) {
-    if (!params_.resolver_proc)
+    if (!params_.resolver_proc.get())
       params_.resolver_proc = HostResolverProc::GetDefault();
     // If default is unset, use the system proc.
-    if (!params_.resolver_proc)
+    if (!params_.resolver_proc.get())
       params_.resolver_proc = new SystemHostResolverProc();
   }
 
@@ -1260,7 +1260,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job {
     // TODO(szym): Check if this is still needed.
     if (!req->info().is_speculative()) {
       had_non_speculative_request_ = true;
-      if (proc_task_)
+      if (proc_task_.get())
         proc_task_->set_had_non_speculative_request();
     }
 
@@ -2202,9 +2202,8 @@ bool HostResolverImpl::HaveDnsConfig() const {
   // ScopedDefaultHostResolverProc.
   // The alternative is to use NetworkChangeNotifier to override DnsConfig,
   // but that would introduce construction order requirements for NCN and SDHRP.
-  return (dns_client_.get() != NULL) &&
-         (dns_client_->GetConfig() != NULL) &&
-         !(proc_params_.resolver_proc == NULL &&
+  return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL) &&
+         !(proc_params_.resolver_proc.get() == NULL &&
            HostResolverProc::GetDefault() != NULL);
 }
 
diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc
index b677af4..74c16f3 100644
--- a/net/dns/host_resolver_impl_unittest.cc
+++ b/net/dns/host_resolver_impl_unittest.cc
@@ -436,17 +436,16 @@ class HostResolverImplTest : public testing::Test {
   };
 
   void CreateResolver() {
-    resolver_.reset(new HostResolverImpl(
-        HostCache::CreateDefaultCache(),
-        DefaultLimits(),
-        DefaultParams(proc_),
-        NULL));
+    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
+                                         DefaultLimits(),
+                                         DefaultParams(proc_.get()),
+                                         NULL));
   }
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time and
   // perform no retries.
   void CreateSerialResolver() {
-    HostResolverImpl::ProcTaskParams params = DefaultParams(proc_);
+    HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
     params.max_retry_attempts = 0u;
     PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
     resolver_.reset(new HostResolverImpl(
@@ -781,11 +780,10 @@ TEST_F(HostResolverImplTest, StartWithinCallback) {
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
-  resolver_.reset(new HostResolverImpl(
-      scoped_ptr<HostCache>(),
-      DefaultLimits(),
-      DefaultParams(proc_),
-      NULL));
+  resolver_.reset(new HostResolverImpl(scoped_ptr<HostCache>(),
+                                       DefaultLimits(),
+                                       DefaultParams(proc_.get()),
+                                       NULL));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
@@ -1270,11 +1268,10 @@ class HostResolverImplDnsTest : public HostResolverImplTest {
   }
 
   void CreateResolver() {
-    resolver_.reset(new HostResolverImpl(
-        HostCache::CreateDefaultCache(),
-        DefaultLimits(),
-        DefaultParams(proc_),
-        NULL));
+    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
+                                         DefaultLimits(),
+                                         DefaultParams(proc_.get()),
+                                         NULL));
     resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   }
 
@@ -1514,7 +1511,7 @@ TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
   resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
                                        DefaultLimits(),
-                                       DefaultParams(proc),
+                                       DefaultParams(proc.get()),
                                        NULL));
   resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
diff --git a/net/dns/host_resolver_proc.cc b/net/dns/host_resolver_proc.cc
index fed3e07..f2b10c6 100644
--- a/net/dns/host_resolver_proc.cc
+++ b/net/dns/host_resolver_proc.cc
@@ -75,9 +75,9 @@ int HostResolverProc::ResolveUsingPrevious(
     HostResolverFlags host_resolver_flags,
     AddressList* addrlist,
     int* os_error) {
-  if (previous_proc_) {
-    return previous_proc_->Resolve(host, address_family, host_resolver_flags,
-                                   addrlist, os_error);
+  if (previous_proc_.get()) {
+    return previous_proc_->Resolve(
+        host, address_family, host_resolver_flags, addrlist, os_error);
   }
 
   // Final fallback is the system resolver.
@@ -86,7 +86,7 @@ int HostResolverProc::ResolveUsingPrevious(
 }
 
 void HostResolverProc::SetPreviousProc(HostResolverProc* proc) {
-  HostResolverProc* current_previous = previous_proc_;
+  HostResolverProc* current_previous = previous_proc_.get();
   previous_proc_ = NULL;
   // Now that we've guaranteed |this| is the last proc in a chain, we can
   // detect potential cycles using GetLastProc().
@@ -102,8 +102,8 @@ HostResolverProc* HostResolverProc::GetLastProc(HostResolverProc* proc) {
   if (proc == NULL)
     return NULL;
   HostResolverProc* last_proc = proc;
-  while (last_proc->previous_proc_ != NULL)
-    last_proc = last_proc->previous_proc_;
+  while (last_proc->previous_proc_.get() != NULL)
+    last_proc = last_proc->previous_proc_.get();
   return last_proc;
 }
 
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index 7fe0adb..93cfd3c 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -424,15 +424,16 @@ ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc(
 }
 
 ScopedDefaultHostResolverProc::~ScopedDefaultHostResolverProc() {
-  HostResolverProc* old_proc = HostResolverProc::SetDefault(previous_proc_);
+  HostResolverProc* old_proc =
+      HostResolverProc::SetDefault(previous_proc_.get());
   // The lifetimes of multiple instances must be nested.
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
-  previous_proc_ = HostResolverProc::SetDefault(current_proc_);
-  current_proc_->SetLastProc(previous_proc_);
+  previous_proc_ = HostResolverProc::SetDefault(current_proc_.get());
+  current_proc_->SetLastProc(previous_proc_.get());
 }
 
 }  // namespace net
diff --git a/net/dns/mock_host_resolver.h b/net/dns/mock_host_resolver.h
index d22e800c..b73bd0a 100644
--- a/net/dns/mock_host_resolver.h
+++ b/net/dns/mock_host_resolver.h
@@ -57,7 +57,7 @@ class MockHostResolverBase : public HostResolver,
  public:
   virtual ~MockHostResolverBase();
 
-  RuleBasedHostResolverProc* rules() { return rules_; }
+  RuleBasedHostResolverProc* rules() { return rules_.get(); }
   void set_rules(RuleBasedHostResolverProc* rules) { rules_ = rules; }
 
   // Controls whether resolutions complete synchronously or asynchronously.
diff --git a/net/dns/serial_worker.h b/net/dns/serial_worker.h
index 982286f..59a4d3f 100644
--- a/net/dns/serial_worker.h
+++ b/net/dns/serial_worker.h
@@ -61,9 +61,7 @@ class NET_EXPORT_PRIVATE SerialWorker
   // Executed on origin thread after |DoRead| completes.
   virtual void OnWorkFinished() = 0;
 
-  base::MessageLoopProxy* loop() {
-    return message_loop_;
-  }
+  base::MessageLoopProxy* loop() { return message_loop_.get(); }
 
  private:
   enum State {
diff --git a/net/ftp/ftp_network_layer.cc b/net/ftp/ftp_network_layer.cc
index df53a09..098fb9f 100644
--- a/net/ftp/ftp_network_layer.cc
+++ b/net/ftp/ftp_network_layer.cc
@@ -1,6 +1,6 @@
-// Copyright (c) 2008 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.
+// Copyright (c) 2008 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/ftp/ftp_network_layer.h"
 
@@ -28,8 +28,8 @@ FtpTransaction* FtpNetworkLayer::CreateTransaction() {
   if (suspended_)
     return NULL;
 
-  return new FtpNetworkTransaction(
-      session_, ClientSocketFactory::GetDefaultFactory());
+  return new FtpNetworkTransaction(session_.get(),
+                                   ClientSocketFactory::GetDefaultFactory());
 }
 
 void FtpNetworkLayer::Suspend(bool suspend) {
diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc
index f218ae1..0cf42c3 100644
--- a/net/ftp/ftp_network_transaction.cc
+++ b/net/ftp/ftp_network_transaction.cc
@@ -339,7 +339,7 @@ void FtpNetworkTransaction::ResetStateForRestart() {
   ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer(net_log_));
   read_data_buf_ = NULL;
   read_data_buf_len_ = 0;
-  if (write_buf_)
+  if (write_buf_.get())
     write_buf_->SetOffset(0);
   last_error_ = OK;
   data_connection_port_ = 0;
@@ -459,8 +459,8 @@ int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
   // which responses are for which command.
   DCHECK(!ctrl_response_buffer_->ResponseAvailable());
 
-  DCHECK(!write_command_buf_);
-  DCHECK(!write_buf_);
+  DCHECK(!write_command_buf_.get());
+  DCHECK(!write_buf_.get());
 
   if (!IsValidFTPCommandString(command)) {
     // Callers should validate the command themselves and return a more specific
@@ -472,7 +472,7 @@ int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
   command_sent_ = cmd;
 
   write_command_buf_ = new IOBufferWithSize(command.length() + 2);
-  write_buf_ = new DrainableIOBuffer(write_command_buf_,
+  write_buf_ = new DrainableIOBuffer(write_command_buf_.get(),
                                      write_command_buf_->size());
   memcpy(write_command_buf_->data(), command.data(), command.length());
   memcpy(write_command_buf_->data() + command.length(), kCRLF, 2);
@@ -697,7 +697,7 @@ int FtpNetworkTransaction::DoCtrlConnectComplete(int result) {
 
 int FtpNetworkTransaction::DoCtrlRead() {
   next_state_ = STATE_CTRL_READ_COMPLETE;
-  return ctrl_socket_->Read(read_ctrl_buf_, kCtrlBufLen, io_callback_);
+  return ctrl_socket_->Read(read_ctrl_buf_.get(), kCtrlBufLen, io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlReadComplete(int result) {
@@ -728,9 +728,8 @@ int FtpNetworkTransaction::DoCtrlReadComplete(int result) {
 int FtpNetworkTransaction::DoCtrlWrite() {
   next_state_ = STATE_CTRL_WRITE_COMPLETE;
 
-  return ctrl_socket_->Write(write_buf_,
-                             write_buf_->BytesRemaining(),
-                             io_callback_);
+  return ctrl_socket_->Write(
+      write_buf_.get(), write_buf_->BytesRemaining(), io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlWriteComplete(int result) {
@@ -1283,7 +1282,7 @@ int FtpNetworkTransaction::DoDataConnectComplete(int result) {
 }
 
 int FtpNetworkTransaction::DoDataRead() {
-  DCHECK(read_data_buf_);
+  DCHECK(read_data_buf_.get());
   DCHECK_GT(read_data_buf_len_, 0);
 
   if (data_socket_ == NULL || !data_socket_->IsConnected()) {
@@ -1304,7 +1303,8 @@ int FtpNetworkTransaction::DoDataRead() {
 
   next_state_ = STATE_DATA_READ_COMPLETE;
   read_data_buf_->data()[0] = 0;
-  return data_socket_->Read(read_data_buf_, read_data_buf_len_, io_callback_);
+  return data_socket_->Read(
+      read_data_buf_.get(), read_data_buf_len_, io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataReadComplete(int result) {
diff --git a/net/http/http_auth_controller.cc b/net/http/http_auth_controller.cc
index ae39640..00b30d75 100644
--- a/net/http/http_auth_controller.cc
+++ b/net/http/http_auth_controller.cc
@@ -251,7 +251,7 @@ int HttpAuthController::HandleAuthChallenge(
     bool establishing_tunnel,
     const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
-  DCHECK(headers);
+  DCHECK(headers.get());
   DCHECK(auth_origin_.is_valid());
   VLOG(1) << "The " << HttpAuth::GetAuthTargetString(target_) << " "
           << auth_origin_ << " requested auth "
@@ -263,8 +263,12 @@ int HttpAuthController::HandleAuthChallenge(
   // case.
   if (HaveAuth()) {
     std::string challenge_used;
-    HttpAuth::AuthorizationResult result = HttpAuth::HandleChallengeResponse(
-        handler_.get(), headers, target_, disabled_schemes_, &challenge_used);
+    HttpAuth::AuthorizationResult result =
+        HttpAuth::HandleChallengeResponse(handler_.get(),
+                                          headers.get(),
+                                          target_,
+                                          disabled_schemes_,
+                                          &challenge_used);
     switch (result) {
       case HttpAuth::AUTHORIZATION_RESULT_ACCEPT:
         break;
@@ -314,8 +318,11 @@ int HttpAuthController::HandleAuthChallenge(
     if (!handler_.get() && can_send_auth) {
       // Find the best authentication challenge that we support.
       HttpAuth::ChooseBestChallenge(http_auth_handler_factory_,
-                                    headers, target_, auth_origin_,
-                                    disabled_schemes_, net_log,
+                                    headers.get(),
+                                    target_,
+                                    auth_origin_,
+                                    disabled_schemes_,
+                                    net_log,
                                     &handler_);
       if (handler_.get())
         HistogramAuthEvent(handler_.get(), AUTH_EVENT_START);
diff --git a/net/http/http_basic_stream.cc b/net/http/http_basic_stream.cc
index 76ec06a..3eb3f98 100644
--- a/net/http/http_basic_stream.cc
+++ b/net/http/http_basic_stream.cc
@@ -35,8 +35,8 @@ int HttpBasicStream::InitializeStream(
     const CompletionCallback& callback) {
   DCHECK(!parser_.get());
   request_info_ = request_info;
-  parser_.reset(new HttpStreamParser(connection_.get(), request_info,
-                                     read_buf_, net_log));
+  parser_.reset(new HttpStreamParser(
+      connection_.get(), request_info, read_buf_.get(), net_log));
   return OK;
 }
 
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index b689c9e..6fe5a81 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -76,8 +76,14 @@ int HttpCache::DefaultBackend::CreateBackend(
     NetLog* net_log, disk_cache::Backend** backend,
     const CompletionCallback& callback) {
   DCHECK_GE(max_bytes_, 0);
-  return disk_cache::CreateCacheBackend(type_, backend_type_, path_, max_bytes_,
-                                        true, thread_, net_log, backend,
+  return disk_cache::CreateCacheBackend(type_,
+                                        backend_type_,
+                                        path_,
+                                        max_bytes_,
+                                        true,
+                                        thread_.get(),
+                                        net_log,
+                                        backend,
                                         callback);
 }
 
@@ -242,7 +248,8 @@ void HttpCache::MetadataWriter::VerifyResponse(int result) {
     return SelfDestroy();
 
   result = transaction_->WriteMetadata(
-      buf_, buf_len_,
+      buf_.get(),
+      buf_len_,
       base::Bind(&MetadataWriter::OnIOComplete, base::Unretained(this)));
   if (result != ERR_IO_PENDING)
     SelfDestroy();
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index 82b3078..3a23682 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -360,7 +360,7 @@ int HttpCache::Transaction::RestartWithCertificate(
 int HttpCache::Transaction::RestartWithAuth(
     const AuthCredentials& credentials,
     const CompletionCallback& callback) {
-  DCHECK(auth_response_.headers);
+  DCHECK(auth_response_.headers.get());
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
@@ -400,7 +400,7 @@ int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len,
   // If we have an intermediate auth response at this point, then it means the
   // user wishes to read the network response (the error page).  If there is a
   // previous response in the cache then we should leave it intact.
-  if (auth_response_.headers && mode_ != NONE) {
+  if (auth_response_.headers.get() && mode_ != NONE) {
     UpdateTransactionPattern(PATTERN_NOT_COVERED);
     DCHECK(mode_ & WRITE);
     DoneWritingToEntry(mode_ == READ_WRITE);
@@ -464,10 +464,12 @@ void HttpCache::Transaction::DoneReading() {
 
 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
   // Null headers means we encountered an error or haven't a response yet
-  if (auth_response_.headers)
+  if (auth_response_.headers.get())
     return &auth_response_;
-  return (response_.headers || response_.ssl_info.cert ||
-          response_.cert_request_info) ? &response_ : NULL;
+  return (response_.headers.get() || response_.ssl_info.cert.get() ||
+          response_.cert_request_info.get())
+             ? &response_
+             : NULL;
 }
 
 LoadState HttpCache::Transaction::GetLoadState() const {
@@ -918,7 +920,7 @@ int HttpCache::Transaction::DoSuccessfulSendRequest() {
   }
 
   new_response_ = new_response;
-  if (!ValidatePartialResponse() && !auth_response_.headers) {
+  if (!ValidatePartialResponse() && !auth_response_.headers.get()) {
     // Something went wrong with this request and we have to restart it.
     // If we have an authentication response, we are exposed to weird things
     // hapenning if the user cancels the authentication before we receive
@@ -982,7 +984,7 @@ int HttpCache::Transaction::DoSuccessfulSendRequest() {
 int HttpCache::Transaction::DoNetworkRead() {
   ReportNetworkActionStart();
   next_state_ = STATE_NETWORK_READ_COMPLETE;
-  return network_trans_->Read(read_buf_, io_buf_len_, io_callback_);
+  return network_trans_->Read(read_buf_.get(), io_buf_len_, io_callback_);
 }
 
 int HttpCache::Transaction::DoNetworkReadComplete(int result) {
@@ -1238,7 +1240,7 @@ int HttpCache::Transaction::DoUpdateCachedResponse() {
   int rv = OK;
   // Update cached response based on headers in new_response.
   // TODO(wtc): should we update cached certificate (response_.ssl_info), too?
-  response_.headers->Update(*new_response_->headers);
+  response_.headers->Update(*new_response_->headers.get());
   response_.response_time = new_response_->response_time;
   response_.request_time = new_response_->request_time;
   response_.network_accessed = new_response_->network_accessed;
@@ -1301,7 +1303,7 @@ int HttpCache::Transaction::DoOverwriteCachedResponse() {
 
   // We change the value of Content-Length for partial content.
   if (handling_206_ && partial_.get())
-    partial_->FixContentLength(new_response_->headers);
+    partial_->FixContentLength(new_response_->headers.get());
 
   response_ = *new_response_;
 
@@ -1309,7 +1311,7 @@ int HttpCache::Transaction::DoOverwriteCachedResponse() {
     // There is no point in storing this resource because it will never be used.
     DoneWritingToEntry(false);
     if (partial_.get())
-      partial_->FixResponseHeaders(response_.headers, true);
+      partial_->FixResponseHeaders(response_.headers.get(), true);
     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
     return OK;
   }
@@ -1392,7 +1394,7 @@ int HttpCache::Transaction::DoPartialHeadersReceived() {
   } else if (mode_ != NONE) {
     // We are about to return the headers for a byte-range request to the user,
     // so let's fix them.
-    partial_->FixResponseHeaders(response_.headers, true);
+    partial_->FixResponseHeaders(response_.headers.get(), true);
   }
   return OK;
 }
@@ -1406,9 +1408,8 @@ int HttpCache::Transaction::DoCacheReadResponse() {
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
   ReportCacheActionStart();
-  return ResetCacheIOStart(
-      entry_->disk_entry->ReadData(kResponseInfoIndex, 0, read_buf_,
-                                   io_buf_len_, io_callback_));
+  return ResetCacheIOStart(entry_->disk_entry->ReadData(
+      kResponseInfoIndex, 0, read_buf_.get(), io_buf_len_, io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheReadResponseComplete(int result) {
@@ -1496,7 +1497,7 @@ int HttpCache::Transaction::DoCacheWriteResponseComplete(int result) {
 
 int HttpCache::Transaction::DoCacheReadMetadata() {
   DCHECK(entry_);
-  DCHECK(!response_.metadata);
+  DCHECK(!response_.metadata.get());
   next_state_ = STATE_CACHE_READ_METADATA_COMPLETE;
 
   response_.metadata =
@@ -1505,7 +1506,9 @@ int HttpCache::Transaction::DoCacheReadMetadata() {
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
   ReportCacheActionStart();
   return ResetCacheIOStart(
-      entry_->disk_entry->ReadData(kMetadataIndex, 0, response_.metadata,
+      entry_->disk_entry->ReadData(kMetadataIndex,
+                                   0,
+                                   response_.metadata.get(),
                                    response_.metadata->size(),
                                    io_callback_));
 }
@@ -1542,14 +1545,15 @@ int HttpCache::Transaction::DoCacheReadData() {
     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_DATA);
   ReportCacheActionStart();
   if (partial_.get()) {
-    return ResetCacheIOStart(
-        partial_->CacheRead(entry_->disk_entry, read_buf_, io_buf_len_,
-                            io_callback_));
+    return ResetCacheIOStart(partial_->CacheRead(
+        entry_->disk_entry, read_buf_.get(), io_buf_len_, io_callback_));
   }
 
-  return ResetCacheIOStart(
-      entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                   read_buf_, io_buf_len_, io_callback_));
+  return ResetCacheIOStart(entry_->disk_entry->ReadData(kResponseContentIndex,
+                                                        read_offset_,
+                                                        read_buf_.get(),
+                                                        io_buf_len_,
+                                                        io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheReadDataComplete(int result) {
@@ -1591,7 +1595,7 @@ int HttpCache::Transaction::DoCacheWriteData(int num_bytes) {
   }
 
   return ResetCacheIOStart(
-      AppendResponseDataToEntry(read_buf_, num_bytes, io_callback_));
+      AppendResponseDataToEntry(read_buf_.get(), num_bytes, io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheWriteDataComplete(int result) {
@@ -1867,8 +1871,8 @@ int HttpCache::Transaction::BeginPartialCacheValidation() {
 int HttpCache::Transaction::ValidateEntryHeadersAndContinue() {
   DCHECK(mode_ == READ_WRITE);
 
-  if (!partial_->UpdateFromStoredHeaders(response_.headers, entry_->disk_entry,
-                                         truncated_)) {
+  if (!partial_->UpdateFromStoredHeaders(
+          response_.headers.get(), entry_->disk_entry, truncated_)) {
     return DoRestartPartialRequest();
   }
 
@@ -1962,7 +1966,8 @@ bool HttpCache::Transaction::RequiresValidation() {
     return false;
 
   if (response_.vary_data.is_valid() &&
-      !response_.vary_data.MatchesRequest(*request_, *response_.headers)) {
+      !response_.vary_data.MatchesRequest(*request_,
+                                          *response_.headers.get())) {
     vary_mismatch_ = true;
     return true;
   }
@@ -1985,7 +1990,7 @@ bool HttpCache::Transaction::RequiresValidation() {
 }
 
 bool HttpCache::Transaction::ConditionalizeRequest() {
-  DCHECK(response_.headers);
+  DCHECK(response_.headers.get());
 
   if (request_->method == "PUT" || request_->method == "DELETE")
     return false;
@@ -2074,7 +2079,7 @@ bool HttpCache::Transaction::ConditionalizeRequest() {
 // time it is called it will return true so that we don't keep retrying the
 // request.
 bool HttpCache::Transaction::ValidatePartialResponse() {
-  const HttpResponseHeaders* headers = new_response_->headers;
+  const HttpResponseHeaders* headers = new_response_->headers.get();
   int response_code = headers->response_code();
   bool partial_response = (response_code == 206);
   handling_206_ = false;
@@ -2184,7 +2189,7 @@ void HttpCache::Transaction::IgnoreRangeRequest() {
 
 void HttpCache::Transaction::FailRangeRequest() {
   response_ = *new_response_;
-  partial_->FixResponseHeaders(response_.headers, false);
+  partial_->FixResponseHeaders(response_.headers.get(), false);
 }
 
 int HttpCache::Transaction::SetupEntryForRead() {
@@ -2275,9 +2280,8 @@ int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
   data->Done();
 
   io_buf_len_ = data->pickle()->size();
-  return ResetCacheIOStart(
-      entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data,
-                                    io_buf_len_, io_callback_, true));
+  return ResetCacheIOStart(entry_->disk_entry->WriteData(
+      kResponseInfoIndex, 0, data.get(), io_buf_len_, io_callback_, true));
 }
 
 int HttpCache::Transaction::AppendResponseDataToEntry(
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index 8c0f55d..2a686f2 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -543,7 +543,7 @@ void CreateTruncatedEntry(std::string raw_headers, MockHttpCache* cache) {
   int len = static_cast<int>(base::strlcpy(buf->data(),
                                            "rg: 00-09 rg: 10-19 ", 100));
   net::TestCompletionCallback cb;
-  int rv = entry->WriteData(1, 0, buf, len, cb.callback(), true);
+  int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
   EXPECT_EQ(len, cb.GetResult(rv));
   entry->Close();
 }
@@ -682,12 +682,12 @@ TEST(HttpCache, ReleaseBuffer) {
 
   const int kBufferSize = 10;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
-  net::ReleaseBufferCompletionCallback cb(buffer);
+  net::ReleaseBufferCompletionCallback cb(buffer.get());
 
   rv = trans->Start(&request, cb.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, cb.GetResult(rv));
 
-  rv = trans->Read(buffer, kBufferSize, cb.callback());
+  rv = trans->Read(buffer.get(), kBufferSize, cb.callback());
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
 }
 
@@ -1748,7 +1748,7 @@ TEST(HttpCache, SimpleGET_AbandonedCacheRead) {
   ASSERT_EQ(net::OK, rv);
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  rv = trans->Read(buf, 256, callback.callback());
+  rv = trans->Read(buf.get(), 256, callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Test that destroying the transaction while it is reading from the cache
@@ -3886,7 +3886,7 @@ TEST(HttpCache, GET_Previous206_NotSparse) {
   int len = static_cast<int>(base::strlcpy(buf->data(),
                                            kRangeGET_TransactionOK.data, 500));
   net::TestCompletionCallback cb;
-  int rv = entry->WriteData(1, 0, buf, len, cb.callback(), true);
+  int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
   EXPECT_EQ(len, cb.GetResult(rv));
   entry->Close();
 
@@ -3934,7 +3934,7 @@ TEST(HttpCache, RangeGET_Previous206_NotSparse_2) {
   int len = static_cast<int>(base::strlcpy(buf->data(),
                                            kRangeGET_TransactionOK.data, 500));
   net::TestCompletionCallback cb;
-  int rv = entry->WriteData(1, 0, buf, len, cb.callback(), true);
+  int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
   EXPECT_EQ(len, cb.GetResult(rv));
   entry->Close();
 
@@ -3976,7 +3976,7 @@ TEST(HttpCache, GET_Previous206_NotValidation) {
   int len = static_cast<int>(base::strlcpy(buf->data(),
                                            kRangeGET_TransactionOK.data, 500));
   net::TestCompletionCallback cb;
-  int rv = entry->WriteData(1, 0, buf, len, cb.callback(), true);
+  int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
   EXPECT_EQ(len, cb.GetResult(rv));
   entry->Close();
 
@@ -4160,7 +4160,7 @@ TEST(HttpCache, RangeGET_Cancel) {
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
@@ -4201,9 +4201,9 @@ TEST(HttpCache, RangeGET_Cancel2) {
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Destroy the transaction before completing the read.
@@ -4247,9 +4247,9 @@ TEST(HttpCache, RangeGET_Cancel3) {
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Destroy the transaction before completing the read.
@@ -4666,7 +4666,7 @@ TEST(HttpCache, DoomOnDestruction2) {
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
@@ -4710,7 +4710,7 @@ TEST(HttpCache, DoomOnDestruction3) {
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
@@ -4760,13 +4760,13 @@ TEST(HttpCache, SetTruncatedFlag) {
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // We want to cancel the request when the transaction is busy.
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   EXPECT_FALSE(c->callback.have_result());
 
@@ -4827,7 +4827,7 @@ TEST(HttpCache, DontSetTruncatedFlag) {
 
   // Read everything.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(22));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(buf->size(), c->callback.GetResult(rv));
 
   // Destroy the transaction.
@@ -4984,7 +4984,7 @@ TEST(HttpCache, GET_IncompleteResource_Cancel) {
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
-  rv = c->trans->Read(buf, buf->size(), c->callback.callback());
+  rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
 
   // Cancel the requests.
@@ -5140,9 +5140,9 @@ TEST(HttpCache, GET_CancelIncompleteResource) {
 
   // Read 20 bytes from the cache, and 10 from the net.
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(100));
-  rv = c->trans->Read(buf, 20, c->callback.callback());
+  rv = c->trans->Read(buf.get(), 20, c->callback.callback());
   EXPECT_EQ(20, c->callback.GetResult(rv));
-  rv = c->trans->Read(buf, 10, c->callback.callback());
+  rv = c->trans->Read(buf.get(), 10, c->callback.callback());
   EXPECT_EQ(10, c->callback.GetResult(rv));
 
   // At this point, we are already reading so canceling the request should leave
@@ -5553,7 +5553,9 @@ TEST(HttpCache, WriteMetadata_OK) {
   base::strlcpy(buf->data(), "Hi there", buf->size());
   cache.http_cache()->WriteMetadata(GURL(kSimpleGET_Transaction.url),
                                     net::DEFAULT_PRIORITY,
-                                    response.response_time, buf, buf->size());
+                                    response.response_time,
+                                    buf.get(),
+                                    buf->size());
 
   // Release the buffer before the operation takes place.
   buf = NULL;
@@ -5590,7 +5592,9 @@ TEST(HttpCache, WriteMetadata_Fail) {
                              base::TimeDelta::FromMilliseconds(20);
   cache.http_cache()->WriteMetadata(GURL(kSimpleGET_Transaction.url),
                                     net::DEFAULT_PRIORITY,
-                                    expected_time, buf, buf->size());
+                                    expected_time,
+                                    buf.get(),
+                                    buf->size());
 
   // Makes sure we finish pending operations.
   base::MessageLoop::current()->RunUntilIdle();
@@ -5621,7 +5625,9 @@ TEST(HttpCache, ReadMetadata) {
   base::strlcpy(buf->data(), "Hi there", buf->size());
   cache.http_cache()->WriteMetadata(GURL(kTypicalGET_Transaction.url),
                                     net::DEFAULT_PRIORITY,
-                                    response.response_time, buf, buf->size());
+                                    response.response_time,
+                                    buf.get(),
+                                    buf->size());
 
   // Makes sure we finish pending operations.
   base::MessageLoop::current()->RunUntilIdle();
@@ -5683,7 +5689,7 @@ TEST(HttpCache, FilterCompletion) {
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
 
     // Now make sure that the entry is preserved.
@@ -5717,15 +5723,15 @@ TEST(HttpCache, StopCachingDeletesEntry) {
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-    rv = trans->Read(buf, 10, callback.callback());
+    rv = trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
     trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 0);
   }
 
@@ -5763,15 +5769,15 @@ TEST(HttpCache, StopCachingSavesEntry) {
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-    rv = trans->Read(buf, 10, callback.callback());
+    rv = trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
     trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 0);
 
     RemoveMockTransaction(&mock_transaction);
@@ -5814,18 +5820,18 @@ TEST(HttpCache, StopCachingTruncatedEntry) {
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-    rv = trans->Read(buf, 10, callback.callback());
+    rv = trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
     // This is actually going to do nothing.
     trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 0);
   }
 
diff --git a/net/http/http_network_layer.cc b/net/http/http_network_layer.cc
index e99cf5b..5fa5c81 100644
--- a/net/http/http_network_layer.cc
+++ b/net/http/http_network_layer.cc
@@ -62,14 +62,12 @@ HttpCache* HttpNetworkLayer::GetCache() {
   return NULL;
 }
 
-HttpNetworkSession* HttpNetworkLayer::GetSession() {
-  return session_;
-}
+HttpNetworkSession* HttpNetworkLayer::GetSession() { return session_.get(); }
 
 void HttpNetworkLayer::OnSuspend() {
   suspended_ = true;
 
-  if (session_)
+  if (session_.get())
     session_->CloseIdleConnections();
 }
 
diff --git a/net/http/http_network_layer_unittest.cc b/net/http/http_network_layer_unittest.cc
index 108e683..dde37bc 100644
--- a/net/http/http_network_layer_unittest.cc
+++ b/net/http/http_network_layer_unittest.cc
@@ -38,10 +38,10 @@ class HttpNetworkLayerTest : public PlatformTest {
     session_params.host_resolver = &host_resolver_;
     session_params.cert_verifier = cert_verifier_.get();
     session_params.proxy_service = proxy_service_.get();
-    session_params.ssl_config_service = ssl_config_service_;
+    session_params.ssl_config_service = ssl_config_service_.get();
     session_params.http_server_properties = &http_server_properties_;
     network_session_ = new HttpNetworkSession(session_params);
-    factory_.reset(new HttpNetworkLayer(network_session_));
+    factory_.reset(new HttpNetworkLayer(network_session_.get()));
   }
 
   MockClientSocketFactory mock_socket_factory_;
diff --git a/net/http/http_network_session.cc b/net/http/http_network_session.cc
index ffbc72d..828583c 100644
--- a/net/http/http_network_session.cc
+++ b/net/http/http_network_session.cc
@@ -130,7 +130,7 @@ HttpNetworkSession::HttpNetworkSession(const Params& params)
       http_stream_factory_(new HttpStreamFactoryImpl(this)),
       params_(params) {
   DCHECK(proxy_service_);
-  DCHECK(ssl_config_service_);
+  DCHECK(ssl_config_service_.get());
   CHECK(http_server_properties_);
 }
 
diff --git a/net/http/http_network_session.h b/net/http/http_network_session.h
index b43c301..c94025f 100644
--- a/net/http/http_network_session.h
+++ b/net/http/http_network_session.h
@@ -121,7 +121,7 @@ class NET_EXPORT HttpNetworkSession
 
   CertVerifier* cert_verifier() { return cert_verifier_; }
   ProxyService* proxy_service() { return proxy_service_; }
-  SSLConfigService* ssl_config_service() { return ssl_config_service_; }
+  SSLConfigService* ssl_config_service() { return ssl_config_service_.get(); }
   SpdySessionPool* spdy_session_pool() { return &spdy_session_pool_; }
   QuicStreamFactory* quic_stream_factory() { return &quic_stream_factory_; }
   HttpAuthHandlerFactory* http_auth_handler_factory() {
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index ab991e4..1c55202 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -157,7 +157,7 @@ HttpNetworkTransaction::~HttpNetworkTransaction() {
       } else {
         // Otherwise, we try to drain the response body.
         HttpStreamBase* stream = stream_.release();
-        stream->Drain(session_);
+        stream->Drain(session_.get());
       }
     }
   }
@@ -362,8 +362,10 @@ int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
 }
 
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
-  return ((headers_valid_ && response_.headers) || response_.ssl_info.cert ||
-          response_.cert_request_info) ? &response_ : NULL;
+  return ((headers_valid_ && response_.headers.get()) ||
+          response_.ssl_info.cert.get() || response_.cert_request_info.get())
+             ? &response_
+             : NULL;
 }
 
 LoadState HttpNetworkTransaction::GetLoadState() const {
@@ -841,7 +843,7 @@ int HttpNetworkTransaction::DoReadHeaders() {
 }
 
 int HttpNetworkTransaction::HandleConnectionClosedBeforeEndOfHeaders() {
-  if (!response_.headers && !stream_->IsConnectionReused()) {
+  if (!response_.headers.get() && !stream_->IsConnectionReused()) {
     // The connection was closed before any data was sent. Likely an error
     // rather than empty HTTP/0.9 response.
     return ERR_EMPTY_RESPONSE;
@@ -865,7 +867,7 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
     DCHECK(stream_.get());
     DCHECK(is_https_request());
     response_.cert_request_info = new SSLCertRequestInfo;
-    stream_->GetSSLCertRequestInfo(response_.cert_request_info);
+    stream_->GetSSLCertRequestInfo(response_.cert_request_info.get());
     result = HandleCertificateRequest(result);
     if (result == OK)
       return result;
@@ -892,12 +894,12 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
     if (rv != OK)
       return rv;
   }
-  DCHECK(response_.headers);
+  DCHECK(response_.headers.get());
 
   // Server-induced fallback is supported only if this is a PAC configured
   // proxy. See: http://crbug.com/143712
   if (response_.was_fetched_via_proxy && proxy_info_.did_use_pac_script() &&
-      response_.headers != NULL) {
+      response_.headers.get() != NULL) {
     bool should_fallback =
         response_.headers->HasHeaderValue("connection", "proxy-bypass");
     // Additionally, fallback if a 500 is returned via the data reduction proxy.
@@ -958,7 +960,7 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
                                        request_->url.EffectiveIntPort());
   ProcessAlternateProtocol(session_->http_stream_factory(),
                            session_->http_server_properties(),
-                           *response_.headers,
+                           *response_.headers.get(),
                            endpoint);
 
   int rv = HandleAuthChallenge();
@@ -973,12 +975,13 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
 }
 
 int HttpNetworkTransaction::DoReadBody() {
-  DCHECK(read_buf_);
+  DCHECK(read_buf_.get());
   DCHECK_GT(read_buf_len_, 0);
   DCHECK(stream_ != NULL);
 
   next_state_ = STATE_READ_BODY_COMPLETE;
-  return stream_->ReadResponseBody(read_buf_, read_buf_len_, io_callback_);
+  return stream_->ReadResponseBody(
+      read_buf_.get(), read_buf_len_, io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
@@ -1164,7 +1167,7 @@ int HttpNetworkTransaction::HandleCertificateRequest(int error) {
   // Check that the certificate selected is still a certificate the server
   // is likely to accept, based on the criteria supplied in the
   // CertificateRequest message.
-  if (client_cert) {
+  if (client_cert.get()) {
     const std::vector<std::string>& cert_authorities =
         response_.cert_request_info->cert_authorities;
 
@@ -1322,7 +1325,7 @@ void HttpNetworkTransaction::ResetStateForAuthRestart() {
 }
 
 HttpResponseHeaders* HttpNetworkTransaction::GetResponseHeaders() const {
-  return response_.headers;
+  return response_.headers.get();
 }
 
 bool HttpNetworkTransaction::ShouldResendRequest(int error) const {
@@ -1361,7 +1364,7 @@ bool HttpNetworkTransaction::ShouldApplyServerAuth() const {
 
 int HttpNetworkTransaction::HandleAuthChallenge() {
   scoped_refptr<HttpResponseHeaders> headers(GetResponseHeaders());
-  DCHECK(headers);
+  DCHECK(headers.get());
 
   int status = headers->response_code();
   if (status != HTTP_UNAUTHORIZED &&
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index c6e0052..54f1a43 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -325,7 +325,7 @@ class HttpNetworkTransactionSpdy2Test : public PlatformTest {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     // Can't use ASSERT_* inside helper functions like this, so
     // return an error.
-    if (response == NULL || response->headers == NULL) {
+    if (response == NULL || response->headers.get() == NULL) {
       out.rv = ERR_UNEXPECTED;
       return out;
     }
@@ -873,7 +873,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, TwoIdenticalLocationHeaders) {
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL && response->headers != NULL);
+  ASSERT_TRUE(response != NULL && response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 302 Redirect", response->headers->GetStatusLine());
   std::string url;
   EXPECT_TRUE(response->headers->IsRedirect(&url));
@@ -937,7 +937,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Head) {
   ASSERT_TRUE(response != NULL);
 
   // Check that the headers got parsed.
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ(1234, response->headers->GetContentLength());
   EXPECT_EQ("HTTP/1.1 404 Not Found", response->headers->GetStatusLine());
 
@@ -980,7 +980,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ReuseConnection) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     TestCompletionCallback callback;
 
@@ -993,7 +993,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ReuseConnection) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    EXPECT_TRUE(response->headers != NULL);
+    EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
@@ -1038,7 +1038,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Ignores100) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -1080,7 +1080,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Ignores1xx) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -1203,7 +1203,7 @@ void HttpNetworkTransactionSpdy2Test::KeepAliveConnectionResendRequestTest(
     TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1224,7 +1224,7 @@ void HttpNetworkTransactionSpdy2Test::KeepAliveConnectionResendRequestTest(
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    EXPECT_TRUE(response->headers != NULL);
+    EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
@@ -1314,7 +1314,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
@@ -1335,11 +1335,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose) {
   EXPECT_EQ(OK, rv);
 
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100));
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(5, rv);
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
 
   trans.reset();
@@ -1355,7 +1355,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose2) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
@@ -1375,7 +1375,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose2) {
   EXPECT_EQ(OK, rv);
 
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100));
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
@@ -1434,7 +1434,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveAfterUnreadBody) {
     TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1455,7 +1455,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveAfterUnreadBody) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    ASSERT_TRUE(response->headers != NULL);
+    ASSERT_TRUE(response->headers.get() != NULL);
     response_lines[i] = response->headers->GetStatusLine();
 
     // We intentionally don't read the response bodies.
@@ -1479,14 +1479,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveAfterUnreadBody) {
 
   TestCompletionCallback callback;
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -1687,7 +1687,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAlive) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1776,7 +1776,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveNoBody) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1860,7 +1860,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveLargeBody) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1946,7 +1946,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveImpatientServer) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -2031,7 +2031,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyNoKeepAlive) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2050,7 +2050,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyNoKeepAlive) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
@@ -2105,7 +2105,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyKeepAlive) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
@@ -2161,7 +2161,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyKeepAlive) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
@@ -2180,7 +2180,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyKeepAlive) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
@@ -2206,7 +2206,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyCancelTunnel) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes[] = {
@@ -2338,7 +2338,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2410,7 +2410,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   TestCompletionCallback callback1;
   scoped_ptr<HttpTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans1->Start(&request1, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2420,7 +2420,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  ASSERT_TRUE(response1->headers != NULL);
+  ASSERT_TRUE(response1->headers.get() != NULL);
   EXPECT_EQ(1, response1->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info1;
@@ -2431,7 +2431,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   TestCompletionCallback callback2;
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans2->Start(&request2, callback2.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2441,7 +2441,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2 != NULL);
-  ASSERT_TRUE(response2->headers != NULL);
+  ASSERT_TRUE(response2->headers.get() != NULL);
   EXPECT_EQ(2, response2->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info2;
@@ -2508,7 +2508,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   TestCompletionCallback callback1;
   scoped_ptr<HttpTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans1->Start(&request1, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2518,7 +2518,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  ASSERT_TRUE(response1->headers != NULL);
+  ASSERT_TRUE(response1->headers.get() != NULL);
   EXPECT_EQ(1, response1->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info1;
@@ -2530,7 +2530,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   TestCompletionCallback callback2;
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans2->Start(&request2, callback2.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2540,7 +2540,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2 != NULL);
-  ASSERT_TRUE(response2->headers != NULL);
+  ASSERT_TRUE(response2->headers.get() != NULL);
   EXPECT_EQ(2, response2->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info2;
@@ -2589,7 +2589,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2654,7 +2654,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2669,7 +2669,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGet) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -2745,7 +2745,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2756,7 +2756,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
   const HttpResponseInfo* const response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
@@ -2773,7 +2773,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
 
   ASSERT_TRUE(response_restart != NULL);
-  ASSERT_TRUE(response_restart->headers != NULL);
+  ASSERT_TRUE(response_restart->headers.get() != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   // The password prompt info should not be set.
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
@@ -2794,7 +2794,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectHttps) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
@@ -2856,7 +2856,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectHttps) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -2879,7 +2879,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectSpdy) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
@@ -2940,7 +2940,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectSpdy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -2963,7 +2963,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectFailure) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
@@ -3115,7 +3115,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // The first connect and request, each of their responses, and the body.
@@ -3130,15 +3130,15 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  EXPECT_EQ(1, trans->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback()));
 
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans2->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -3157,7 +3157,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   // separate stream.
   EXPECT_NE(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
-  EXPECT_EQ(2, trans2->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(2, trans2->Read(buf.get(), 256, callback.callback()));
 }
 
 // Test load timing in the case of two HTTPS (non-SPDY) requests through a SPDY
@@ -3244,7 +3244,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // The first connect and request, each of their responses, and the body.
@@ -3259,16 +3259,16 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  EXPECT_EQ(1, trans->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback()));
   trans.reset();
 
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans2->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -3285,7 +3285,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   // The requests should have the same ID.
   EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
-  EXPECT_EQ(2, trans2->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(2, trans2->Read(buf.get(), 256, callback.callback()));
 }
 
 // Test load timing in the case of of two HTTP requests through a SPDY HTTPS
@@ -3363,7 +3363,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   spdy_data.RunFor(2);
@@ -3378,19 +3378,19 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  EXPECT_EQ(ERR_IO_PENDING, trans->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, trans->Read(buf.get(), 256, callback.callback()));
   spdy_data.RunFor(1);
   EXPECT_EQ(1, callback.WaitForResult());
   // Delete the first request, so the second one can reuse the socket.
   trans.reset();
 
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans2->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -3405,7 +3405,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   // The requests should have the same ID.
   EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
-  EXPECT_EQ(ERR_IO_PENDING, trans2->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, trans2->Read(buf.get(), 256, callback.callback()));
   spdy_data.RunFor(1);
   EXPECT_EQ(2, callback.WaitForResult());
 }
@@ -3463,7 +3463,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyAuthRetry) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -3478,7 +3478,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyAuthRetry) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
@@ -3542,7 +3542,7 @@ void HttpNetworkTransactionSpdy2Test::ConnectStatusHelperWithExpectedStatus(
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -3938,7 +3938,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NTLMAuth1) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -4118,7 +4118,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NTLMAuth2) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -4235,7 +4235,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
@@ -4274,11 +4274,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   // We now check to make sure the TCPClientSocket was not added back to
   // the pool.
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
   trans.reset();
   base::MessageLoop::current()->RunUntilIdle();
   // Make sure that the socket didn't get recycled after calling the destructor.
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Make sure that we recycle a socket after reading all of the response body.
@@ -4291,7 +4291,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocket) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     // A part of the response body is received with the response headers.
@@ -4317,11 +4317,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocket) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200 OK", status_line);
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4333,7 +4333,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Make sure that we recycle a SSL socket after reading all of the response
@@ -4368,7 +4368,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSSLSocket) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -4377,10 +4377,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSSLSocket) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4392,7 +4392,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSSLSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 }
 
 // Grab a SSL socket, use it, and put it back into the pool.  Then, reuse it
@@ -4436,7 +4436,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -4445,10 +4445,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4460,11 +4460,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 
   // Now start the second transaction, which should reuse the previous socket.
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -4473,10 +4473,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
@@ -4487,7 +4487,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 }
 
 // Make sure that we recycle a socket after a zero-length response.
@@ -4504,7 +4504,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocketAfterZeroContentLength) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n"
@@ -4528,11 +4528,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocketAfterZeroContentLength) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 204 No Content", status_line);
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4544,7 +4544,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocketAfterZeroContentLength) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 TEST_F(HttpNetworkTransactionSpdy2Test, ResendRequestOnWriteBodyError) {
@@ -4613,7 +4613,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ResendRequestOnWriteBodyError) {
 
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<HttpTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     TestCompletionCallback callback;
 
@@ -4626,7 +4626,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ResendRequestOnWriteBodyError) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    EXPECT_TRUE(response->headers != NULL);
+    EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
@@ -4836,7 +4836,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
@@ -4912,7 +4912,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
@@ -4996,7 +4996,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z2 HTTP/1.1\r\n"
@@ -5044,7 +5044,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/1 HTTP/1.1\r\n"
@@ -5114,7 +5114,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
@@ -5226,7 +5226,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DigestPreAuthNonceCount) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
@@ -5305,7 +5305,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DigestPreAuthNonceCount) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
@@ -5368,7 +5368,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ResetStateForRestart) {
     scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(temp));
     request.extra_headers.SetHeader("Foo", "1");
     request.extra_headers.SetHeader("bar", "23");
-    EXPECT_TRUE(response->vary_data.Init(request, *headers));
+    EXPECT_TRUE(response->vary_data.Init(request, *headers.get()));
   }
 
   // Cause the above state to be reset.
@@ -5918,7 +5918,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5937,7 +5937,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(response->auth_challenge.get() != NULL);
@@ -6039,7 +6039,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -6049,9 +6049,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   scoped_ptr<HttpTransaction> push_trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
-  rv = push_trans->Start(&push_request,
-                         callback.callback(), log.bound());
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  rv = push_trans->Start(&push_request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ -6075,7 +6074,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
                                  CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   // Verify the pushed stream.
-  EXPECT_TRUE(push_response->headers != NULL);
+  EXPECT_TRUE(push_response->headers.get() != NULL);
   EXPECT_EQ(200, push_response->headers->response_code());
 
   rv = ReadTransaction(push_trans.get(), &response_data);
@@ -6154,7 +6153,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPushCorrectness) {
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -7014,7 +7013,7 @@ int GroupNameTransactionHelper(
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   TestCompletionCallback callback;
 
@@ -7216,7 +7215,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForSOCKSConnections) {
     peer.SetClientSocketPoolManager(mock_pool_manager);
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session));
@@ -7383,7 +7382,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ConnectionClosedAfterStartOfHeaders) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -7445,7 +7444,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DrainResetOK) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -7535,7 +7534,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, LargeContentLengthThenClose) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -7585,7 +7584,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UploadFileSmallerThanLength) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -7647,7 +7646,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UploadUnreadableFile) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   file_util::Delete(temp_file, false);
@@ -7716,7 +7715,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UnreadableUploadFileAfterAuthRestart) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 401 Unauthorized", response->headers->GetStatusLine());
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
@@ -7734,7 +7733,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UnreadableUploadFileAfterAuthRestart) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
@@ -7918,7 +7917,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HonorAlternateProtocolHeader) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -7933,7 +7932,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HonorAlternateProtocolHeader) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
@@ -7988,7 +7987,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
@@ -7997,7 +7996,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8050,7 +8049,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8101,7 +8100,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   EXPECT_EQ(ERR_IO_PENDING, trans->Start(
@@ -8149,7 +8148,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8198,7 +8197,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8246,7 +8245,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8290,7 +8289,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
@@ -8303,7 +8302,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8366,7 +8365,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseAlternateProtocolForNpnSpdy) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8374,14 +8373,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseAlternateProtocolForNpnSpdy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8389,7 +8388,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseAlternateProtocolForNpnSpdy) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8465,7 +8464,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   TestCompletionCallback callback1;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8473,7 +8472,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8481,12 +8480,12 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
   EXPECT_EQ("hello world", response_data);
 
   TestCompletionCallback callback2;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
   rv = trans2.Start(&request, callback2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestCompletionCallback callback3;
-  HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get());
   rv = trans3.Start(&request, callback3.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -8495,7 +8494,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8504,7 +8503,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
 
   response = trans3.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8552,7 +8551,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StallAlternateProtocolForNpnSpdy) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8560,14 +8559,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StallAlternateProtocolForNpnSpdy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8575,7 +8574,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StallAlternateProtocolForNpnSpdy) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
@@ -8702,7 +8701,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8710,7 +8709,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
@@ -8719,7 +8718,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8727,7 +8726,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8794,7 +8793,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8802,7 +8801,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8848,7 +8847,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   EXPECT_EQ(OK, spdy_session->InitializeWithSocket(ssl_connection.release(),
                                                    true, OK));
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8856,7 +8855,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -9325,7 +9324,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MultiRoundAuth) {
   session_peer.SetClientSocketPoolManager(mock_pool_manager);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   const MockWrite kGet(
@@ -9395,7 +9394,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MultiRoundAuth) {
   // It should not be able to grab the TCP socket that trans has already
   // claimed.
   scoped_ptr<HttpTransaction> trans_compete(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback_compete;
   rv = trans_compete->Start(
       &request, callback_compete.callback(), BoundNetLog());
@@ -9440,11 +9439,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MultiRoundAuth) {
   // Read the body since the fourth round was successful. This will also
   // release the socket back to the pool.
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(50));
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(3, rv);
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
   // There are still 0 idle sockets, since the trans_compete transaction
   // will be handed it immediately after trans releases it to the group.
@@ -9454,11 +9453,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MultiRoundAuth) {
   // read the body.
   rv = callback_compete.WaitForResult();
   EXPECT_EQ(OK, rv);
-  rv = trans_compete->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(3, rv);
-  rv = trans_compete->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
@@ -9504,7 +9503,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NpnWithHttpOverSSL) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -9513,7 +9512,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NpnWithHttpOverSSL) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -9558,7 +9557,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyPostNPNServerHangup) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9688,7 +9687,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyAlternateProtocolThroughProxy) {
   // First round should work and provide the Alternate-Protocol state.
   TestCompletionCallback callback_1;
   scoped_ptr<HttpTransaction> trans_1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_1.WaitForResult());
@@ -9696,7 +9695,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyAlternateProtocolThroughProxy) {
   // Second round should attempt a tunnel connect and get an auth challenge.
   TestCompletionCallback callback_2;
   scoped_ptr<HttpTransaction> trans_2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans_2->Start(&request, callback_2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_2.WaitForResult());
@@ -9794,7 +9793,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ProxyGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9858,7 +9857,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ProxyTunnelGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9928,7 +9927,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ProxyTunnelGetHangup) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10005,7 +10004,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, PreconnectWithExistingSpdySession) {
   request.motivation = HttpRequestInfo::PRECONNECT_MOTIVATED;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10032,7 +10031,7 @@ void HttpNetworkTransactionSpdy2Test::CheckErrorIsPassedBack(
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
@@ -10126,7 +10125,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Begin the SSL handshake with the peer. This consumes ssl_data1.
   TestCompletionCallback callback;
@@ -10247,7 +10246,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Begin the initial SSL handshake.
   TestCompletionCallback callback;
@@ -10340,7 +10339,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ClientAuthCertCache_Proxy_Fail) {
     session_deps_.socket_factory->ResetNextMockIndexes();
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     // Begin the SSL handshake with the proxy.
     TestCompletionCallback callback;
@@ -10441,7 +10440,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10449,7 +10448,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -10471,7 +10470,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
   rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10479,7 +10478,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -10537,7 +10536,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10545,7 +10544,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -10556,7 +10555,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
   rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10564,7 +10563,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -10673,7 +10672,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10681,7 +10680,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -10701,7 +10700,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
   rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10709,7 +10708,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -10822,7 +10821,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttp) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -10836,7 +10835,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttp) {
   request2.method = "GET";
   request2.url = GURL(http_url);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -10915,7 +10914,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -10935,7 +10934,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
   request2.method = "GET";
   request2.url = GURL(http_url);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -10998,7 +10997,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseSpdySessionForHttpWhenForced) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -11012,7 +11011,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseSpdySessionForHttpWhenForced) {
   request2.method = "GET";
   request2.url = GURL(http_url);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -11130,7 +11129,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
   request1.method = "GET";
   request1.url = GURL(url1);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   ASSERT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -11145,7 +11144,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
   request2.method = "GET";
   request2.url = GURL(url2);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -11211,7 +11210,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ErrorSocketNotConnected) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(MEDIUM, session);
+  HttpNetworkTransaction trans1(MEDIUM, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -11223,7 +11222,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ErrorSocketNotConnected) {
   request2.method = "GET";
   request2.url = GURL(https_url);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -11320,7 +11319,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
   request1.url = GURL("https://www.a.com/");
   request1.load_flags = 0;
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -11328,7 +11327,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -11349,7 +11348,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
   request2.method = "GET";
   request2.url = GURL("https://www.b.com/");
   request2.load_flags = 0;
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -11357,7 +11356,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -11377,7 +11376,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
   request3.method = "GET";
   request3.url = GURL("http://www.a.com/");
   request3.load_flags = 0;
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request3, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -11385,7 +11384,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index ac59b50..24b0b11 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -326,7 +326,7 @@ class HttpNetworkTransactionSpdy3Test : public PlatformTest {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     // Can't use ASSERT_* inside helper functions like this, so
     // return an error.
-    if (response == NULL || response->headers == NULL) {
+    if (response == NULL || response->headers.get() == NULL) {
       out.rv = ERR_UNEXPECTED;
       return out;
     }
@@ -874,7 +874,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, TwoIdenticalLocationHeaders) {
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL && response->headers != NULL);
+  ASSERT_TRUE(response != NULL && response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 302 Redirect", response->headers->GetStatusLine());
   std::string url;
   EXPECT_TRUE(response->headers->IsRedirect(&url));
@@ -938,7 +938,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, Head) {
   ASSERT_TRUE(response != NULL);
 
   // Check that the headers got parsed.
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ(1234, response->headers->GetContentLength());
   EXPECT_EQ("HTTP/1.1 404 Not Found", response->headers->GetStatusLine());
 
@@ -981,7 +981,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ReuseConnection) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     TestCompletionCallback callback;
 
@@ -994,7 +994,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ReuseConnection) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    EXPECT_TRUE(response->headers != NULL);
+    EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
@@ -1039,7 +1039,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, Ignores100) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -1081,7 +1081,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, Ignores1xx) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -1204,7 +1204,7 @@ void HttpNetworkTransactionSpdy3Test::KeepAliveConnectionResendRequestTest(
     TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1225,7 +1225,7 @@ void HttpNetworkTransactionSpdy3Test::KeepAliveConnectionResendRequestTest(
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    EXPECT_TRUE(response->headers != NULL);
+    EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
@@ -1315,7 +1315,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveEarlyClose) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
@@ -1336,11 +1336,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveEarlyClose) {
   EXPECT_EQ(OK, rv);
 
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100));
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(5, rv);
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
 
   trans.reset();
@@ -1356,7 +1356,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveEarlyClose2) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
@@ -1376,7 +1376,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveEarlyClose2) {
   EXPECT_EQ(OK, rv);
 
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100));
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
@@ -1435,7 +1435,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveAfterUnreadBody) {
     TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1456,7 +1456,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveAfterUnreadBody) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    ASSERT_TRUE(response->headers != NULL);
+    ASSERT_TRUE(response->headers.get() != NULL);
     response_lines[i] = response->headers->GetStatusLine();
 
     // We intentionally don't read the response bodies.
@@ -1480,14 +1480,14 @@ TEST_F(HttpNetworkTransactionSpdy3Test, KeepAliveAfterUnreadBody) {
 
   TestCompletionCallback callback;
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -1688,7 +1688,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthKeepAlive) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1777,7 +1777,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthKeepAliveNoBody) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1861,7 +1861,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthKeepAliveLargeBody) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1947,7 +1947,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthKeepAliveImpatientServer) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -2032,7 +2032,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthProxyNoKeepAlive) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2051,7 +2051,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthProxyNoKeepAlive) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
@@ -2106,7 +2106,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthProxyKeepAlive) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
@@ -2162,7 +2162,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthProxyKeepAlive) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
@@ -2181,7 +2181,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthProxyKeepAlive) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
@@ -2207,7 +2207,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthProxyCancelTunnel) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes[] = {
@@ -2339,7 +2339,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2411,7 +2411,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   TestCompletionCallback callback1;
   scoped_ptr<HttpTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans1->Start(&request1, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2421,7 +2421,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  ASSERT_TRUE(response1->headers != NULL);
+  ASSERT_TRUE(response1->headers.get() != NULL);
   EXPECT_EQ(1, response1->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info1;
@@ -2432,7 +2432,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   TestCompletionCallback callback2;
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans2->Start(&request2, callback2.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2442,7 +2442,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingNoPacTwoRequests) {
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2 != NULL);
-  ASSERT_TRUE(response2->headers != NULL);
+  ASSERT_TRUE(response2->headers.get() != NULL);
   EXPECT_EQ(2, response2->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info2;
@@ -2509,7 +2509,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   TestCompletionCallback callback1;
   scoped_ptr<HttpTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans1->Start(&request1, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2519,7 +2519,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  ASSERT_TRUE(response1->headers != NULL);
+  ASSERT_TRUE(response1->headers.get() != NULL);
   EXPECT_EQ(1, response1->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info1;
@@ -2531,7 +2531,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   TestCompletionCallback callback2;
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans2->Start(&request2, callback2.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2541,7 +2541,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpProxyLoadTimingWithPacTwoRequests) {
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2 != NULL);
-  ASSERT_TRUE(response2->headers != NULL);
+  ASSERT_TRUE(response2->headers.get() != NULL);
   EXPECT_EQ(2, response2->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info2;
@@ -2590,7 +2590,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxyGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2655,7 +2655,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2670,7 +2670,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyGet) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -2743,7 +2743,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyGetWithProxyAuth) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -2754,7 +2754,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyGetWithProxyAuth) {
   const HttpResponseInfo* const response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
@@ -2771,7 +2771,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyGetWithProxyAuth) {
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
 
   ASSERT_TRUE(response_restart != NULL);
-  ASSERT_TRUE(response_restart->headers != NULL);
+  ASSERT_TRUE(response_restart->headers.get() != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   // The password prompt info should not be set.
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
@@ -2792,7 +2792,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyConnectHttps) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
@@ -2854,7 +2854,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyConnectHttps) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -2877,7 +2877,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyConnectSpdy) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
@@ -2938,7 +2938,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyConnectSpdy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -2961,7 +2961,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxySpdyConnectFailure) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
@@ -3113,7 +3113,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // The first connect and request, each of their responses, and the body.
@@ -3128,15 +3128,15 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  EXPECT_EQ(1, trans->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback()));
 
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans2->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -3155,7 +3155,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   // separate stream.
   EXPECT_NE(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
-  EXPECT_EQ(2, trans2->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(2, trans2->Read(buf.get(), 256, callback.callback()));
 }
 
 // Test load timing in the case of two HTTPS (non-SPDY) requests through a SPDY
@@ -3242,7 +3242,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // The first connect and request, each of their responses, and the body.
@@ -3257,17 +3257,17 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  EXPECT_EQ(1, trans->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback()));
   // Delete the first request, so the second one can reuse the socket.
   trans.reset();
 
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans2->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -3284,7 +3284,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   // The requests should have the same ID.
   EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
-  EXPECT_EQ(2, trans2->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(2, trans2->Read(buf.get(), 256, callback.callback()));
 }
 
 // Test load timing in the case of of two HTTP requests through a SPDY HTTPS
@@ -3348,7 +3348,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   spdy_data.RunFor(2);
@@ -3363,19 +3363,19 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-  EXPECT_EQ(ERR_IO_PENDING, trans->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, trans->Read(buf.get(), 256, callback.callback()));
   spdy_data.RunFor(1);
   EXPECT_EQ(1, callback.WaitForResult());
   // Delete the first request, so the second one can reuse the socket.
   trans.reset();
 
   scoped_ptr<HttpTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans2->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -3390,7 +3390,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   // The requests should have the same ID.
   EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
-  EXPECT_EQ(ERR_IO_PENDING, trans2->Read(buf, 256, callback.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, trans2->Read(buf.get(), 256, callback.callback()));
   spdy_data.RunFor(1);
   EXPECT_EQ(2, callback.WaitForResult());
 }
@@ -3448,7 +3448,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxyAuthRetry) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -3463,7 +3463,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HttpsProxyAuthRetry) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
@@ -3527,7 +3527,7 @@ void HttpNetworkTransactionSpdy3Test::ConnectStatusHelperWithExpectedStatus(
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -3923,7 +3923,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, NTLMAuth1) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -4103,7 +4103,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, NTLMAuth2) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -4220,7 +4220,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
@@ -4259,11 +4259,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   // We now check to make sure the TCPClientSocket was not added back to
   // the pool.
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
   trans.reset();
   base::MessageLoop::current()->RunUntilIdle();
   // Make sure that the socket didn't get recycled after calling the destructor.
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Make sure that we recycle a socket after reading all of the response body.
@@ -4276,7 +4276,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocket) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     // A part of the response body is received with the response headers.
@@ -4302,11 +4302,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocket) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200 OK", status_line);
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4318,7 +4318,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Make sure that we recycle a SSL socket after reading all of the response
@@ -4353,7 +4353,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSSLSocket) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -4362,10 +4362,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSSLSocket) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4377,7 +4377,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSSLSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 }
 
 // Grab a SSL socket, use it, and put it back into the pool.  Then, reuse it
@@ -4421,7 +4421,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleDeadSSLSocket) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -4430,10 +4430,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleDeadSSLSocket) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4445,11 +4445,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleDeadSSLSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 
   // Now start the second transaction, which should reuse the previous socket.
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -4458,10 +4458,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleDeadSSLSocket) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
@@ -4472,7 +4472,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleDeadSSLSocket) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 }
 
 // Make sure that we recycle a socket after a zero-length response.
@@ -4489,7 +4489,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocketAfterZeroContentLength) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n"
@@ -4513,11 +4513,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocketAfterZeroContentLength) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 204 No Content", status_line);
 
-  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -4529,7 +4529,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocketAfterZeroContentLength) {
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session));
+  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 TEST_F(HttpNetworkTransactionSpdy3Test, ResendRequestOnWriteBodyError) {
@@ -4598,7 +4598,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ResendRequestOnWriteBodyError) {
 
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<HttpTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     TestCompletionCallback callback;
 
@@ -4611,7 +4611,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ResendRequestOnWriteBodyError) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
-    EXPECT_TRUE(response->headers != NULL);
+    EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
@@ -4821,7 +4821,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
@@ -4897,7 +4897,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
@@ -4981,7 +4981,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z2 HTTP/1.1\r\n"
@@ -5029,7 +5029,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/1 HTTP/1.1\r\n"
@@ -5099,7 +5099,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthCacheAndPreauth) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
@@ -5211,7 +5211,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DigestPreAuthNonceCount) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
@@ -5290,7 +5290,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DigestPreAuthNonceCount) {
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
@@ -5353,7 +5353,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ResetStateForRestart) {
     scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(temp));
     request.extra_headers.SetHeader("Foo", "1");
     request.extra_headers.SetHeader("bar", "23");
-    EXPECT_TRUE(response->vary_data.Init(request, *headers));
+    EXPECT_TRUE(response->vary_data.Init(request, *headers.get()));
   }
 
   // Cause the above state to be reset.
@@ -5903,7 +5903,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthSpdyProxy) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5922,7 +5922,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, BasicAuthSpdyProxy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_FALSE(response->headers == NULL);
+  ASSERT_FALSE(response->headers.get() == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(response->auth_challenge.get() != NULL);
@@ -6024,7 +6024,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CrossOriginProxyPush) {
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -6034,7 +6034,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CrossOriginProxyPush) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   scoped_ptr<HttpTransaction> push_trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = push_trans->Start(&push_request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -6059,7 +6059,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CrossOriginProxyPush) {
                                  CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   // Verify the pushed stream.
-  EXPECT_TRUE(push_response->headers != NULL);
+  EXPECT_TRUE(push_response->headers.get() != NULL);
   EXPECT_EQ(200, push_response->headers->response_code());
 
   rv = ReadTransaction(push_trans.get(), &response_data);
@@ -6138,7 +6138,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CrossOriginProxyPushCorrectness) {
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -6998,7 +6998,7 @@ int GroupNameTransactionHelper(
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   TestCompletionCallback callback;
 
@@ -7200,7 +7200,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, GroupNameForSOCKSConnections) {
     peer.SetClientSocketPoolManager(mock_pool_manager);
 
     scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session));
@@ -7368,7 +7368,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ConnectionClosedAfterStartOfHeaders) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -7430,7 +7430,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DrainResetOK) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -7520,7 +7520,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, LargeContentLengthThenClose) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -7570,7 +7570,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UploadFileSmallerThanLength) {
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -7632,7 +7632,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UploadUnreadableFile) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   file_util::Delete(temp_file, false);
@@ -7701,7 +7701,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UnreadableUploadFileAfterAuthRestart) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 401 Unauthorized", response->headers->GetStatusLine());
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
@@ -7719,7 +7719,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UnreadableUploadFileAfterAuthRestart) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
@@ -7904,7 +7904,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HonorAlternateProtocolHeader) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -7919,7 +7919,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, HonorAlternateProtocolHeader) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
@@ -7974,7 +7974,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
@@ -7983,7 +7983,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8036,7 +8036,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8086,7 +8086,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   EXPECT_EQ(ERR_IO_PENDING, trans->Start(
@@ -8133,7 +8133,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8181,7 +8181,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8229,7 +8229,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ -8272,7 +8272,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolUnsafeBlocked) {
       NPN_SPDY_3);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
@@ -8285,7 +8285,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolUnsafeBlocked) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8348,7 +8348,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseAlternateProtocolForNpnSpdy) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8356,14 +8356,14 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseAlternateProtocolForNpnSpdy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8371,7 +8371,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseAlternateProtocolForNpnSpdy) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8447,7 +8447,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolWithSpdyLateBinding) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   TestCompletionCallback callback1;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8455,7 +8455,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolWithSpdyLateBinding) {
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8463,12 +8463,12 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolWithSpdyLateBinding) {
   EXPECT_EQ("hello world", response_data);
 
   TestCompletionCallback callback2;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
   rv = trans2.Start(&request, callback2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestCompletionCallback callback3;
-  HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get());
   rv = trans3.Start(&request, callback3.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -8477,7 +8477,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolWithSpdyLateBinding) {
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8486,7 +8486,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, AlternateProtocolWithSpdyLateBinding) {
 
   response = trans3.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8534,7 +8534,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, StallAlternateProtocolForNpnSpdy) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8542,14 +8542,14 @@ TEST_F(HttpNetworkTransactionSpdy3Test, StallAlternateProtocolForNpnSpdy) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8557,7 +8557,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, StallAlternateProtocolForNpnSpdy) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
@@ -8684,7 +8684,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8692,7 +8692,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
@@ -8701,7 +8701,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8709,7 +8709,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -8776,7 +8776,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8784,7 +8784,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -8830,7 +8830,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   EXPECT_EQ(OK, spdy_session->InitializeWithSocket(ssl_connection.release(),
                                                    true, OK));
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -8838,7 +8838,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -9307,7 +9307,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, MultiRoundAuth) {
   session_peer.SetClientSocketPoolManager(mock_pool_manager);
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   const MockWrite kGet(
@@ -9377,7 +9377,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, MultiRoundAuth) {
   // It should not be able to grab the TCP socket that trans has already
   // claimed.
   scoped_ptr<HttpTransaction> trans_compete(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback_compete;
   rv = trans_compete->Start(
       &request, callback_compete.callback(), BoundNetLog());
@@ -9422,11 +9422,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test, MultiRoundAuth) {
   // Read the body since the fourth round was successful. This will also
   // release the socket back to the pool.
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(50));
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(3, rv);
-  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
   // There are still 0 idle sockets, since the trans_compete transaction
   // will be handed it immediately after trans releases it to the group.
@@ -9436,11 +9436,11 @@ TEST_F(HttpNetworkTransactionSpdy3Test, MultiRoundAuth) {
   // read the body.
   rv = callback_compete.WaitForResult();
   EXPECT_EQ(OK, rv);
-  rv = trans_compete->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(3, rv);
-  rv = trans_compete->Read(io_buf, io_buf->size(), callback.callback());
+  rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
@@ -9486,7 +9486,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, NpnWithHttpOverSSL) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
@@ -9495,7 +9495,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, NpnWithHttpOverSSL) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -9540,7 +9540,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SpdyPostNPNServerHangup) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9671,7 +9671,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SpdyAlternateProtocolThroughProxy) {
   // First round should work and provide the Alternate-Protocol state.
   TestCompletionCallback callback_1;
   scoped_ptr<HttpTransaction> trans_1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_1.WaitForResult());
@@ -9679,7 +9679,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SpdyAlternateProtocolThroughProxy) {
   // Second round should attempt a tunnel connect and get an auth challenge.
   TestCompletionCallback callback_2;
   scoped_ptr<HttpTransaction> trans_2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   rv = trans_2->Start(&request, callback_2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_2.WaitForResult());
@@ -9777,7 +9777,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ProxyGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9841,7 +9841,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ProxyTunnelGet) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9911,7 +9911,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ProxyTunnelGetHangup) {
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -9988,7 +9988,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, PreconnectWithExistingSpdySession) {
   request.motivation = HttpRequestInfo::PRECONNECT_MOTIVATED;
 
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10016,7 +10016,7 @@ void HttpNetworkTransactionSpdy3Test::CheckErrorIsPassedBack(
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
@@ -10111,7 +10111,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Begin the SSL handshake with the peer. This consumes ssl_data1.
   TestCompletionCallback callback;
@@ -10232,7 +10232,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ClientAuthCertCache_Direct_FalseStart) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // Begin the initial SSL handshake.
   TestCompletionCallback callback;
@@ -10326,7 +10326,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ClientAuthCertCache_Proxy_Fail) {
     session_deps_.socket_factory->ResetNextMockIndexes();
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
     // Begin the SSL handshake with the proxy.
     TestCompletionCallback callback;
@@ -10421,7 +10421,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPooling) {
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10429,7 +10429,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPooling) {
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -10451,7 +10451,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPooling) {
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
   rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10459,7 +10459,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPooling) {
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -10516,7 +10516,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPoolingAfterResolution) {
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10524,7 +10524,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPoolingAfterResolution) {
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -10535,7 +10535,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPoolingAfterResolution) {
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
   rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10543,7 +10543,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseIPConnectionPoolingAfterResolution) {
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -10644,7 +10644,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10652,7 +10652,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ -10672,7 +10672,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
   rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -10680,7 +10680,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test,
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -10792,7 +10792,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DoNotUseSpdySessionForHttp) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -10806,7 +10806,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DoNotUseSpdySessionForHttp) {
   request2.method = "GET";
   request2.url = GURL(httpUrl);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -10877,7 +10877,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DoNotUseSpdySessionForHttpOverTunnel) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -10897,7 +10897,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DoNotUseSpdySessionForHttpOverTunnel) {
   request2.method = "GET";
   request2.url = GURL(httpUrl);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -10959,7 +10959,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseSpdySessionForHttpWhenForced) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(LOWEST, session);
+  HttpNetworkTransaction trans1(LOWEST, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -10973,7 +10973,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UseSpdySessionForHttpWhenForced) {
   request2.method = "GET";
   request2.url = GURL(http_url);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -11082,7 +11082,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
   request1.method = "GET";
   request1.url = GURL(url1);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session);
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback1;
   ASSERT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -11097,7 +11097,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
   request2.method = "GET";
   request2.url = GURL(url2);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -11163,7 +11163,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ErrorSocketNotConnected) {
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
-  HttpNetworkTransaction trans1(MEDIUM, session);
+  HttpNetworkTransaction trans1(MEDIUM, session.get());
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             trans1.Start(&request1, callback1.callback(), BoundNetLog()));
@@ -11175,7 +11175,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ErrorSocketNotConnected) {
   request2.method = "GET";
   request2.url = GURL(https_url);
   request2.load_flags = 0;
-  HttpNetworkTransaction trans2(MEDIUM, session);
+  HttpNetworkTransaction trans2(MEDIUM, session.get());
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
@@ -11272,7 +11272,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
   request1.url = GURL("https://www.a.com/");
   request1.load_flags = 0;
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -11280,7 +11280,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -11301,7 +11301,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
   request2.method = "GET";
   request2.url = GURL("https://www.b.com/");
   request2.load_flags = 0;
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -11309,7 +11309,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
@@ -11329,7 +11329,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
   request3.method = "GET";
   request3.url = GURL("http://www.a.com/");
   request3.load_flags = 0;
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request3, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -11337,7 +11337,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
diff --git a/net/http/http_network_transaction_ssl_unittest.cc b/net/http/http_network_transaction_ssl_unittest.cc
index ba5d3f5..6b3c3c7 100644
--- a/net/http/http_network_transaction_ssl_unittest.cc
+++ b/net/http/http_network_transaction_ssl_unittest.cc
@@ -129,7 +129,7 @@ TEST_F(HttpNetworkTransactionSSLTest, SSL3FallbackDisabled_Google) {
   scoped_refptr<HttpNetworkSession> session(
       new HttpNetworkSession(session_params_));
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   SSLConfig& ssl_config = GetServerSSLConfig(trans.get());
   ssl_config.unrestricted_ssl3_fallback_enabled = false;
@@ -175,7 +175,7 @@ TEST_F(HttpNetworkTransactionSSLTest, SSL3FallbackEnabled_Google) {
   scoped_refptr<HttpNetworkSession> session(
       new HttpNetworkSession(session_params_));
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   SSLConfig& ssl_config = GetServerSSLConfig(trans.get());
   ssl_config.unrestricted_ssl3_fallback_enabled = true;
@@ -222,7 +222,7 @@ TEST_F(HttpNetworkTransactionSSLTest, SSL3FallbackDisabled_Paypal) {
   scoped_refptr<HttpNetworkSession> session(
       new HttpNetworkSession(session_params_));
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   SSLConfig& ssl_config = GetServerSSLConfig(trans.get());
   ssl_config.unrestricted_ssl3_fallback_enabled = false;
@@ -275,7 +275,7 @@ TEST_F(HttpNetworkTransactionSSLTest, SSLFallback) {
   scoped_refptr<HttpNetworkSession> session(
       new HttpNetworkSession(session_params_));
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   SSLConfig& ssl_config = GetServerSSLConfig(trans.get());
   ssl_config.unrestricted_ssl3_fallback_enabled = true;
diff --git a/net/http/http_pipelined_connection_impl.cc b/net/http/http_pipelined_connection_impl.cc
index c5ca00c..471b26adef 100644
--- a/net/http/http_pipelined_connection_impl.cc
+++ b/net/http/http_pipelined_connection_impl.cc
@@ -680,7 +680,7 @@ void HttpPipelinedConnectionImpl::GetSSLCertRequestInfo(
 
 void HttpPipelinedConnectionImpl::Drain(HttpPipelinedStream* stream,
                                         HttpNetworkSession* session) {
-  HttpResponseHeaders* headers = stream->GetResponseInfo()->headers;
+  HttpResponseHeaders* headers = stream->GetResponseInfo()->headers.get();
   if (!stream->CanFindEndOfResponse() || headers->IsChunkEncoded() ||
       !usable_) {
     // TODO(simonjam): Drain chunk-encoded responses if they're relatively
diff --git a/net/http/http_proxy_client_socket.cc b/net/http/http_proxy_client_socket.cc
index 6c642a6..fc9c2b3 100644
--- a/net/http/http_proxy_client_socket.cc
+++ b/net/http/http_proxy_client_socket.cc
@@ -95,7 +95,7 @@ NextProto HttpProxyClientSocket::GetProtocolNegotiated() const {
 }
 
 const HttpResponseInfo* HttpProxyClientSocket::GetConnectResponseInfo() const {
-  return response_.headers ? &response_ : NULL;
+  return response_.headers.get() ? &response_ : NULL;
 }
 
 HttpStream* HttpProxyClientSocket::CreateConnectResponseStream() {
@@ -414,8 +414,8 @@ int HttpProxyClientSocket::DoSendRequest() {
   }
 
   parser_buf_ = new GrowableIOBuffer();
-  http_stream_parser_.reset(
-      new HttpStreamParser(transport_.get(), &request_, parser_buf_, net_log_));
+  http_stream_parser_.reset(new HttpStreamParser(
+      transport_.get(), &request_, parser_buf_.get(), net_log_));
   return http_stream_parser_->SendRequest(
       request_line_, request_headers_, &response_, io_callback_);
 }
@@ -478,7 +478,7 @@ int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
       // authentication code is smart enough to avoid being tricked by an
       // active network attacker.
       // The next state is intentionally not set as it should be STATE_NONE;
-      return HandleProxyAuthChallenge(auth_, &response_, net_log_);
+      return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_);
 
     default:
       // Ignore response to avoid letting the proxy impersonate the target
@@ -493,11 +493,11 @@ int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
 }
 
 int HttpProxyClientSocket::DoDrainBody() {
-  DCHECK(drain_buf_);
+  DCHECK(drain_buf_.get());
   DCHECK(transport_->is_initialized());
   next_state_ = STATE_DRAIN_BODY_COMPLETE;
-  return http_stream_parser_->ReadResponseBody(drain_buf_, kDrainBodyBufferSize,
-                                               io_callback_);
+  return http_stream_parser_->ReadResponseBody(
+      drain_buf_.get(), kDrainBodyBufferSize, io_callback_);
 }
 
 int HttpProxyClientSocket::DoDrainBodyComplete(int result) {
diff --git a/net/http/http_proxy_client_socket_pool.cc b/net/http/http_proxy_client_socket_pool.cc
index 3b99de7..cfff600 100644
--- a/net/http/http_proxy_client_socket_pool.cc
+++ b/net/http/http_proxy_client_socket_pool.cc
@@ -47,9 +47,9 @@ HttpProxySocketParams::HttpProxySocketParams(
       http_auth_cache_(tunnel ? http_auth_cache : NULL),
       http_auth_handler_factory_(tunnel ? http_auth_handler_factory : NULL),
       tunnel_(tunnel) {
-  DCHECK((transport_params == NULL && ssl_params != NULL) ||
-         (transport_params != NULL && ssl_params == NULL));
-  if (transport_params_) {
+  DCHECK((transport_params.get() == NULL && ssl_params.get() != NULL) ||
+         (transport_params.get() != NULL && ssl_params.get() == NULL));
+  if (transport_params_.get()) {
     ignore_limits_ = transport_params->ignore_limits();
   } else {
     ignore_limits_ = ssl_params->ignore_limits();
@@ -57,7 +57,7 @@ HttpProxySocketParams::HttpProxySocketParams(
 }
 
 const HostResolver::RequestInfo& HttpProxySocketParams::destination() const {
-  if (transport_params_ == NULL) {
+  if (transport_params_.get() == NULL) {
     return ssl_params_->transport_params()->destination();
   } else {
     return transport_params_->destination();
@@ -118,7 +118,7 @@ LoadState HttpProxyConnectJob::GetLoadState() const {
 }
 
 void HttpProxyConnectJob::GetAdditionalErrorState(ClientSocketHandle * handle) {
-  if (error_response_info_.cert_request_info) {
+  if (error_response_info_.cert_request_info.get()) {
     handle->set_ssl_error_response_info(error_response_info_);
     handle->set_is_ssl_error(true);
   }
@@ -282,7 +282,7 @@ int HttpProxyConnectJob::DoHttpProxyConnect() {
                                 params_->tunnel(),
                                 using_spdy_,
                                 protocol_negotiated_,
-                                params_->ssl_params() != NULL));
+                                params_->ssl_params().get() != NULL));
   return transport_socket_->Connect(callback_);
 }
 
@@ -347,7 +347,7 @@ int HttpProxyConnectJob::DoSpdyProxyCreateStreamComplete(int result) {
 }
 
 int HttpProxyConnectJob::ConnectInternal() {
-  if (params_->transport_params()) {
+  if (params_->transport_params().get()) {
     next_state_ = STATE_TCP_CONNECT;
   } else {
     next_state_ = STATE_SSL_CONNECT;
diff --git a/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc b/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc
index 50b6bf6..ea23e48 100644
--- a/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc
+++ b/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc
@@ -603,7 +603,7 @@ TEST_P(HttpProxyClientSocketPoolSpdy2Test, TunnelSetupRedirect) {
     const ProxyClientSocket* tunnel_socket =
         static_cast<ProxyClientSocket*>(handle_.socket());
     const HttpResponseInfo* response = tunnel_socket->GetConnectResponseInfo();
-    const HttpResponseHeaders* headers = response->headers;
+    const HttpResponseHeaders* headers = response->headers.get();
 
     // Make sure Set-Cookie header was stripped.
     EXPECT_FALSE(headers->HasHeader("set-cookie"));
diff --git a/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc b/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc
index a612b9d..c1086d5 100644
--- a/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc
+++ b/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc
@@ -604,7 +604,7 @@ TEST_P(HttpProxyClientSocketPoolSpdy3Test, TunnelSetupRedirect) {
     const ProxyClientSocket* tunnel_socket =
         static_cast<ProxyClientSocket*>(handle_.socket());
     const HttpResponseInfo* response = tunnel_socket->GetConnectResponseInfo();
-    const HttpResponseHeaders* headers = response->headers;
+    const HttpResponseHeaders* headers = response->headers.get();
 
     // Make sure Set-Cookie header was stripped.
     EXPECT_FALSE(headers->HasHeader("set-cookie"));
diff --git a/net/http/http_response_body_drainer.cc b/net/http/http_response_body_drainer.cc
index a6c9686..d8f0085 100644
--- a/net/http/http_response_body_drainer.cc
+++ b/net/http/http_response_body_drainer.cc
@@ -87,7 +87,8 @@ int HttpResponseBodyDrainer::DoDrainResponseBody() {
   next_state_ = STATE_DRAIN_RESPONSE_BODY_COMPLETE;
 
   return stream_->ReadResponseBody(
-      read_buf_, read_size_ - total_read_,
+      read_buf_.get(),
+      read_size_ - total_read_,
       base::Bind(&HttpResponseBodyDrainer::OnIOComplete,
                  base::Unretained(this)));
 }
diff --git a/net/http/http_response_body_drainer_unittest.cc b/net/http/http_response_body_drainer_unittest.cc
index 188cffa..6fcb3f4 100644
--- a/net/http/http_response_body_drainer_unittest.cc
+++ b/net/http/http_response_body_drainer_unittest.cc
@@ -197,7 +197,7 @@ int MockHttpStream::ReadResponseBodyImpl(IOBuffer* buf, int buf_len) {
 }
 
 void MockHttpStream::CompleteRead() {
-  int result = ReadResponseBodyImpl(user_buf_, buf_len_);
+  int result = ReadResponseBodyImpl(user_buf_.get(), buf_len_);
   user_buf_ = NULL;
   CompletionCallback callback = callback_;
   callback_.Reset();
@@ -219,7 +219,7 @@ class HttpResponseBodyDrainerTest : public testing::Test {
   HttpNetworkSession* CreateNetworkSession() const {
     HttpNetworkSession::Params params;
     params.proxy_service = proxy_service_.get();
-    params.ssl_config_service = ssl_config_service_;
+    params.ssl_config_service = ssl_config_service_.get();
     params.http_server_properties = http_server_properties_.get();
     return new HttpNetworkSession(params);
   }
@@ -236,20 +236,20 @@ class HttpResponseBodyDrainerTest : public testing::Test {
 TEST_F(HttpResponseBodyDrainerTest, DrainBodySyncSingleOK) {
   mock_stream_->set_num_chunks(1);
   mock_stream_->set_sync();
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodySyncOK) {
   mock_stream_->set_num_chunks(3);
   mock_stream_->set_sync();
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodyAsyncOK) {
   mock_stream_->set_num_chunks(3);
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
@@ -259,7 +259,7 @@ TEST_F(HttpResponseBodyDrainerTest, DrainBodyAsyncOK) {
 TEST_F(HttpResponseBodyDrainerTest, DrainBodyAsyncEmptyChunk) {
   mock_stream_->set_num_chunks(4);
   mock_stream_->set_is_last_chunk_zero_size();
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
@@ -267,28 +267,28 @@ TEST_F(HttpResponseBodyDrainerTest, DrainBodySyncEmptyChunk) {
   mock_stream_->set_num_chunks(4);
   mock_stream_->set_sync();
   mock_stream_->set_is_last_chunk_zero_size();
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodySizeEqualsDrainBuffer) {
   mock_stream_->set_num_chunks(
       HttpResponseBodyDrainer::kDrainBodyBufferSize / kMagicChunkSize);
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodyTimeOut) {
   mock_stream_->set_num_chunks(2);
   mock_stream_->set_stall_reads_forever();
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_TRUE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, CancelledBySession) {
   mock_stream_->set_num_chunks(2);
   mock_stream_->set_stall_reads_forever();
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   // HttpNetworkSession should delete |drainer_|.
 }
 
@@ -298,7 +298,7 @@ TEST_F(HttpResponseBodyDrainerTest, DrainBodyTooLarge) {
   too_many_chunks += 1;  // Now it's too large.
 
   mock_stream_->set_num_chunks(too_many_chunks);
-  drainer_->Start(session_);
+  drainer_->Start(session_.get());
   EXPECT_TRUE(result_waiter_.WaitForResult());
 }
 
@@ -308,13 +308,13 @@ TEST_F(HttpResponseBodyDrainerTest, StartBodyTooLarge) {
   too_many_chunks += 1;  // Now it's too large.
 
   mock_stream_->set_num_chunks(0);
-  drainer_->StartWithSize(session_, too_many_chunks * kMagicChunkSize);
+  drainer_->StartWithSize(session_.get(), too_many_chunks * kMagicChunkSize);
   EXPECT_TRUE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, StartWithNothingToDo) {
   mock_stream_->set_num_chunks(0);
-  drainer_->StartWithSize(session_, 0);
+  drainer_->StartWithSize(session_.get(), 0);
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
diff --git a/net/http/http_response_headers_unittest.cc b/net/http/http_response_headers_unittest.cc
index fde98b5..ee489c4 100644
--- a/net/http/http_response_headers_unittest.cc
+++ b/net/http/http_response_headers_unittest.cc
@@ -969,7 +969,7 @@ TEST(HttpResponseHeadersTest, Update) {
     scoped_refptr<net::HttpResponseHeaders> new_parsed(
         new net::HttpResponseHeaders(new_headers));
 
-    parsed->Update(*new_parsed);
+    parsed->Update(*new_parsed.get());
 
     std::string resulting_headers;
     parsed->GetNormalizedHeaders(&resulting_headers);
diff --git a/net/http/http_response_info.cc b/net/http/http_response_info.cc
index 57825e6..dc6fd1e 100644
--- a/net/http/http_response_info.cc
+++ b/net/http/http_response_info.cc
@@ -183,7 +183,7 @@ bool HttpResponseInfo::InitFromPickle(const Pickle& pickle,
   if (flags & RESPONSE_INFO_HAS_CERT) {
     X509Certificate::PickleType type = GetPickleTypeForVersion(version);
     ssl_info.cert = X509Certificate::CreateFromPickle(pickle, &iter, type);
-    if (!ssl_info.cert)
+    if (!ssl_info.cert.get())
       return false;
   }
   if (flags & RESPONSE_INFO_HAS_CERT_STATUS) {
diff --git a/net/http/http_stream_factory_impl.cc b/net/http/http_stream_factory_impl.cc
index d86c690..47110df 100644
--- a/net/http/http_stream_factory_impl.cc
+++ b/net/http/http_stream_factory_impl.cc
@@ -240,8 +240,11 @@ void HttpStreamFactoryImpl::OnSpdySessionReady(
                       using_spdy,
                       net_log);
     bool use_relative_url = direct || request->url().SchemeIs("https");
-    request->OnStreamReady(NULL, used_ssl_config, used_proxy_info,
-                           new SpdyHttpStream(spdy_session, use_relative_url));
+    request->OnStreamReady(
+        NULL,
+        used_ssl_config,
+        used_proxy_info,
+        new SpdyHttpStream(spdy_session.get(), use_relative_url));
   }
   // TODO(mbelshe): Alert other valid requests.
 }
diff --git a/net/http/http_stream_factory_impl_job.cc b/net/http/http_stream_factory_impl_job.cc
index 34eb217..a80cc0d 100644
--- a/net/http/http_stream_factory_impl_job.cc
+++ b/net/http/http_stream_factory_impl_job.cc
@@ -298,7 +298,7 @@ void HttpStreamFactoryImpl::Job::OnSpdySessionReadyCallback() {
   DCHECK(!stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(using_spdy());
-  DCHECK(new_spdy_session_);
+  DCHECK(new_spdy_session_.get());
   scoped_refptr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_ = NULL;
   if (IsOrphaned()) {
@@ -367,11 +367,15 @@ void HttpStreamFactoryImpl::Job::OnHttpsProxyTunnelResponseCallback(
 
 void HttpStreamFactoryImpl::Job::OnPreconnectsComplete() {
   DCHECK(!request_);
-  if (new_spdy_session_) {
-    stream_factory_->OnSpdySessionReady(
-        new_spdy_session_, spdy_session_direct_, server_ssl_config_,
-        proxy_info_, was_npn_negotiated(), protocol_negotiated(), using_spdy(),
-        net_log_);
+  if (new_spdy_session_.get()) {
+    stream_factory_->OnSpdySessionReady(new_spdy_session_,
+                                        spdy_session_direct_,
+                                        server_ssl_config_,
+                                        proxy_info_,
+                                        was_npn_negotiated(),
+                                        protocol_negotiated(),
+                                        using_spdy(),
+                                        net_log_);
   }
   stream_factory_->OnPreconnectsComplete(this);
   // |this| may be deleted after this call.
@@ -480,12 +484,11 @@ int HttpStreamFactoryImpl::Job::RunLoop(int result) {
 
     case OK:
       next_state_ = STATE_DONE;
-      if (new_spdy_session_) {
+      if (new_spdy_session_.get()) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
-            base::Bind(
-                &HttpStreamFactoryImpl::Job::OnSpdySessionReadyCallback,
-                ptr_factory_.GetWeakPtr()));
+            base::Bind(&HttpStreamFactoryImpl::Job::OnSpdySessionReadyCallback,
+                       ptr_factory_.GetWeakPtr()));
       } else {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
@@ -710,7 +713,7 @@ int HttpStreamFactoryImpl::Job::DoInitConnection() {
   SpdySessionKey spdy_session_key = GetSpdySessionKey();
   scoped_refptr<SpdySession> spdy_session =
       session_->spdy_session_pool()->GetIfExists(spdy_session_key, net_log_);
-  if (spdy_session && CanUseExistingSpdySession()) {
+  if (spdy_session.get() && CanUseExistingSpdySession()) {
     // If we're preconnecting, but we already have a SpdySession, we don't
     // actually need to preconnect any sockets, so we're done.
     if (IsPreconnecting())
@@ -815,7 +818,7 @@ int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
     SpdySessionKey spdy_session_key = GetSpdySessionKey();
     existing_spdy_session_ =
         session_->spdy_session_pool()->GetIfExists(spdy_session_key, net_log_);
-    if (existing_spdy_session_) {
+    if (existing_spdy_session_.get()) {
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
     } else {
@@ -961,7 +964,7 @@ int HttpStreamFactoryImpl::Job::DoWaitingUserAction(int result) {
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStream() {
-  DCHECK(connection_->socket() || existing_spdy_session_ ||
+  DCHECK(connection_->socket() || existing_spdy_session_.get() ||
          existing_available_pipeline_ || using_quic_);
 
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
@@ -1019,7 +1022,7 @@ int HttpStreamFactoryImpl::Job::DoCreateStream() {
   }
 
   scoped_refptr<SpdySession> spdy_session;
-  if (existing_spdy_session_) {
+  if (existing_spdy_session_.get()) {
     // We picked up an existing session, so we don't need our socket.
     if (connection_->socket())
       connection_->socket()->Disconnect();
@@ -1028,10 +1031,13 @@ int HttpStreamFactoryImpl::Job::DoCreateStream() {
   } else {
     SpdySessionPool* spdy_pool = session_->spdy_session_pool();
     spdy_session = spdy_pool->GetIfExists(spdy_session_key, net_log_);
-    if (!spdy_session) {
-      int error = spdy_pool->GetSpdySessionFromSocket(
-          spdy_session_key, connection_.release(), net_log_,
-          spdy_certificate_error_, &new_spdy_session_, using_ssl_);
+    if (!spdy_session.get()) {
+      int error = spdy_pool->GetSpdySessionFromSocket(spdy_session_key,
+                                                      connection_.release(),
+                                                      net_log_,
+                                                      spdy_certificate_error_,
+                                                      &new_spdy_session_,
+                                                      using_ssl_);
       if (error != OK)
         return error;
       const HostPortPair& host_port_pair = spdy_session_key.host_port_pair();
@@ -1052,7 +1058,7 @@ int HttpStreamFactoryImpl::Job::DoCreateStream() {
   // will know when SpdySessions become available.
 
   bool use_relative_url = direct || request_info_.url.SchemeIs("https");
-  stream_.reset(new SpdyHttpStream(spdy_session, use_relative_url));
+  stream_.reset(new SpdyHttpStream(spdy_session.get(), use_relative_url));
   return OK;
 }
 
@@ -1285,7 +1291,7 @@ int HttpStreamFactoryImpl::Job::HandleCertificateError(int error) {
   // |ssl_info_.cert| may be NULL if we failed to create
   // X509Certificate for whatever reason, but normally it shouldn't
   // happen, unless this code is used inside sandbox.
-  if (ssl_info_.cert == NULL ||
+  if (ssl_info_.cert.get() == NULL ||
       !X509Certificate::GetDEREncoded(ssl_info_.cert->os_cert_handle(),
                                       &bad_cert.der_cert)) {
     return error;
diff --git a/net/http/http_stream_factory_impl_request.cc b/net/http/http_stream_factory_impl_request.cc
index 23aa5ff..3fcc7ae 100644
--- a/net/http/http_stream_factory_impl_request.cc
+++ b/net/http/http_stream_factory_impl_request.cc
@@ -313,7 +313,7 @@ void HttpStreamFactoryImpl::Request::OnSpdySessionReady(
   delegate_->OnStreamReady(
       job->server_ssl_config(),
       job->proxy_info(),
-      new SpdyHttpStream(spdy_session, use_relative_url));
+      new SpdyHttpStream(spdy_session.get(), use_relative_url));
   // |this| may be deleted after this point.
   factory->OnSpdySessionReady(
       spdy_session, direct, used_ssl_config, used_proxy_info,
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index cac7f02..6f4e6ea 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -152,7 +152,7 @@ HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
   params.host_resolver = session_deps->host_resolver.get();
   params.cert_verifier = session_deps->cert_verifier.get();
   params.proxy_service = session_deps->proxy_service.get();
-  params.ssl_config_service = session_deps->ssl_config_service;
+  params.ssl_config_service = session_deps->ssl_config_service.get();
   params.client_socket_factory = &session_deps->socket_factory;
   params.http_auth_handler_factory =
       session_deps->http_auth_handler_factory.get();
@@ -321,7 +321,7 @@ TEST(HttpStreamFactoryTest, PreconnectDirect) {
     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
@@ -348,7 +348,7 @@ TEST(HttpStreamFactoryTest, PreconnectHttpProxy) {
     mock_pool_manager->SetSocketPoolForHTTPProxy(proxy_host, http_proxy_pool);
     mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
@@ -376,7 +376,7 @@ TEST(HttpStreamFactoryTest, PreconnectSocksProxy) {
     mock_pool_manager->SetSocketPoolForSOCKSProxy(proxy_host, socks_proxy_pool);
     mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
@@ -410,7 +410,7 @@ TEST(HttpStreamFactoryTest, PreconnectDirectWithExistingSpdySession) {
     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     // We shouldn't be preconnecting if we have an existing session, which is
     // the case for https://www.google.com.
     if (kTests[i].ssl)
@@ -438,7 +438,7 @@ TEST(HttpStreamFactoryTest, PreconnectUnsafePort) {
   mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
   peer.SetClientSocketPoolManager(mock_pool_manager);
 
-  PreconnectHelperForURL(1, GURL("http://www.google.com:7"), session);
+  PreconnectHelperForURL(1, GURL("http://www.google.com:7"), session.get());
 
   EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
 }
diff --git a/net/http/http_stream_parser.cc b/net/http/http_stream_parser.cc
index 7b195e7..17b5c6e 100644
--- a/net/http/http_stream_parser.cc
+++ b/net/http/http_stream_parser.cc
@@ -248,15 +248,15 @@ int HttpStreamParser::SendRequest(const std::string& request_line,
     // We'll repurpose |request_headers_| to store the merged headers and
     // body.
     request_headers_ = new DrainableIOBuffer(
-        merged_request_headers_and_body, merged_size);
+        merged_request_headers_and_body.get(), merged_size);
 
     memcpy(request_headers_->data(), request.data(), request.size());
     request_headers_->DidConsume(request.size());
 
     size_t todo = request_->upload_data_stream->size();
     while (todo) {
-      int consumed = request_->upload_data_stream->Read(request_headers_, todo,
-                                                        CompletionCallback());
+      int consumed = request_->upload_data_stream
+          ->Read(request_headers_.get(), todo, CompletionCallback());
       DCHECK_GT(consumed, 0);  // Read() won't fail if not chunked.
       request_headers_->DidConsume(consumed);
       todo -= consumed;
@@ -278,8 +278,8 @@ int HttpStreamParser::SendRequest(const std::string& request_line,
     // If we didn't merge the body with the headers, then |request_headers_|
     // contains just the HTTP headers.
     scoped_refptr<StringIOBuffer> headers_io_buf(new StringIOBuffer(request));
-    request_headers_ = new DrainableIOBuffer(headers_io_buf,
-                                             headers_io_buf->size());
+    request_headers_ =
+        new DrainableIOBuffer(headers_io_buf.get(), headers_io_buf->size());
   }
 
   result = DoLoop(OK);
@@ -422,9 +422,8 @@ int HttpStreamParser::DoSendHeaders(int result) {
     if (bytes_remaining == request_headers_->size()) {
       response_->request_time = base::Time::Now();
     }
-    result = connection_->socket()->Write(request_headers_,
-                                          bytes_remaining,
-                                          io_callback_);
+    result = connection_->socket()
+        ->Write(request_headers_.get(), bytes_remaining, io_callback_);
   } else if (request_->upload_data_stream != NULL &&
              (request_->upload_data_stream->is_chunked() ||
               // !IsEOF() indicates that the body wasn't merged.
@@ -451,10 +450,10 @@ int HttpStreamParser::DoSendBody(int result) {
   // Send the remaining data in the request body buffer.
   request_body_send_buf_->DidConsume(result);
   if (request_body_send_buf_->BytesRemaining() > 0) {
-    return connection_->socket()->Write(
-        request_body_send_buf_,
-        request_body_send_buf_->BytesRemaining(),
-        io_callback_);
+    return connection_->socket()
+        ->Write(request_body_send_buf_.get(),
+                request_body_send_buf_->BytesRemaining(),
+                io_callback_);
   }
 
   if (request_->upload_data_stream->is_chunked() && sent_last_chunk_) {
@@ -464,7 +463,7 @@ int HttpStreamParser::DoSendBody(int result) {
 
   request_body_read_buf_->Clear();
   io_state_ = STATE_SEND_REQUEST_READING_BODY;
-  return request_->upload_data_stream->Read(request_body_read_buf_,
+  return request_->upload_data_stream->Read(request_body_read_buf_.get(),
                                             request_body_read_buf_->capacity(),
                                             io_callback_);
 }
@@ -513,9 +512,8 @@ int HttpStreamParser::DoReadHeaders() {
   // See if the user is passing in an IOBuffer with a NULL |data_|.
   CHECK(read_buf_->data());
 
-  return connection_->socket()->Read(read_buf_,
-                                     read_buf_->RemainingCapacity(),
-                                     io_callback_);
+  return connection_->socket()
+      ->Read(read_buf_.get(), read_buf_->RemainingCapacity(), io_callback_);
 }
 
 int HttpStreamParser::DoReadHeadersComplete(int result) {
@@ -650,8 +648,8 @@ int HttpStreamParser::DoReadBody() {
     return 0;
 
   DCHECK_EQ(0, read_buf_->offset());
-  return connection_->socket()->Read(user_read_buf_, user_read_buf_len_,
-                                     io_callback_);
+  return connection_->socket()
+      ->Read(user_read_buf_.get(), user_read_buf_len_, io_callback_);
 }
 
 int HttpStreamParser::DoReadBodyComplete(int result) {
@@ -795,25 +793,26 @@ int HttpStreamParser::DoParseResponseHeaders(int end_offset) {
   // If they exist, and have distinct values, it's a potential response
   // smuggling attack.
   if (!headers->HasHeader("Transfer-Encoding")) {
-    if (HeadersContainMultipleCopiesOfField(*headers, "Content-Length"))
+    if (HeadersContainMultipleCopiesOfField(*headers.get(), "Content-Length"))
       return ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH;
   }
 
   // Check for multiple Content-Disposition or Location headers.  If they exist,
   // it's also a potential response smuggling attack.
-  if (HeadersContainMultipleCopiesOfField(*headers, "Content-Disposition"))
+  if (HeadersContainMultipleCopiesOfField(*headers.get(),
+                                          "Content-Disposition"))
     return ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION;
-  if (HeadersContainMultipleCopiesOfField(*headers, "Location"))
+  if (HeadersContainMultipleCopiesOfField(*headers.get(), "Location"))
     return ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION;
 
   response_->headers = headers;
   response_->connection_info = HttpResponseInfo::CONNECTION_INFO_HTTP1;
-  response_->vary_data.Init(*request_, *response_->headers);
+  response_->vary_data.Init(*request_, *response_->headers.get());
   DVLOG(1) << __FUNCTION__ << "()"
-           << " content_length = \""
-           << response_->headers->GetContentLength() << "\n\""
-           << " headers = \"" << GetResponseHeaderLines(*response_->headers)
-           << "\"";
+           << " content_length = \"" << response_->headers->GetContentLength()
+           << "\n\""
+           << " headers = \""
+           << GetResponseHeaderLines(*response_->headers.get()) << "\"";
   return OK;
 }
 
diff --git a/net/http/http_stream_parser_unittest.cc b/net/http/http_stream_parser_unittest.cc
index 9637bad..5d9bcfd 100644
--- a/net/http/http_stream_parser_unittest.cc
+++ b/net/http/http_stream_parser_unittest.cc
@@ -225,8 +225,8 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-  HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer,
-                          BoundNetLog());
+  HttpStreamParser parser(
+      socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Host", "localhost");
@@ -292,7 +292,8 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
-  rv = parser.ReadResponseBody(body_buffer, kBodySize, callback.callback());
+  rv = parser.ReadResponseBody(
+      body_buffer.get(), kBodySize, callback.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.RunFor(1);
 
@@ -382,8 +383,8 @@ TEST(HttpStreamParser, TruncatedHeaders) {
       request_info.load_flags = LOAD_NORMAL;
 
       scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-      HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer,
-                              BoundNetLog());
+      HttpStreamParser parser(
+          socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
       HttpRequestHeaders request_headers;
       HttpResponseInfo response_info;
diff --git a/net/http/http_transaction_unittest.cc b/net/http/http_transaction_unittest.cc
index 7b9ef46..bff06e0 100644
--- a/net/http/http_transaction_unittest.cc
+++ b/net/http/http_transaction_unittest.cc
@@ -203,7 +203,8 @@ void TestTransactionConsumer::DidFinish(int result) {
 void TestTransactionConsumer::Read() {
   state_ = READING;
   read_buf_ = new net::IOBuffer(1024);
-  int result = trans_->Read(read_buf_, 1024,
+  int result = trans_->Read(read_buf_.get(),
+                            1024,
                             base::Bind(&TestTransactionConsumer::OnIOComplete,
                                        base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
@@ -274,7 +275,7 @@ int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
     response_.response_time = t->response_time;
 
   response_.headers = new net::HttpResponseHeaders(header_data);
-  response_.vary_data.Init(*request, *response_.headers);
+  response_.vary_data.Init(*request, *response_.headers.get());
   response_.ssl_info.cert_status = t->cert_status;
   data_ = resp_data;
 
@@ -426,7 +427,7 @@ int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
   std::string content;
   do {
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-    rv = trans->Read(buf, 256, callback.callback());
+    rv = trans->Read(buf.get(), 256, callback.callback());
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
 
diff --git a/net/http/http_vary_data_unittest.cc b/net/http/http_vary_data_unittest.cc
index 93ee4f45..cffa2d2 100644
--- a/net/http/http_vary_data_unittest.cc
+++ b/net/http/http_vary_data_unittest.cc
@@ -45,7 +45,7 @@ TEST(HttpVaryDataTest, IsInvalid) {
 
     net::HttpVaryData v;
     EXPECT_FALSE(v.is_valid());
-    EXPECT_FALSE(v.Init(t.request, *t.response));
+    EXPECT_FALSE(v.Init(t.request, *t.response.get()));
     EXPECT_FALSE(v.is_valid());
   }
 }
@@ -56,13 +56,13 @@ TEST(HttpVaryDataTest, MultipleInit) {
   // Init to something valid.
   TestTransaction t1;
   t1.Init("Foo: 1\r\nbar: 23", "HTTP/1.1 200 OK\nVary: foo, bar\n\n");
-  EXPECT_TRUE(v.Init(t1.request, *t1.response));
+  EXPECT_TRUE(v.Init(t1.request, *t1.response.get()));
   EXPECT_TRUE(v.is_valid());
 
   // Now overwrite by initializing to something invalid.
   TestTransaction t2;
   t2.Init("Foo: 1\r\nbar: 23", "HTTP/1.1 200 OK\nVary: *\n\n");
-  EXPECT_FALSE(v.Init(t2.request, *t2.response));
+  EXPECT_FALSE(v.Init(t2.request, *t2.response.get()));
   EXPECT_FALSE(v.is_valid());
 }
 
@@ -74,9 +74,9 @@ TEST(HttpVaryDataTest, DoesVary) {
   b.Init("Foo: 2", "HTTP/1.1 200 OK\nVary: foo\n\n");
 
   net::HttpVaryData v;
-  EXPECT_TRUE(v.Init(a.request, *a.response));
+  EXPECT_TRUE(v.Init(a.request, *a.response.get()));
 
-  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response));
+  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response.get()));
 }
 
 TEST(HttpVaryDataTest, DoesVary2) {
@@ -87,9 +87,9 @@ TEST(HttpVaryDataTest, DoesVary2) {
   b.Init("Foo: 12\r\nbar: 3", "HTTP/1.1 200 OK\nVary: foo, bar\n\n");
 
   net::HttpVaryData v;
-  EXPECT_TRUE(v.Init(a.request, *a.response));
+  EXPECT_TRUE(v.Init(a.request, *a.response.get()));
 
-  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response));
+  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response.get()));
 }
 
 TEST(HttpVaryDataTest, DoesntVary) {
@@ -100,9 +100,9 @@ TEST(HttpVaryDataTest, DoesntVary) {
   b.Init("Foo: 1", "HTTP/1.1 200 OK\nVary: foo\n\n");
 
   net::HttpVaryData v;
-  EXPECT_TRUE(v.Init(a.request, *a.response));
+  EXPECT_TRUE(v.Init(a.request, *a.response.get()));
 
-  EXPECT_TRUE(v.MatchesRequest(b.request, *b.response));
+  EXPECT_TRUE(v.MatchesRequest(b.request, *b.response.get()));
 }
 
 TEST(HttpVaryDataTest, DoesntVary2) {
@@ -113,9 +113,9 @@ TEST(HttpVaryDataTest, DoesntVary2) {
   b.Init("Foo: 1\r\nbaR: 2", "HTTP/1.1 200 OK\nVary: foo\nVary: bar\n\n");
 
   net::HttpVaryData v;
-  EXPECT_TRUE(v.Init(a.request, *a.response));
+  EXPECT_TRUE(v.Init(a.request, *a.response.get()));
 
-  EXPECT_TRUE(v.MatchesRequest(b.request, *b.response));
+  EXPECT_TRUE(v.MatchesRequest(b.request, *b.response.get()));
 }
 
 TEST(HttpVaryDataTest, ImplicitCookieForRedirect) {
@@ -126,9 +126,9 @@ TEST(HttpVaryDataTest, ImplicitCookieForRedirect) {
   b.Init("Cookie: 2", "HTTP/1.1 301 Moved\nLocation: x\n\n");
 
   net::HttpVaryData v;
-  EXPECT_TRUE(v.Init(a.request, *a.response));
+  EXPECT_TRUE(v.Init(a.request, *a.response.get()));
 
-  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response));
+  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response.get()));
 }
 
 TEST(HttpVaryDataTest, ImplicitCookieForRedirect2) {
@@ -141,7 +141,7 @@ TEST(HttpVaryDataTest, ImplicitCookieForRedirect2) {
   b.Init("Cookie: 2", "HTTP/1.1 301 Moved\nLocation: x\nVary: cooKie\n\n");
 
   net::HttpVaryData v;
-  EXPECT_TRUE(v.Init(a.request, *a.response));
+  EXPECT_TRUE(v.Init(a.request, *a.response.get()));
 
-  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response));
+  EXPECT_FALSE(v.MatchesRequest(b.request, *b.response.get()));
 }
diff --git a/net/http/mock_http_cache.cc b/net/http/mock_http_cache.cc
index a17af59..8f2eb7c 100644
--- a/net/http/mock_http_cache.cc
+++ b/net/http/mock_http_cache.cc
@@ -511,7 +511,7 @@ bool MockHttpCache::ReadResponseInfo(disk_cache::Entry* disk_entry,
 
   net::TestCompletionCallback cb;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
-  int rv = disk_entry->ReadData(0, 0, buffer, size, cb.callback());
+  int rv = disk_entry->ReadData(0, 0, buffer.get(), size, cb.callback());
   rv = cb.GetResult(rv);
   EXPECT_EQ(size, rv);
 
@@ -532,7 +532,7 @@ bool MockHttpCache::WriteResponseInfo(
       reinterpret_cast<const char*>(pickle.data())));
   int len = static_cast<int>(pickle.size());
 
-  int rv =  disk_entry->WriteData(0, 0, data, len, cb.callback(), true);
+  int rv = disk_entry->WriteData(0, 0, data.get(), len, cb.callback(), true);
   rv = cb.GetResult(rv);
   return (rv == len);
 }
diff --git a/net/http/proxy_client_socket.cc b/net/http/proxy_client_socket.cc
index b892479..4caab08 100644
--- a/net/http/proxy_client_socket.cc
+++ b/net/http/proxy_client_socket.cc
@@ -46,7 +46,7 @@ void ProxyClientSocket::BuildTunnelRequest(
 int ProxyClientSocket::HandleProxyAuthChallenge(HttpAuthController* auth,
                                                 HttpResponseInfo* response,
                                                 const BoundNetLog& net_log) {
-  DCHECK(response->headers);
+  DCHECK(response->headers.get());
   int rv = auth->HandleAuthChallenge(response->headers, false, true, net_log);
   response->auth_challenge = auth->auth_info();
   if (rv == OK)
@@ -74,7 +74,7 @@ void ProxyClientSocket::LogBlockedTunnelResponse(int http_status_code,
 // static
 bool ProxyClientSocket::SanitizeProxyRedirect(HttpResponseInfo* response,
                                               const GURL& url) {
-  DCHECK(response && response->headers);
+  DCHECK(response && response->headers.get());
 
   std::string location;
   if (!response->headers->IsRedirect(&location))
diff --git a/net/ocsp/nss_ocsp.cc b/net/ocsp/nss_ocsp.cc
index 350cdc9..55ac036 100644
--- a/net/ocsp/nss_ocsp.cc
+++ b/net/ocsp/nss_ocsp.cc
@@ -300,7 +300,7 @@ class OCSPRequestSession
       response_code_ = request_->GetResponseCode();
       response_headers_ = request_->response_headers();
       response_headers_->GetMimeType(&response_content_type_);
-      request_->Read(buffer_, kRecvBufferSize, &bytes_read);
+      request_->Read(buffer_.get(), kRecvBufferSize, &bytes_read);
     }
     OnReadCompleted(request_, bytes_read);
   }
@@ -314,7 +314,7 @@ class OCSPRequestSession
       if (!request_->status().is_success() || bytes_read <= 0)
         break;
       data_.append(buffer_->data(), bytes_read);
-    } while (request_->Read(buffer_, kRecvBufferSize, &bytes_read));
+    } while (request_->Read(buffer_.get(), kRecvBufferSize, &bytes_read));
 
     if (!request_->status().is_io_pending()) {
       delete request_;
diff --git a/net/ocsp/nss_ocsp_unittest.cc b/net/ocsp/nss_ocsp_unittest.cc
index 076e9bd..be29d5f 100644
--- a/net/ocsp/nss_ocsp_unittest.cc
+++ b/net/ocsp/nss_ocsp_unittest.cc
@@ -73,8 +73,7 @@ class NssHttpTest : public ::testing::Test {
       : context_(false),
         handler_(NULL),
         verify_proc_(new CertVerifyProcNSS),
-        verifier_(new MultiThreadedCertVerifier(verify_proc_)) {
-  }
+        verifier_(new MultiThreadedCertVerifier(verify_proc_.get())) {}
   virtual ~NssHttpTest() {}
 
   virtual void SetUp() {
@@ -136,16 +135,21 @@ TEST_F(NssHttpTest, TestAia) {
       ImportCertFromFile(GetTestCertsDirectory(), "aia-root.pem"));
   ASSERT_TRUE(test_root.get());
 
-  ScopedTestRoot scoped_root(test_root);
+  ScopedTestRoot scoped_root(test_root.get());
 
   CertVerifyResult verify_result;
   TestCompletionCallback test_callback;
   CertVerifier::RequestHandle request_handle;
 
   int flags = CertVerifier::VERIFY_CERT_IO_ENABLED;
-  int error = verifier()->Verify(test_cert, "aia-host.invalid", flags, NULL,
-                                 &verify_result, test_callback.callback(),
-                                 &request_handle, BoundNetLog());
+  int error = verifier()->Verify(test_cert.get(),
+                                 "aia-host.invalid",
+                                 flags,
+                                 NULL,
+                                 &verify_result,
+                                 test_callback.callback(),
+                                 &request_handle,
+                                 BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, error);
 
   error = test_callback.WaitForResult();
diff --git a/net/proxy/mock_proxy_resolver.cc b/net/proxy/mock_proxy_resolver.cc
index 6878d24..ad73e4e 100644
--- a/net/proxy/mock_proxy_resolver.cc
+++ b/net/proxy/mock_proxy_resolver.cc
@@ -69,7 +69,7 @@ int MockAsyncProxyResolverBase::GetProxyForURL(
 void MockAsyncProxyResolverBase::CancelRequest(RequestHandle request_handle) {
   scoped_refptr<Request> request = reinterpret_cast<Request*>(request_handle);
   cancelled_requests_.push_back(request);
-  RemovePendingRequest(request);
+  RemovePendingRequest(request.get());
 }
 
 LoadState MockAsyncProxyResolverBase::GetLoadState(
diff --git a/net/proxy/mock_proxy_resolver.h b/net/proxy/mock_proxy_resolver.h
index fc2422c..33c67a5 100644
--- a/net/proxy/mock_proxy_resolver.h
+++ b/net/proxy/mock_proxy_resolver.h
@@ -55,7 +55,9 @@ class MockAsyncProxyResolverBase : public ProxyResolver {
         const net::CompletionCallback& callback);
     ~SetPacScriptRequest();
 
-    const ProxyResolverScriptData* script_data() const { return script_data_; }
+    const ProxyResolverScriptData* script_data() const {
+      return script_data_.get();
+    }
 
     void CompleteNow(int rv);
 
diff --git a/net/proxy/multi_threaded_proxy_resolver.cc b/net/proxy/multi_threaded_proxy_resolver.cc
index 5f59df2..072c2b8 100644
--- a/net/proxy/multi_threaded_proxy_resolver.cc
+++ b/net/proxy/multi_threaded_proxy_resolver.cc
@@ -325,7 +325,7 @@ MultiThreadedProxyResolver::Executor::Executor(
 }
 
 void MultiThreadedProxyResolver::Executor::StartJob(Job* job) {
-  DCHECK(!outstanding_job_);
+  DCHECK(!outstanding_job_.get());
   outstanding_job_ = job;
 
   // Run the job. Once it has completed (regardless of whether it was
@@ -355,7 +355,7 @@ void MultiThreadedProxyResolver::Executor::Destroy() {
   }
 
   // Cancel any outstanding job.
-  if (outstanding_job_) {
+  if (outstanding_job_.get()) {
     outstanding_job_->Cancel();
     // Orphan the job (since this executor may be deleted soon).
     outstanding_job_->set_executor(NULL);
@@ -383,7 +383,7 @@ MultiThreadedProxyResolver::Executor::~Executor() {
   DCHECK(!coordinator_) << "Destroy() was not called";
   DCHECK(!thread_.get());
   DCHECK(!resolver_.get());
-  DCHECK(!outstanding_job_);
+  DCHECK(!outstanding_job_.get());
 }
 
 // MultiThreadedProxyResolver --------------------------------------------------
@@ -423,7 +423,7 @@ int MultiThreadedProxyResolver::GetProxyForURL(
   Executor* executor = FindIdleExecutor();
   if (executor) {
     DCHECK_EQ(0u, pending_jobs_.size());
-    executor->StartJob(job);
+    executor->StartJob(job.get());
     return ERR_IO_PENDING;
   }
 
@@ -487,7 +487,7 @@ void MultiThreadedProxyResolver::PurgeMemory() {
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    Executor* executor = *it;
+    Executor* executor = it->get();
     executor->PurgeMemory();
   }
 }
@@ -521,7 +521,7 @@ void MultiThreadedProxyResolver::CheckNoOutstandingUserRequests() const {
 
   for (ExecutorList::const_iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    const Executor* executor = *it;
+    const Executor* executor = it->get();
     Job* job = executor->outstanding_job();
     // The "has_user_callback()" is to exclude jobs for which the callback
     // has already been invoked, or was not user-initiated (as in the case of
@@ -537,7 +537,7 @@ void MultiThreadedProxyResolver::ReleaseAllExecutors() {
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    Executor* executor = *it;
+    Executor* executor = it->get();
     executor->Destroy();
   }
   executors_.clear();
@@ -548,7 +548,7 @@ MultiThreadedProxyResolver::FindIdleExecutor() {
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    Executor* executor = *it;
+    Executor* executor = it->get();
     if (!executor->outstanding_job())
       return executor;
   }
@@ -577,7 +577,7 @@ void MultiThreadedProxyResolver::OnExecutorReady(Executor* executor) {
   // to the executor.
   scoped_refptr<Job> job = pending_jobs_.front();
   pending_jobs_.pop_front();
-  executor->StartJob(job);
+  executor->StartJob(job.get());
 }
 
 }  // namespace net
diff --git a/net/proxy/multi_threaded_proxy_resolver_unittest.cc b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
index 21ae9bc..994dd8f 100644
--- a/net/proxy/multi_threaded_proxy_resolver_unittest.cc
+++ b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
@@ -87,7 +87,7 @@ class MockProxyResolver : public ProxyResolver {
   int request_count() const { return request_count_; }
 
   const ProxyResolverScriptData* last_script_data() const {
-    return last_script_data_;
+    return last_script_data_.get();
   }
 
   void SetResolveLatency(base::TimeDelta latency) {
diff --git a/net/proxy/polling_proxy_config_service.cc b/net/proxy/polling_proxy_config_service.cc
index a03422a..5fa7b56 100644
--- a/net/proxy/polling_proxy_config_service.cc
+++ b/net/proxy/polling_proxy_config_service.cc
@@ -105,10 +105,9 @@ class PollingProxyConfigService::Core
     func(&config);
 
     base::AutoLock l(lock_);
-    if (origin_loop_proxy_) {
+    if (origin_loop_proxy_.get()) {
       origin_loop_proxy_->PostTask(
-          FROM_HERE,
-          base::Bind(&Core::GetConfigCompleted, this, config));
+          FROM_HERE, base::Bind(&Core::GetConfigCompleted, this, config));
     }
   }
 
@@ -117,7 +116,7 @@ class PollingProxyConfigService::Core
     DCHECK(poll_task_outstanding_);
     poll_task_outstanding_ = false;
 
-    if (!origin_loop_proxy_)
+    if (!origin_loop_proxy_.get())
       return;  // Was orphaned (parent has already been destroyed).
 
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
diff --git a/net/proxy/proxy_config_service_linux.cc b/net/proxy/proxy_config_service_linux.cc
index b735a92..d17dc35 100644
--- a/net/proxy/proxy_config_service_linux.cc
+++ b/net/proxy/proxy_config_service_linux.cc
@@ -234,7 +234,7 @@ class SettingGetterImplGConf : public ProxyConfigServiceLinux::SettingGetter {
                     base::MessageLoopForIO* file_loop) OVERRIDE {
     DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
     DCHECK(!client_);
-    DCHECK(!task_runner_);
+    DCHECK(!task_runner_.get());
     task_runner_ = glib_thread_task_runner;
     client_ = gconf_client_get_default();
     if (!client_) {
@@ -317,7 +317,7 @@ class SettingGetterImplGConf : public ProxyConfigServiceLinux::SettingGetter {
   }
 
   virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
-    return task_runner_;
+    return task_runner_.get();
   }
 
   virtual ProxyConfigSource GetConfigSource() OVERRIDE {
@@ -562,7 +562,7 @@ class SettingGetterImplGSettings
                     base::MessageLoopForIO* file_loop) OVERRIDE {
     DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
     DCHECK(!client_);
-    DCHECK(!task_runner_);
+    DCHECK(!task_runner_.get());
 
     if (!SchemaExists("org.gnome.system.proxy") ||
         !(client_ = libgio_loader_.g_settings_new("org.gnome.system.proxy"))) {
@@ -619,7 +619,7 @@ class SettingGetterImplGSettings
   }
 
   virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
-    return task_runner_;
+    return task_runner_.get();
   }
 
   virtual ProxyConfigSource GetConfigSource() OVERRIDE {
@@ -1562,7 +1562,7 @@ void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
   // then we don't set up proxy setting change notifications. This
   // should not be the usual case but is intended to simplify test
   // setups.
-  if (!io_thread_task_runner_ || !file_loop)
+  if (!io_thread_task_runner_.get() || !file_loop)
     VLOG(1) << "Monitoring of proxy setting changes is disabled";
 
   // Fetch and cache the current proxy config. The config is left in
@@ -1607,7 +1607,7 @@ void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
     if (io_thread_task_runner && file_loop) {
       scoped_refptr<base::SingleThreadTaskRunner> required_loop =
           setting_getter_->GetNotificationTaskRunner();
-      if (!required_loop || required_loop->BelongsToCurrentThread()) {
+      if (!required_loop.get() || required_loop->BelongsToCurrentThread()) {
         // In this case we are already on an acceptable thread.
         SetUpNotifications();
       } else {
@@ -1636,7 +1636,7 @@ void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
 void ProxyConfigServiceLinux::Delegate::SetUpNotifications() {
   scoped_refptr<base::SingleThreadTaskRunner> required_loop =
       setting_getter_->GetNotificationTaskRunner();
-  DCHECK(!required_loop || required_loop->BelongsToCurrentThread());
+  DCHECK(!required_loop.get() || required_loop->BelongsToCurrentThread());
   if (!setting_getter_->SetUpNotifications(this))
     LOG(ERROR) << "Unable to set up proxy configuration change notifications";
 }
@@ -1653,7 +1653,7 @@ ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::Delegate::GetLatestProxyConfig(
         ProxyConfig* config) {
   // This is called from the IO thread.
-  DCHECK(!io_thread_task_runner_ ||
+  DCHECK(!io_thread_task_runner_.get() ||
          io_thread_task_runner_->BelongsToCurrentThread());
 
   // Simply return the last proxy configuration that glib_default_loop
@@ -1678,7 +1678,7 @@ ProxyConfigService::ConfigAvailability
 void ProxyConfigServiceLinux::Delegate::OnCheckProxyConfigSettings() {
   scoped_refptr<base::SingleThreadTaskRunner> required_loop =
       setting_getter_->GetNotificationTaskRunner();
-  DCHECK(!required_loop || required_loop->BelongsToCurrentThread());
+  DCHECK(!required_loop.get() || required_loop->BelongsToCurrentThread());
   ProxyConfig new_config;
   bool valid = GetConfigFromSettings(&new_config);
   if (valid)
@@ -1714,7 +1714,7 @@ void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
     return;
   scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
-  if (!shutdown_loop || shutdown_loop->BelongsToCurrentThread()) {
+  if (!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread()) {
     // Already on the right thread, call directly.
     // This is the case for the unittests.
     OnDestroy();
@@ -1728,7 +1728,7 @@ void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
 void ProxyConfigServiceLinux::Delegate::OnDestroy() {
   scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
-  DCHECK(!shutdown_loop || shutdown_loop->BelongsToCurrentThread());
+  DCHECK(!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread());
   setting_getter_->ShutDown();
 }
 
diff --git a/net/proxy/proxy_resolver_v8.cc b/net/proxy/proxy_resolver_v8.cc
index 2c340e7..71ddd13 100644
--- a/net/proxy/proxy_resolver_v8.cc
+++ b/net/proxy/proxy_resolver_v8.cc
@@ -710,7 +710,7 @@ void ProxyResolverV8::PurgeMemory() {
 int ProxyResolverV8::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback& /*callback*/) {
-  DCHECK(script_data);
+  DCHECK(script_data.get());
   DCHECK(js_bindings_);
 
   context_.reset();
diff --git a/net/proxy/proxy_resolver_v8_tracing.cc b/net/proxy/proxy_resolver_v8_tracing.cc
index 65fe482..9959ce15 100644
--- a/net/proxy/proxy_resolver_v8_tracing.cc
+++ b/net/proxy/proxy_resolver_v8_tracing.cc
@@ -1077,7 +1077,7 @@ ProxyResolverV8Tracing::ProxyResolverV8Tracing(
 
 ProxyResolverV8Tracing::~ProxyResolverV8Tracing() {
   // Note, all requests should have been cancelled.
-  CHECK(!set_pac_script_job_);
+  CHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   // Join the worker thread. See http://crbug.com/69710. Note that we call
@@ -1094,7 +1094,7 @@ int ProxyResolverV8Tracing::GetProxyForURL(const GURL& url,
                                            const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
-  DCHECK(!set_pac_script_job_);
+  DCHECK(!set_pac_script_job_.get());
 
   scoped_refptr<Job> job = new Job(this);
 
@@ -1116,7 +1116,7 @@ LoadState ProxyResolverV8Tracing::GetLoadState(RequestHandle request) const {
 }
 
 void ProxyResolverV8Tracing::CancelSetPacScript() {
-  DCHECK(set_pac_script_job_);
+  DCHECK(set_pac_script_job_.get());
   set_pac_script_job_->Cancel();
   set_pac_script_job_ = NULL;
 }
@@ -1139,7 +1139,7 @@ int ProxyResolverV8Tracing::SetPacScript(
   // Note that there should not be any outstanding (non-cancelled) Jobs when
   // setting the PAC script (ProxyService should guarantee this). If there are,
   // then they might complete in strange ways after the new script is set.
-  DCHECK(!set_pac_script_job_);
+  DCHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   set_pac_script_job_ = new Job(this);
diff --git a/net/proxy/proxy_script_fetcher_impl.cc b/net/proxy/proxy_script_fetcher_impl.cc
index 4338a67..2cb17e5 100644
--- a/net/proxy/proxy_script_fetcher_impl.cc
+++ b/net/proxy/proxy_script_fetcher_impl.cc
@@ -250,7 +250,7 @@ void ProxyScriptFetcherImpl::ReadBody(URLRequest* request) {
   // Read as many bytes as are available synchronously.
   while (true) {
     int num_bytes;
-    if (!request->Read(buf_, kBufSize, &num_bytes)) {
+    if (!request->Read(buf_.get(), kBufSize, &num_bytes)) {
       // Check whether the read failed synchronously.
       if (!request->status().is_io_pending())
         OnResponseCompleted(request);
diff --git a/net/proxy/proxy_script_fetcher_impl_unittest.cc b/net/proxy/proxy_script_fetcher_impl_unittest.cc
index d58c5bc..6462643 100644
--- a/net/proxy/proxy_script_fetcher_impl_unittest.cc
+++ b/net/proxy/proxy_script_fetcher_impl_unittest.cc
@@ -65,8 +65,7 @@ class RequestContext : public URLRequestContext {
     scoped_refptr<HttpNetworkSession> network_session(
         new HttpNetworkSession(params));
     storage_.set_http_transaction_factory(new HttpCache(
-        network_session,
-        HttpCache::DefaultBackend::InMemory(0)));
+        network_session.get(), HttpCache::DefaultBackend::InMemory(0)));
     URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl();
     job_factory->SetProtocolHandler("file", new FileProtocolHandler());
     storage_.set_job_factory(job_factory);
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index c28c11d..62f7044 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -477,7 +477,7 @@ class ProxyService::InitProxyResolver {
   }
 
   int DoSetPacScript() {
-    DCHECK(script_data_);
+    DCHECK(script_data_.get());
     // TODO(eroman): Should log this latency to the NetLog.
     next_state_ = STATE_SET_PAC_SCRIPT_COMPLETE;
     return proxy_resolver_->SetPacScript(
@@ -674,7 +674,7 @@ class ProxyService::ProxyScriptDeciderPoller {
     // Otherwise if it succeeded both this time and last time, we need to look
     // closer and see if we ended up downloading different content for the PAC
     // script.
-    return !script_data->Equals(last_script_data_);
+    return !script_data->Equals(last_script_data_.get());
   }
 
   void NotifyProxyServiceOfChange(
@@ -682,7 +682,7 @@ class ProxyService::ProxyScriptDeciderPoller {
       const scoped_refptr<ProxyResolverScriptData>& script_data,
       const ProxyConfig& effective_config) {
     // Note that |this| may be deleted after calling into the ProxyService.
-    change_callback_.Run(result, script_data, effective_config);
+    change_callback_.Run(result, script_data.get(), effective_config);
   }
 
   base::WeakPtrFactory<ProxyScriptDeciderPoller> weak_factory_;
@@ -993,7 +993,7 @@ int ProxyService::ResolveProxy(const GURL& raw_url,
   }
 
   DCHECK_EQ(ERR_IO_PENDING, rv);
-  DCHECK(!ContainsPendingRequest(req));
+  DCHECK(!ContainsPendingRequest(req.get()));
   pending_requests_.push_back(req);
 
   // Completion will be notified through |callback|, unless the caller cancels
@@ -1365,7 +1365,7 @@ ProxyConfigService* ProxyService::CreateSystemProxyConfigService(
   // notifications (delivered in either |glib_default_loop| or
   // |file_loop|) to keep us updated when the proxy config changes.
   linux_config_service->SetupAndFetchInitialConfig(
-      glib_thread_task_runner,
+      glib_thread_task_runner.get(),
       io_thread_task_runner,
       static_cast<base::MessageLoopForIO*>(file_loop));
 
diff --git a/net/quic/quic_client_session.cc b/net/quic/quic_client_session.cc
index c22bda5..be40b39 100644
--- a/net/quic/quic_client_session.cc
+++ b/net/quic/quic_client_session.cc
@@ -167,7 +167,8 @@ void QuicClientSession::StartReading() {
     return;
   }
   read_pending_ = true;
-  int rv = socket_->Read(read_buffer_, read_buffer_->size(),
+  int rv = socket_->Read(read_buffer_.get(),
+                         read_buffer_->size(),
                          base::Bind(&QuicClientSession::OnReadComplete,
                                     weak_factory_.GetWeakPtr()));
   if (rv == ERR_IO_PENDING) {
diff --git a/net/quic/quic_connection_helper.cc b/net/quic/quic_connection_helper.cc
index ec2866e..a44f60d 100644
--- a/net/quic/quic_connection_helper.cc
+++ b/net/quic/quic_connection_helper.cc
@@ -58,7 +58,8 @@ int QuicConnectionHelper::WritePacketToWire(
   scoped_refptr<StringIOBuffer> buf(
       new StringIOBuffer(std::string(packet.data(),
                                      packet.length())));
-  int rv = socket_->Write(buf, packet.length(),
+  int rv = socket_->Write(buf.get(),
+                          packet.length(),
                           base::Bind(&QuicConnectionHelper::OnWriteComplete,
                                      weak_factory_.GetWeakPtr()));
   if (rv >= 0) {
diff --git a/net/quic/quic_http_stream.cc b/net/quic/quic_http_stream.cc
index ea22a32..1f6258e 100644
--- a/net/quic/quic_http_stream.cc
+++ b/net/quic/quic_http_stream.cc
@@ -89,7 +89,7 @@ int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
     // packet due to overhead.
     raw_request_body_buf_ = new IOBufferWithSize(kMaxPacketSize);
     // The request body buffer is empty at first.
-    request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_, 0);
+    request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), 0);
   }
 
   // Store the response info.
@@ -166,7 +166,7 @@ int QuicHttpStream::ReadResponseBody(
   }
 
   CHECK(callback_.is_null());
-  CHECK(!user_buffer_);
+  CHECK(!user_buffer_.get());
   CHECK_EQ(0, user_buffer_len_);
 
   callback_ = callback;
@@ -379,10 +379,10 @@ int QuicHttpStream::DoSendHeadersComplete(int rv) {
 
 int QuicHttpStream::DoReadRequestBody() {
   next_state_ = STATE_READ_REQUEST_BODY_COMPLETE;
-  return request_body_stream_->Read(raw_request_body_buf_,
-                                    raw_request_body_buf_->size(),
-                                    base::Bind(&QuicHttpStream::OnIOComplete,
-                                               weak_factory_.GetWeakPtr()));
+  return request_body_stream_->Read(
+      raw_request_body_buf_.get(),
+      raw_request_body_buf_->size(),
+      base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
 int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
@@ -391,7 +391,7 @@ int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
   if (rv < 0)
     return rv;
 
-  request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_, rv);
+  request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv);
   if (rv == 0) {  // Reached the end.
     DCHECK(request_body_stream_->IsEOF());
   }
@@ -405,7 +405,7 @@ int QuicHttpStream::DoSendBody() {
     return ERR_UNEXPECTED;
 
   CHECK(request_body_stream_);
-  CHECK(request_body_buf_);
+  CHECK(request_body_buf_.get());
   const bool eof = request_body_stream_->IsEOF();
   int len = request_body_buf_->BytesRemaining();
   if (len > 0 || eof) {
@@ -465,7 +465,8 @@ int QuicHttpStream::ParseResponseHeaders() {
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
   response_info_->connection_info =
       HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3;
-  response_info_->vary_data.Init(*request_info_, *response_info_->headers);
+  response_info_->vary_data
+      .Init(*request_info_, *response_info_->headers.get());
   response_info_->was_npn_negotiated = true;
   response_info_->npn_negotiated_protocol = "quic/1+spdy/3";
   response_headers_received_ = true;
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 9c00fe9..b29a0e4 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -351,7 +351,7 @@ TEST_F(QuicHttpStreamTest, GetRequest) {
 
   // 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"));
 
@@ -393,7 +393,7 @@ TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
 
   // 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"));
 
@@ -443,7 +443,7 @@ TEST_F(QuicHttpStreamTest, SendPostRequest) {
 
   // 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"));
 
@@ -505,7 +505,7 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
 
   // 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"));
 
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index d87565e..257f1f3 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -236,7 +236,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
   void CheckWasQuicResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
-    ASSERT_TRUE(response->headers != NULL);
+    ASSERT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_npn_negotiated);
@@ -247,7 +247,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
   void CheckWasHttpResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
-    ASSERT_TRUE(response->headers != NULL);
+    ASSERT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_FALSE(response->was_fetched_via_spdy);
     EXPECT_FALSE(response->was_npn_negotiated);
@@ -271,7 +271,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
 
   void SendRequestAndExpectHttpResponse(const std::string& expected) {
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     RunTransaction(trans.get());
     CheckWasHttpResponse(trans);
     CheckResponseData(trans.get(), expected);
@@ -279,7 +279,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
 
   void SendRequestAndExpectQuicResponse(const std::string& expected) {
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     RunTransaction(trans.get());
     CheckWasQuicResponse(trans);
     CheckResponseData(trans.get(), expected);
@@ -412,7 +412,7 @@ TEST_F(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
   CreateSession();
 
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session_));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
diff --git a/net/server/http_connection.cc b/net/server/http_connection.cc
index 2bc9d4d..9bce6f8 100644
--- a/net/server/http_connection.cc
+++ b/net/server/http_connection.cc
@@ -15,13 +15,13 @@ namespace net {
 int HttpConnection::last_id_ = 0;
 
 void HttpConnection::Send(const std::string& data) {
-  if (!socket_)
+  if (!socket_.get())
     return;
   socket_->Send(data);
 }
 
 void HttpConnection::Send(const char* bytes, int len) {
-  if (!socket_)
+  if (!socket_.get())
     return;
   socket_->Send(bytes, len);
 }
@@ -29,7 +29,7 @@ void HttpConnection::Send(const char* bytes, int len) {
 void HttpConnection::Send(HttpStatusCode status_code,
                           const std::string& data,
                           const std::string& content_type) {
-  if (!socket_)
+  if (!socket_.get())
     return;
 
   std::string status_message;
diff --git a/net/server/http_server.cc b/net/server/http_server.cc
index f518358..d4055d2 100644
--- a/net/server/http_server.cc
+++ b/net/server/http_server.cc
@@ -22,7 +22,7 @@ HttpServer::HttpServer(const StreamListenSocketFactory& factory,
                        HttpServer::Delegate* delegate)
     : delegate_(delegate),
       server_(factory.CreateAndListen(this)) {
-  DCHECK(server_);
+  DCHECK(server_.get());
 }
 
 void HttpServer::AcceptWebSocket(
@@ -76,7 +76,7 @@ void HttpServer::Close(int connection_id) {
 
   // Initiating close from server-side does not lead to the DidClose call.
   // Do it manually here.
-  DidClose(connection->socket_);
+  DidClose(connection->socket_.get());
 }
 
 int HttpServer::GetLocalAddress(IPEndPoint* address) {
@@ -142,7 +142,7 @@ void HttpServer::DidClose(StreamListenSocket* socket) {
   HttpConnection* connection = FindConnection(socket);
   DCHECK(connection != NULL);
   id_to_connection_.erase(connection->id());
-  socket_to_connection_.erase(connection->socket_);
+  socket_to_connection_.erase(connection->socket_.get());
   delete connection;
 }
 
diff --git a/net/socket/buffered_write_stream_socket.cc b/net/socket/buffered_write_stream_socket.cc
index 734696b..166fdd5 100644
--- a/net/socket/buffered_write_stream_socket.cc
+++ b/net/socket/buffered_write_stream_socket.cc
@@ -125,7 +125,8 @@ bool BufferedWriteStreamSocket::GetSSLInfo(SSLInfo* ssl_info) {
 
 void BufferedWriteStreamSocket::DoDelayedWrite() {
   int result = wrapped_socket_->Write(
-      io_buffer_, io_buffer_->RemainingCapacity(),
+      io_buffer_.get(),
+      io_buffer_->RemainingCapacity(),
       base::Bind(&BufferedWriteStreamSocket::OnIOComplete,
                  base::Unretained(this)));
   if (result == ERR_IO_PENDING) {
diff --git a/net/socket/client_socket_factory.cc b/net/socket/client_socket_factory.cc
index f97500a..022988a 100644
--- a/net/socket/client_socket_factory.cc
+++ b/net/socket/client_socket_factory.cc
@@ -98,15 +98,18 @@ class DefaultClientSocketFactory : public ClientSocketFactory,
     // from call to call.
     scoped_refptr<base::SequencedTaskRunner> nss_task_runner(
         nss_thread_task_runner_);
-    if (!nss_task_runner)
+    if (!nss_task_runner.get())
       nss_task_runner = base::ThreadTaskRunnerHandle::Get();
 
 #if defined(USE_OPENSSL)
     return new SSLClientSocketOpenSSL(transport_socket, host_and_port,
                                       ssl_config, context);
 #elif defined(USE_NSS) || defined(OS_MACOSX) || defined(OS_WIN)
-    return new SSLClientSocketNSS(nss_task_runner, transport_socket,
-                                  host_and_port, ssl_config, context);
+    return new SSLClientSocketNSS(nss_task_runner.get(),
+                                  transport_socket,
+                                  host_and_port,
+                                  ssl_config,
+                                  context);
 #else
     NOTIMPLEMENTED();
     return NULL;
diff --git a/net/socket/client_socket_pool_manager_impl.cc b/net/socket/client_socket_pool_manager_impl.cc
index 95dcf2f..e8fabaa 100644
--- a/net/socket/client_socket_pool_manager_impl.cc
+++ b/net/socket/client_socket_pool_manager_impl.cc
@@ -277,23 +277,22 @@ ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
   DCHECK(tcp_https_ret.second);
 
   std::pair<SSLSocketPoolMap::iterator, bool> ssl_https_ret =
-      ssl_socket_pools_for_https_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new SSLClientSocketPool(
-                  max_sockets_per_proxy_server(pool_type_),
-                  max_sockets_per_group(pool_type_),
-                  &ssl_for_https_proxy_pool_histograms_,
-                  host_resolver_,
-                  cert_verifier_,
-                  server_bound_cert_service_,
-                  transport_security_state_,
-                  ssl_session_cache_shard_,
-                  socket_factory_,
-                  tcp_https_ret.first->second /* https proxy */,
-                  NULL /* no socks proxy */,
-                  NULL /* no http proxy */,
-                  ssl_config_service_, net_log_)));
+      ssl_socket_pools_for_https_proxies_.insert(std::make_pair(
+          http_proxy,
+          new SSLClientSocketPool(max_sockets_per_proxy_server(pool_type_),
+                                  max_sockets_per_group(pool_type_),
+                                  &ssl_for_https_proxy_pool_histograms_,
+                                  host_resolver_,
+                                  cert_verifier_,
+                                  server_bound_cert_service_,
+                                  transport_security_state_,
+                                  ssl_session_cache_shard_,
+                                  socket_factory_,
+                                  tcp_https_ret.first->second /* https proxy */,
+                                  NULL /* no socks proxy */,
+                                  NULL /* no http proxy */,
+                                  ssl_config_service_.get(),
+                                  net_log_)));
   DCHECK(tcp_https_ret.second);
 
   std::pair<HTTPProxySocketPoolMap::iterator, bool> ret =
@@ -332,7 +331,7 @@ SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSSLWithProxy(
       NULL, /* no tcp pool, we always go through a proxy */
       GetSocketPoolForSOCKSProxy(proxy_server),
       GetSocketPoolForHTTPProxy(proxy_server),
-      ssl_config_service_,
+      ssl_config_service_.get(),
       net_log_);
 
   std::pair<SSLSocketPoolMap::iterator, bool> ret =
diff --git a/net/socket/deterministic_socket_data_unittest.cc b/net/socket/deterministic_socket_data_unittest.cc
index d0f568a..b97cd40 100644
--- a/net/socket/deterministic_socket_data_unittest.cc
+++ b/net/socket/deterministic_socket_data_unittest.cc
@@ -130,7 +130,7 @@ void DeterministicSocketDataTest::AssertAsyncReadEquals(const char* data,
 void DeterministicSocketDataTest::AssertReadReturns(const char* data,
                                                     int len, int rv) {
   read_buf_ = new IOBuffer(len);
-  ASSERT_EQ(rv, sock_->Read(read_buf_, len, read_callback_.callback()));
+  ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, read_callback_.callback()));
 }
 
 void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
@@ -144,7 +144,7 @@ void DeterministicSocketDataTest::AssertSyncWriteEquals(const char* data,
   memcpy(buf->data(), data, len);
 
   // Issue the write, which will complete immediately
-  ASSERT_EQ(len, sock_->Write(buf, len, write_callback_.callback()));
+  ASSERT_EQ(len, sock_->Write(buf.get(), len, write_callback_.callback()));
 }
 
 void DeterministicSocketDataTest::AssertAsyncWriteEquals(const char* data,
@@ -165,23 +165,32 @@ void DeterministicSocketDataTest::AssertWriteReturns(const char* data,
   memcpy(buf->data(), data, len);
 
   // Issue the read, which will complete asynchronously
-  ASSERT_EQ(rv, sock_->Write(buf, len, write_callback_.callback()));
+  ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback()));
 }
 
 void DeterministicSocketDataTest::ReentrantReadCallback(int len, int rv) {
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(len));
-  EXPECT_EQ(len, sock_->Read(read_buf,  len,
-      base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
-                 base::Unretained(this), len)));
+  EXPECT_EQ(len,
+            sock_->Read(
+                read_buf.get(),
+                len,
+                base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
+                           base::Unretained(this),
+                           len)));
 }
 
 void DeterministicSocketDataTest::ReentrantWriteCallback(
     const char* data, int len, int rv) {
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(len));
   memcpy(write_buf->data(), data, len);
-  EXPECT_EQ(len, sock_->Write(write_buf,  len,
-      base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
-                 base::Unretained(this), data, len)));
+  EXPECT_EQ(len,
+            sock_->Write(
+                write_buf.get(),
+                len,
+                base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
+                           base::Unretained(this),
+                           data,
+                           len)));
 }
 
 // ----------- Read
@@ -324,9 +333,13 @@ TEST_F(DeterministicSocketDataTest, SyncReadFromCompletionCallback) {
   data_->StopAfter(2);
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(read_buf, kLen1,
-      base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
-                 base::Unretained(this), kLen2)));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(
+                read_buf.get(),
+                kLen1,
+                base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
+                           base::Unretained(this),
+                           kLen2)));
   data_->Run();
 }
 
@@ -465,9 +478,14 @@ TEST_F(DeterministicSocketDataTest, SyncWriteFromCompletionCallback) {
 
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
   memcpy(write_buf->data(), kMsg1, kLen1);
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, kLen1,
-      base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
-                 base::Unretained(this), kMsg2, kLen2)));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Write(
+                write_buf.get(),
+                kLen1,
+                base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
+                           base::Unretained(this),
+                           kMsg2,
+                           kLen2)));
   data_->Run();
 }
 
diff --git a/net/socket/socks5_client_socket.cc b/net/socket/socks5_client_socket.cc
index 8a3b780..d84761d 100644
--- a/net/socket/socks5_client_socket.cc
+++ b/net/socket/socks5_client_socket.cc
@@ -291,8 +291,8 @@ int SOCKS5ClientSocket::DoGreetWrite() {
   handshake_buf_ = new IOBuffer(handshake_buf_len);
   memcpy(handshake_buf_->data(), &buffer_.data()[bytes_sent_],
          handshake_buf_len);
-  return transport_->socket()->Write(handshake_buf_, handshake_buf_len,
-                                     io_callback_);
+  return transport_->socket()
+      ->Write(handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoGreetWriteComplete(int result) {
@@ -314,8 +314,8 @@ int SOCKS5ClientSocket::DoGreetRead() {
   next_state_ = STATE_GREET_READ_COMPLETE;
   size_t handshake_buf_len = kGreetReadHeaderSize - bytes_received_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  return transport_->socket()->Read(handshake_buf_, handshake_buf_len,
-                                    io_callback_);
+  return transport_->socket()
+      ->Read(handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoGreetReadComplete(int result) {
@@ -389,8 +389,8 @@ int SOCKS5ClientSocket::DoHandshakeWrite() {
   handshake_buf_ = new IOBuffer(handshake_buf_len);
   memcpy(handshake_buf_->data(), &buffer_[bytes_sent_],
          handshake_buf_len);
-  return transport_->socket()->Write(handshake_buf_, handshake_buf_len,
-                                     io_callback_);
+  return transport_->socket()
+      ->Write(handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoHandshakeWriteComplete(int result) {
@@ -423,8 +423,8 @@ int SOCKS5ClientSocket::DoHandshakeRead() {
 
   int handshake_buf_len = read_header_size - bytes_received_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  return transport_->socket()->Read(handshake_buf_, handshake_buf_len,
-                                    io_callback_);
+  return transport_->socket()
+      ->Read(handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoHandshakeReadComplete(int result) {
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index 9a55090..717d858 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -151,13 +151,15 @@ TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
-  rv = user_sock_->Write(buffer, payload_write.size(), callback_.callback());
+  rv = user_sock_->Write(
+      buffer.get(), payload_write.size(), callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_write.size()), rv);
 
   buffer = new IOBuffer(payload_read.size());
-  rv = user_sock_->Read(buffer, payload_read.size(), callback_.callback());
+  rv =
+      user_sock_->Read(buffer.get(), payload_read.size(), callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_read.size()), rv);
diff --git a/net/socket/socks_client_socket.cc b/net/socket/socks_client_socket.cc
index 54bc7dc..c4bbd28 100644
--- a/net/socket/socks_client_socket.cc
+++ b/net/socket/socks_client_socket.cc
@@ -343,7 +343,8 @@ int SOCKSClientSocket::DoHandshakeWrite() {
   memcpy(handshake_buf_->data(), &buffer_[bytes_sent_],
          handshake_buf_len);
   return transport_->socket()->Write(
-      handshake_buf_, handshake_buf_len,
+      handshake_buf_.get(),
+      handshake_buf_len,
       base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)));
 }
 
@@ -376,9 +377,10 @@ int SOCKSClientSocket::DoHandshakeRead() {
 
   int handshake_buf_len = kReadHeaderSize - bytes_received_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  return transport_->socket()->Read(handshake_buf_, handshake_buf_len,
-                                    base::Bind(&SOCKSClientSocket::OnIOComplete,
-                                               base::Unretained(this)));
+  return transport_->socket()->Read(
+      handshake_buf_.get(),
+      handshake_buf_len,
+      base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)));
 }
 
 int SOCKSClientSocket::DoHandshakeReadComplete(int result) {
diff --git a/net/socket/socks_client_socket_pool.cc b/net/socket/socks_client_socket_pool.cc
index 66d8281..5e34cd0 100644
--- a/net/socket/socks_client_socket_pool.cc
+++ b/net/socket/socks_client_socket_pool.cc
@@ -26,7 +26,7 @@ SOCKSSocketParams::SOCKSSocketParams(
     : transport_params_(proxy_server),
       destination_(host_port_pair),
       socks_v5_(socks_v5) {
-  if (transport_params_)
+  if (transport_params_.get())
     ignore_limits_ = transport_params_->ignore_limits();
   else
     ignore_limits_ = false;
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index cff9c26..7a8faf6 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -162,13 +162,15 @@ TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
-  rv = user_sock_->Write(buffer, payload_write.size(), callback_.callback());
+  rv = user_sock_->Write(
+      buffer.get(), payload_write.size(), callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_write.size()), rv);
 
   buffer = new IOBuffer(payload_read.size());
-  rv = user_sock_->Read(buffer, payload_read.size(), callback_.callback());
+  rv =
+      user_sock_->Read(buffer.get(), payload_read.size(), callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_read.size()), rv);
diff --git a/net/socket/ssl_client_socket_nss.cc b/net/socket/ssl_client_socket_nss.cc
index 47bd809..5b0a900 100644
--- a/net/socket/ssl_client_socket_nss.cc
+++ b/net/socket/ssl_client_socket_nss.cc
@@ -1093,8 +1093,8 @@ int SSLClientSocketNSS::Core::Connect(const CompletionCallback& callback) {
   DCHECK(user_read_callback_.is_null());
   DCHECK(user_write_callback_.is_null());
   DCHECK(user_connect_callback_.is_null());
-  DCHECK(!user_read_buf_);
-  DCHECK(!user_write_buf_);
+  DCHECK(!user_read_buf_.get());
+  DCHECK(!user_write_buf_.get());
 
   next_handshake_state_ = STATE_HANDSHAKE;
   int rv = DoHandshakeLoop(OK);
@@ -1148,7 +1148,7 @@ int SSLClientSocketNSS::Core::Read(IOBuffer* buf, int buf_len,
   DCHECK_EQ(STATE_NONE, next_handshake_state_);
   DCHECK(user_read_callback_.is_null());
   DCHECK(user_connect_callback_.is_null());
-  DCHECK(!user_read_buf_);
+  DCHECK(!user_read_buf_.get());
   DCHECK(nss_bufs_);
 
   user_read_buf_ = buf;
@@ -1202,7 +1202,7 @@ int SSLClientSocketNSS::Core::Write(IOBuffer* buf, int buf_len,
   DCHECK_EQ(STATE_NONE, next_handshake_state_);
   DCHECK(user_write_callback_.is_null());
   DCHECK(user_connect_callback_.is_null());
-  DCHECK(!user_write_buf_);
+  DCHECK(!user_write_buf_.get());
   DCHECK(nss_bufs_);
 
   user_write_buf_ = buf;
@@ -1545,9 +1545,9 @@ SECStatus SSLClientSocketNSS::Core::ClientAuthHandler(
 
   if (core->ssl_config_.send_client_cert) {
     // Second pass: a client certificate should have been selected.
-    if (core->ssl_config_.client_cert) {
-      CERTCertificate* cert = CERT_DupCertificate(
-          core->ssl_config_.client_cert->os_cert_handle());
+    if (core->ssl_config_.client_cert.get()) {
+      CERTCertificate* cert =
+          CERT_DupCertificate(core->ssl_config_.client_cert->os_cert_handle());
       SECKEYPrivateKey* privkey = PK11_FindKeyByAnyCert(cert, wincx);
       if (privkey) {
         // TODO(jsorianopastor): We should wait for server certificate
@@ -1957,7 +1957,7 @@ int SSLClientSocketNSS::Core::DoGetDBCertComplete(int result) {
 
 int SSLClientSocketNSS::Core::DoPayloadRead() {
   DCHECK(OnNSSTaskRunner());
-  DCHECK(user_read_buf_);
+  DCHECK(user_read_buf_.get());
   DCHECK_GT(user_read_buf_len_, 0);
 
   int rv;
@@ -2075,7 +2075,7 @@ int SSLClientSocketNSS::Core::DoPayloadRead() {
 int SSLClientSocketNSS::Core::DoPayloadWrite() {
   DCHECK(OnNSSTaskRunner());
 
-  DCHECK(user_write_buf_);
+  DCHECK(user_write_buf_.get());
 
   int old_amount_in_read_buffer = memio_GetReadableBufferSize(nss_bufs_);
   int rv = PR_Write(nss_fd_, user_write_buf_->data(), user_write_buf_len_);
@@ -2157,7 +2157,7 @@ int SSLClientSocketNSS::Core::BufferRecv() {
   } else {
     scoped_refptr<IOBuffer> read_buffer(new IOBuffer(nb));
     if (OnNetworkTaskRunner()) {
-      rv = DoBufferRecv(read_buffer, nb);
+      rv = DoBufferRecv(read_buffer.get(), nb);
     } else {
       bool posted = network_task_runner_->PostTask(
           FROM_HERE,
@@ -2202,7 +2202,7 @@ int SSLClientSocketNSS::Core::BufferSend() {
     memcpy(send_buffer->data() + len1, buf2, len2);
 
     if (OnNetworkTaskRunner()) {
-      rv = DoBufferSend(send_buffer, len);
+      rv = DoBufferSend(send_buffer.get(), len);
     } else {
       bool posted = network_task_runner_->PostTask(
           FROM_HERE,
@@ -2231,7 +2231,7 @@ void SSLClientSocketNSS::Core::OnRecvComplete(int result) {
 
   // Network layer received some data, check if client requested to read
   // decrypted data.
-  if (!user_read_buf_)
+  if (!user_read_buf_.get())
     return;
 
   int rv = DoReadLoop(result);
@@ -2253,15 +2253,13 @@ void SSLClientSocketNSS::Core::OnSendComplete(int result) {
   int rv_write = ERR_IO_PENDING;
   bool network_moved;
   do {
-    if (user_read_buf_)
+    if (user_read_buf_.get())
       rv_read = DoPayloadRead();
-    if (user_write_buf_)
+    if (user_write_buf_.get())
       rv_write = DoPayloadWrite();
     network_moved = DoTransportIO();
-  } while (rv_read == ERR_IO_PENDING &&
-           rv_write == ERR_IO_PENDING &&
-           (user_read_buf_ || user_write_buf_) &&
-           network_moved);
+  } while (rv_read == ERR_IO_PENDING && rv_write == ERR_IO_PENDING &&
+           (user_read_buf_.get() || user_write_buf_.get()) && network_moved);
 
   // If the parent SSLClientSocketNSS is deleted during the processing of the
   // Read callback and OnNSSTaskRunner() == OnNetworkTaskRunner(), then the Core
@@ -2269,13 +2267,13 @@ void SSLClientSocketNSS::Core::OnSendComplete(int result) {
   // an extra reference, then check if the Core was detached before invoking the
   // next callback.
   scoped_refptr<Core> guard(this);
-  if (user_read_buf_ && rv_read != ERR_IO_PENDING)
+  if (user_read_buf_.get() && rv_read != ERR_IO_PENDING)
     DoReadCallback(rv_read);
 
   if (OnNetworkTaskRunner() && detached_)
     return;
 
-  if (user_write_buf_ && rv_write != ERR_IO_PENDING)
+  if (user_write_buf_.get() && rv_write != ERR_IO_PENDING)
     DoWriteCallback(rv_write);
 }
 
@@ -2442,7 +2440,7 @@ void SSLClientSocketNSS::Core::UpdateServerCert() {
   nss_handshake_state_.server_cert_chain.Reset(nss_fd_);
   nss_handshake_state_.server_cert = X509Certificate::CreateFromDERCertChain(
       nss_handshake_state_.server_cert_chain.AsStringPieceVector());
-  if (nss_handshake_state_.server_cert) {
+  if (nss_handshake_state_.server_cert.get()) {
     // Since this will be called asynchronously on another thread, it needs to
     // own a reference to the certificate.
     NetLog::ParametersCallback net_log_callback =
@@ -2855,7 +2853,7 @@ bool SSLClientSocketNSS::GetSSLInfo(SSLInfo* ssl_info) {
   ssl_info->is_issued_by_known_root =
       server_cert_verify_result_.is_issued_by_known_root;
   ssl_info->client_cert_sent =
-      ssl_config_.send_client_cert && ssl_config_.client_cert;
+      ssl_config_.send_client_cert && ssl_config_.client_cert.get();
   ssl_info->channel_id_sent = WasChannelIDSent();
 
   PRUint16 cipher_suite = SSLConnectionStatusToCipherSuite(
@@ -3060,7 +3058,7 @@ bool SSLClientSocketNSS::UsingTCPFastOpen() const {
 
 int SSLClientSocketNSS::Read(IOBuffer* buf, int buf_len,
                              const CompletionCallback& callback) {
-  DCHECK(core_);
+  DCHECK(core_.get());
   DCHECK(!callback.is_null());
 
   EnterFunction(buf_len);
@@ -3072,7 +3070,7 @@ int SSLClientSocketNSS::Read(IOBuffer* buf, int buf_len,
 
 int SSLClientSocketNSS::Write(IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
-  DCHECK(core_);
+  DCHECK(core_.get());
   DCHECK(!callback.is_null());
 
   EnterFunction(buf_len);
@@ -3111,8 +3109,12 @@ int SSLClientSocketNSS::Init() {
 }
 
 void SSLClientSocketNSS::InitCore() {
-  core_ = new Core(base::ThreadTaskRunnerHandle::Get(), nss_task_runner_,
-                   transport_.get(), host_and_port_, ssl_config_, &net_log_,
+  core_ = new Core(base::ThreadTaskRunnerHandle::Get(),
+                   nss_task_runner_.get(),
+                   transport_.get(),
+                   host_and_port_,
+                   ssl_config_,
+                   &net_log_,
                    server_bound_cert_service_);
 }
 
@@ -3395,7 +3397,7 @@ int SSLClientSocketNSS::DoVerifyCert(int result) {
 
   // We may have failed to create X509Certificate object if we are
   // running inside sandbox.
-  if (!core_->state().server_cert) {
+  if (!core_->state().server_cert.get()) {
     server_cert_verify_result_.Reset();
     server_cert_verify_result_.cert_status = CERT_STATUS_INVALID;
     return ERR_CERT_INVALID;
@@ -3412,8 +3414,11 @@ int SSLClientSocketNSS::DoVerifyCert(int result) {
     flags |= CertVerifier::VERIFY_CERT_IO_ENABLED;
   verifier_.reset(new SingleRequestCertVerifier(cert_verifier_));
   return verifier_->Verify(
-      core_->state().server_cert, host_and_port_.host(), flags,
-      SSLConfigService::GetCRLSet(), &server_cert_verify_result_,
+      core_->state().server_cert.get(),
+      host_and_port_.host(),
+      flags,
+      SSLConfigService::GetCRLSet(),
+      &server_cert_verify_result_,
       base::Bind(&SSLClientSocketNSS::OnHandshakeIOComplete,
                  base::Unretained(this)),
       net_log_);
diff --git a/net/socket/ssl_client_socket_pool.cc b/net/socket/ssl_client_socket_pool.cc
index d4f5bda..e9b9ec5 100644
--- a/net/socket/ssl_client_socket_pool.cc
+++ b/net/socket/ssl_client_socket_pool.cc
@@ -123,7 +123,7 @@ LoadState SSLConnectJob::GetLoadState() const {
 void SSLConnectJob::GetAdditionalErrorState(ClientSocketHandle* handle) {
   // Headers in |error_response_info_| indicate a proxy tunnel setup
   // problem. See DoTunnelConnectComplete.
-  if (error_response_info_.headers) {
+  if (error_response_info_.headers.get()) {
     handle->set_pending_http_proxy_connection(
         transport_socket_handle_.release());
   }
@@ -383,7 +383,8 @@ int SSLConnectJob::DoSSLConnectComplete(int result) {
     set_socket(ssl_socket_.release());
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     error_response_info_.cert_request_info = new SSLCertRequestInfo;
-    ssl_socket_->GetSSLCertRequestInfo(error_response_info_.cert_request_info);
+    ssl_socket_->GetSSLCertRequestInfo(
+        error_response_info_.cert_request_info.get());
   }
 
   return result;
@@ -475,7 +476,7 @@ SSLClientSocketPool::SSLClientSocketPool(
                                          ssl_session_cache_shard),
                                      net_log)),
       ssl_config_service_(ssl_config_service) {
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->AddObserver(this);
   if (transport_pool_)
     transport_pool_->AddLayeredPool(this);
@@ -492,7 +493,7 @@ SSLClientSocketPool::~SSLClientSocketPool() {
     socks_pool_->RemoveLayeredPool(this);
   if (transport_pool_)
     transport_pool_->RemoveLayeredPool(this);
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->RemoveObserver(this);
 }
 
diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc
index fbfa338..7e1eeb9 100644
--- a/net/socket/ssl_client_socket_pool_unittest.cc
+++ b/net/socket/ssl_client_socket_pool_unittest.cc
@@ -183,7 +183,7 @@ class SSLClientSocketPoolTest : public testing::Test {
     params.cert_verifier = cert_verifier_.get();
     params.proxy_service = proxy_service_.get();
     params.client_socket_factory = &socket_factory_;
-    params.ssl_config_service = ssl_config_service_;
+    params.ssl_config_service = ssl_config_service_.get();
     params.http_auth_handler_factory = http_auth_handler_factory_.get();
     params.http_server_properties = &http_server_properties_;
     params.enable_spdy_compression = false;
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index 6a25b0b..1f1ab72 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -162,7 +162,7 @@ ReadBufferingStreamSocket::ReadBufferingStreamSocket(
 }
 
 void ReadBufferingStreamSocket::SetBufferSize(int size) {
-  DCHECK(!user_read_buf_);
+  DCHECK(!user_read_buf_.get());
   buffer_size_ = size;
   read_buffer_->SetCapacity(size);
 }
@@ -210,11 +210,11 @@ int ReadBufferingStreamSocket::DoLoop(int result) {
 
 int ReadBufferingStreamSocket::DoRead() {
   state_ = STATE_READ_COMPLETE;
-  int rv = transport_->Read(
-      read_buffer_,
-      read_buffer_->RemainingCapacity(),
-      base::Bind(&ReadBufferingStreamSocket::OnReadCompleted,
-                 base::Unretained(this)));
+  int rv =
+      transport_->Read(read_buffer_.get(),
+                       read_buffer_->RemainingCapacity(),
+                       base::Bind(&ReadBufferingStreamSocket::OnReadCompleted,
+                                  base::Unretained(this)));
   return rv;
 }
 
@@ -835,8 +835,8 @@ TEST_F(SSLClientSocketTest, Read) {
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
@@ -845,7 +845,7 @@ TEST_F(SSLClientSocketTest, Read) {
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
   for (;;) {
-    rv = sock->Read(buf, 4096, callback.callback());
+    rv = sock->Read(buf.get(), 4096, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
     if (rv == net::ERR_IO_PENDING)
@@ -897,8 +897,8 @@ TEST_F(SSLClientSocketTest, Read_WithSynchronousError) {
       new net::IOBuffer(kRequestTextSize));
   memcpy(request_buffer->data(), request_text, kRequestTextSize);
 
-  rv = callback.GetResult(sock->Write(request_buffer, kRequestTextSize,
-                                      callback.callback()));
+  rv = callback.GetResult(
+      sock->Write(request_buffer.get(), kRequestTextSize, callback.callback()));
   EXPECT_EQ(kRequestTextSize, rv);
 
   // Simulate an unclean/forcible shutdown.
@@ -909,7 +909,7 @@ TEST_F(SSLClientSocketTest, Read_WithSynchronousError) {
   // Note: This test will hang if this bug has regressed. Simply checking that
   // rv != ERR_IO_PENDING is insufficient, as ERR_IO_PENDING is a legitimate
   // result when using a dedicated task runner for NSS.
-  rv = callback.GetResult(sock->Read(buf, 4096, callback.callback()));
+  rv = callback.GetResult(sock->Read(buf.get(), 4096, callback.callback()));
 
 #if !defined(USE_OPENSSL)
   // NSS records the error exactly
@@ -952,7 +952,7 @@ TEST_F(SSLClientSocketTest, Read_FullDuplex) {
 
   // Issue a "hanging" Read first.
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
-  rv = sock->Read(buf, 4096, callback.callback());
+  rv = sock->Read(buf.get(), 4096, callback.callback());
   // We haven't written the request, so there should be no response yet.
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
@@ -968,7 +968,8 @@ TEST_F(SSLClientSocketTest, Read_FullDuplex) {
       new net::StringIOBuffer(request_text));
 
   net::TestCompletionCallback callback2;  // Used for Write only.
-  rv = sock->Write(request_buffer, request_text.size(), callback2.callback());
+  rv = sock->Write(
+      request_buffer.get(), request_text.size(), callback2.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
@@ -1039,7 +1040,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
   // the ERR_IO_PENDING caused by SetReadShouldBlock() and thus return.
   DeleteSocketCallback read_callback(sock);
   scoped_refptr<net::IOBuffer> read_buf(new net::IOBuffer(4096));
-  rv = sock->Read(read_buf, 4096, read_callback.callback());
+  rv = sock->Read(read_buf.get(), 4096, read_callback.callback());
 
   // Ensure things didn't complete synchronously, otherwise |sock| is invalid.
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
@@ -1062,7 +1063,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
   // SSLClientSocketOpenSSL::Write() will not return until all of
   // |request_buffer| has been written to the underlying BIO (although not
   // necessarily the underlying transport).
-  rv = callback.GetResult(sock->Write(request_buffer,
+  rv = callback.GetResult(sock->Write(request_buffer.get(),
                                       request_buffer->BytesRemaining(),
                                       callback.callback()));
   ASSERT_LT(0, rv);
@@ -1077,7 +1078,8 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
   // Attempt to write the remaining data. NSS will not be able to consume the
   // application data because the internal buffers are full, while OpenSSL will
   // return that its blocked because the underlying transport is blocked.
-  rv = sock->Write(request_buffer, request_buffer->BytesRemaining(),
+  rv = sock->Write(request_buffer.get(),
+                   request_buffer->BytesRemaining(),
                    callback.callback());
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
   ASSERT_FALSE(callback.have_result());
@@ -1132,8 +1134,8 @@ TEST_F(SSLClientSocketTest, Read_SmallChunks) {
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
@@ -1142,7 +1144,7 @@ TEST_F(SSLClientSocketTest, Read_SmallChunks) {
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(1));
   for (;;) {
-    rv = sock->Read(buf, 1, callback.callback());
+    rv = sock->Read(buf.get(), 1, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
     if (rv == net::ERR_IO_PENDING)
@@ -1186,7 +1188,7 @@ TEST_F(SSLClientSocketTest, Read_ManySmallRecords) {
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
   rv = callback.GetResult(sock->Write(
-      request_buffer, arraysize(request_text) - 1, callback.callback()));
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback()));
   ASSERT_GT(rv, 0);
   ASSERT_EQ(static_cast<int>(arraysize(request_text) - 1), rv);
 
@@ -1202,7 +1204,7 @@ TEST_F(SSLClientSocketTest, Read_ManySmallRecords) {
   transport->SetBufferSize(15000);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(8192));
-  rv = callback.GetResult(sock->Read(buffer, 8192, callback.callback()));
+  rv = callback.GetResult(sock->Read(buffer.get(), 8192, callback.callback()));
   ASSERT_EQ(rv, 8192);
 }
 
@@ -1237,8 +1239,8 @@ TEST_F(SSLClientSocketTest, Read_Interrupted) {
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
@@ -1247,7 +1249,7 @@ TEST_F(SSLClientSocketTest, Read_Interrupted) {
 
   // Do a partial read and then exit.  This test should not crash!
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(512));
-  rv = sock->Read(buf, 512, callback.callback());
+  rv = sock->Read(buf.get(), 512, callback.callback());
   EXPECT_TRUE(rv > 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
@@ -1290,8 +1292,8 @@ TEST_F(SSLClientSocketTest, Read_FullLogging) {
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
@@ -1306,7 +1308,7 @@ TEST_F(SSLClientSocketTest, Read_FullLogging) {
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
   for (;;) {
-    rv = sock->Read(buf, 4096, callback.callback());
+    rv = sock->Read(buf.get(), 4096, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
     if (rv == net::ERR_IO_PENDING)
@@ -1577,14 +1579,14 @@ TEST_F(SSLClientSocketTest, VerifyReturnChainProperlyOrdered) {
 
   // Add a rule that maps the server cert (A) to the chain of A->B->C2
   // rather than A->B->C.
-  cert_verifier_->AddResultForCert(certs[0], verify_result, net::OK);
+  cert_verifier_->AddResultForCert(certs[0].get(), verify_result, net::OK);
 
   // Load and install the root for the validated chain.
   scoped_refptr<net::X509Certificate> root_cert =
     net::ImportCertFromFile(net::GetTestCertsDirectory(),
                            "redundant-validated-chain-root.pem");
   ASSERT_NE(static_cast<net::X509Certificate*>(NULL), root_cert);
-  net::ScopedTestRoot scoped_root(root_cert);
+  net::ScopedTestRoot scoped_root(root_cert.get());
 
   // Set up a test server with CERT_CHAIN_WRONG_ROOT.
   net::SpawnedTestServer::SSLOptions ssl_options(
@@ -1692,7 +1694,7 @@ TEST_F(SSLClientSocketCertRequestInfoTest, NoAuthorities) {
   ssl_options.request_client_certificate = true;
   scoped_refptr<net::SSLCertRequestInfo> request_info =
       GetCertRequest(ssl_options);
-  ASSERT_TRUE(request_info);
+  ASSERT_TRUE(request_info.get());
   EXPECT_EQ(0u, request_info->cert_authorities.size());
 }
 
@@ -1733,7 +1735,7 @@ TEST_F(SSLClientSocketCertRequestInfoTest, TwoAuthorities) {
       net::GetTestClientCertsDirectory().Append(kDiginotarFile));
   scoped_refptr<net::SSLCertRequestInfo> request_info =
       GetCertRequest(ssl_options);
-  ASSERT_TRUE(request_info);
+  ASSERT_TRUE(request_info.get());
   ASSERT_EQ(2u, request_info->cert_authorities.size());
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kThawteDN), kThawteLen),
             request_info->cert_authorities[0]);
diff --git a/net/socket/ssl_server_socket_nss.cc b/net/socket/ssl_server_socket_nss.cc
index 658aff7..c2681d3 100644
--- a/net/socket/ssl_server_socket_nss.cc
+++ b/net/socket/ssl_server_socket_nss.cc
@@ -200,7 +200,7 @@ int SSLServerSocketNSS::Read(IOBuffer* buf, int buf_len,
                              const CompletionCallback& callback) {
   DCHECK(user_read_callback_.is_null());
   DCHECK(user_handshake_callback_.is_null());
-  DCHECK(!user_read_buf_);
+  DCHECK(!user_read_buf_.get());
   DCHECK(nss_bufs_);
   DCHECK(!callback.is_null());
 
@@ -223,7 +223,7 @@ int SSLServerSocketNSS::Read(IOBuffer* buf, int buf_len,
 int SSLServerSocketNSS::Write(IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
   DCHECK(user_write_callback_.is_null());
-  DCHECK(!user_write_buf_);
+  DCHECK(!user_write_buf_.get());
   DCHECK(nss_bufs_);
   DCHECK(!callback.is_null());
 
@@ -486,7 +486,7 @@ void SSLServerSocketNSS::OnSendComplete(int result) {
   if (!completed_handshake_)
     return;
 
-  if (user_write_buf_) {
+  if (user_write_buf_.get()) {
     int rv = DoWriteLoop(result);
     if (rv != ERR_IO_PENDING)
       DoWriteCallback(rv);
@@ -505,7 +505,7 @@ void SSLServerSocketNSS::OnRecvComplete(int result) {
 
   // Network layer received some data, check if client requested to read
   // decrypted data.
-  if (!user_read_buf_ || !completed_handshake_)
+  if (!user_read_buf_.get() || !completed_handshake_)
     return;
 
   int rv = DoReadLoop(result);
@@ -541,7 +541,8 @@ int SSLServerSocketNSS::BufferSend(void) {
     memcpy(send_buffer->data(), buf1, len1);
     memcpy(send_buffer->data() + len1, buf2, len2);
     rv = transport_socket_->Write(
-        send_buffer, len,
+        send_buffer.get(),
+        len,
         base::Bind(&SSLServerSocketNSS::BufferSendComplete,
                    base::Unretained(this)));
     if (rv == ERR_IO_PENDING) {
@@ -572,7 +573,8 @@ int SSLServerSocketNSS::BufferRecv(void) {
   } else {
     recv_buffer_ = new IOBuffer(nb);
     rv = transport_socket_->Read(
-        recv_buffer_, nb,
+        recv_buffer_.get(),
+        nb,
         base::Bind(&SSLServerSocketNSS::BufferRecvComplete,
                    base::Unretained(this)));
     if (rv == ERR_IO_PENDING) {
@@ -620,7 +622,7 @@ bool SSLServerSocketNSS::DoTransportIO() {
 }
 
 int SSLServerSocketNSS::DoPayloadRead() {
-  DCHECK(user_read_buf_);
+  DCHECK(user_read_buf_.get());
   DCHECK_GT(user_read_buf_len_, 0);
   int rv = PR_Read(nss_fd_, user_read_buf_->data(), user_read_buf_len_);
   if (rv >= 0)
@@ -636,7 +638,7 @@ int SSLServerSocketNSS::DoPayloadRead() {
 }
 
 int SSLServerSocketNSS::DoPayloadWrite() {
-  DCHECK(user_write_buf_);
+  DCHECK(user_write_buf_.get());
   int rv = PR_Write(nss_fd_, user_write_buf_->data(), user_write_buf_len_);
   if (rv >= 0)
     return rv;
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index 653530c..da388b9 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -267,11 +267,12 @@ TEST(FakeSocketTest, DataTransfer) {
   scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(kReadBufSize);
 
   // Write then read.
-  int written = server.Write(write_buf, kTestDataSize, CompletionCallback());
+  int written =
+      server.Write(write_buf.get(), kTestDataSize, CompletionCallback());
   EXPECT_GT(written, 0);
   EXPECT_LE(written, kTestDataSize);
 
-  int read = client.Read(read_buf, kReadBufSize, CompletionCallback());
+  int read = client.Read(read_buf.get(), kReadBufSize, CompletionCallback());
   EXPECT_GT(read, 0);
   EXPECT_LE(read, written);
   EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
@@ -279,9 +280,9 @@ TEST(FakeSocketTest, DataTransfer) {
   // Read then write.
   TestCompletionCallback callback;
   EXPECT_EQ(net::ERR_IO_PENDING,
-            server.Read(read_buf, kReadBufSize, callback.callback()));
+            server.Read(read_buf.get(), kReadBufSize, callback.callback()));
 
-  written = client.Write(write_buf, kTestDataSize, CompletionCallback());
+  written = client.Write(write_buf.get(), kTestDataSize, CompletionCallback());
   EXPECT_GT(written, 0);
   EXPECT_LE(written, kTestDataSize);
 
@@ -343,9 +344,8 @@ class SSLServerSocketTest : public PlatformTest {
     client_socket_.reset(
         socket_factory_->CreateSSLClientSocket(
             fake_client_socket, host_and_pair, ssl_config, context));
-    server_socket_.reset(net::CreateSSLServerSocket(fake_server_socket,
-                                                    cert, private_key.get(),
-                                                    net::SSLConfig()));
+    server_socket_.reset(net::CreateSSLServerSocket(
+        fake_server_socket, cert.get(), private_key.get(), net::SSLConfig()));
   }
 
   FakeDataChannel channel_1_;
@@ -422,11 +422,11 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
   // Write then read.
   TestCompletionCallback write_callback;
   TestCompletionCallback read_callback;
-  server_ret = server_socket_->Write(write_buf, write_buf->size(),
-                                     write_callback.callback());
+  server_ret = server_socket_->Write(
+      write_buf.get(), write_buf->size(), write_callback.callback());
   EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
-  client_ret = client_socket_->Read(read_buf, read_buf->BytesRemaining(),
-                                    read_callback.callback());
+  client_ret = client_socket_->Read(
+      read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
   EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
 
   server_ret = write_callback.GetResult(server_ret);
@@ -436,8 +436,8 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
 
   read_buf->DidConsume(client_ret);
   while (read_buf->BytesConsumed() < write_buf->size()) {
-    client_ret = client_socket_->Read(read_buf, read_buf->BytesRemaining(),
-                                      read_callback.callback());
+    client_ret = client_socket_->Read(
+        read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
     EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
     client_ret = read_callback.GetResult(client_ret);
     ASSERT_GT(client_ret, 0);
@@ -449,11 +449,11 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
 
   // Read then write.
   write_buf = new net::StringIOBuffer("hello123");
-  server_ret = server_socket_->Read(read_buf, read_buf->BytesRemaining(),
-                                    read_callback.callback());
+  server_ret = server_socket_->Read(
+      read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
   EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
-  client_ret = client_socket_->Write(write_buf, write_buf->size(),
-                                     write_callback.callback());
+  client_ret = client_socket_->Write(
+      write_buf.get(), write_buf->size(), write_callback.callback());
   EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
 
   server_ret = read_callback.GetResult(server_ret);
@@ -463,8 +463,8 @@ TEST_F(SSLServerSocketTest, DataTransfer) {
 
   read_buf->DidConsume(server_ret);
   while (read_buf->BytesConsumed() < write_buf->size()) {
-    server_ret = server_socket_->Read(read_buf, read_buf->BytesRemaining(),
-                                      read_callback.callback());
+    server_ret = server_socket_->Read(
+        read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
     EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
     server_ret = read_callback.GetResult(server_ret);
     ASSERT_GT(server_ret, 0);
@@ -506,8 +506,8 @@ TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
   // will call Read() on the transport socket again.
   TestCompletionCallback write_callback;
 
-  server_ret = server_socket_->Write(write_buf, write_buf->size(),
-                                     write_callback.callback());
+  server_ret = server_socket_->Write(
+      write_buf.get(), write_buf->size(), write_callback.callback());
   EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
 
   server_ret = write_callback.GetResult(server_ret);
@@ -516,8 +516,8 @@ TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
   server_socket_->Disconnect();
 
   // The client writes some data. This should not cause an infinite loop.
-  client_ret = client_socket_->Write(write_buf, write_buf->size(),
-                                     write_callback.callback());
+  client_ret = client_socket_->Write(
+      write_buf.get(), write_buf->size(), write_callback.callback());
   EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
 
   client_ret = write_callback.GetResult(client_ret);
diff --git a/net/socket/tcp_listen_socket.cc b/net/socket/tcp_listen_socket.cc
index 9484cb9..aab2e45 100644
--- a/net/socket/tcp_listen_socket.cc
+++ b/net/socket/tcp_listen_socket.cc
@@ -110,7 +110,7 @@ void TCPListenSocket::Accept() {
 #if defined(OS_POSIX)
   sock->WatchSocket(WAITING_READ);
 #endif
-  socket_delegate_->DidAccept(this, sock);
+  socket_delegate_->DidAccept(this, sock.get());
 }
 
 TCPListenSocketFactory::TCPListenSocketFactory(const string& ip, int port)
diff --git a/net/socket/tcp_listen_socket_unittest.cc b/net/socket/tcp_listen_socket_unittest.cc
index a4edd21..19dd658 100644
--- a/net/socket/tcp_listen_socket_unittest.cc
+++ b/net/socket/tcp_listen_socket_unittest.cc
@@ -43,7 +43,7 @@ void TCPListenSocketTester::SetUp() {
 
   // verify Listen succeeded
   NextAction();
-  ASSERT_FALSE(server_ == NULL);
+  ASSERT_FALSE(server_.get() == NULL);
   ASSERT_EQ(ACTION_LISTEN, last_action_.type());
 
   // verify the connect/accept and setup test_socket_
@@ -127,7 +127,7 @@ void TCPListenSocketTester::Shutdown() {
 
 void TCPListenSocketTester::Listen() {
   server_ = DoListen();
-  ASSERT_TRUE(server_);
+  ASSERT_TRUE(server_.get());
   server_->AddRef();
   ReportAction(TCPListenSocketTestAction(ACTION_LISTEN));
 }
diff --git a/net/socket/tcp_server_socket_unittest.cc b/net/socket/tcp_server_socket_unittest.cc
index 62f3f37..fd81e55 100644
--- a/net/socket/tcp_server_socket_unittest.cc
+++ b/net/socket/tcp_server_socket_unittest.cc
@@ -220,9 +220,8 @@ TEST_F(TCPServerSocketTest, AcceptIO) {
     memmove(write_buffer->data(), message.data(), message.size());
 
     TestCompletionCallback write_callback;
-    int write_result = accepted_socket->Write(write_buffer,
-                                              write_buffer->size(),
-                                              write_callback.callback());
+    int write_result = accepted_socket->Write(
+        write_buffer.get(), write_buffer->size(), write_callback.callback());
     write_result = write_callback.GetResult(write_result);
     ASSERT_TRUE(write_result >= 0);
     ASSERT_TRUE(bytes_written + write_result <= message.size());
@@ -234,9 +233,8 @@ TEST_F(TCPServerSocketTest, AcceptIO) {
     scoped_refptr<net::IOBufferWithSize> read_buffer(
         new net::IOBufferWithSize(message.size() - bytes_read));
     TestCompletionCallback read_callback;
-    int read_result = connecting_socket.Read(read_buffer,
-                                             read_buffer->size(),
-                                             read_callback.callback());
+    int read_result = connecting_socket.Read(
+        read_buffer.get(), read_buffer->size(), read_callback.callback());
     read_result = read_callback.GetResult(read_result);
     ASSERT_TRUE(read_result >= 0);
     ASSERT_TRUE(bytes_read + read_result <= message.size());
diff --git a/net/socket/transport_client_socket_unittest.cc b/net/socket/transport_client_socket_unittest.cc
index b5935e3..2f75e74 100644
--- a/net/socket/transport_client_socket_unittest.cc
+++ b/net/socket/transport_client_socket_unittest.cc
@@ -116,7 +116,7 @@ void TransportClientSocketTest::SetUp() {
     if (sock.get())
       break;
   }
-  ASSERT_TRUE(sock != NULL);
+  ASSERT_TRUE(sock.get() != NULL);
   listen_sock_ = sock;
   listen_port_ = port;
 
@@ -164,8 +164,8 @@ void TransportClientSocketTest::SendClientRequest() {
   int rv;
 
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
-  rv = sock_->Write(request_buffer, arraysize(request_text) - 1,
-                    callback.callback());
+  rv = sock_->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
   if (rv == ERR_IO_PENDING)
@@ -225,7 +225,7 @@ TEST_P(TransportClientSocketTest, IsConnected) {
   SendClientRequest();
 
   // Drain a single byte so we know we've received some data.
-  bytes_read = DrainClientSocket(buf, 1, 1, &callback);
+  bytes_read = DrainClientSocket(buf.get(), 1, 1, &callback);
   ASSERT_EQ(bytes_read, 1u);
 
   // Socket should be considered connected, but not idle, due to
@@ -233,8 +233,8 @@ TEST_P(TransportClientSocketTest, IsConnected) {
   EXPECT_TRUE(sock_->IsConnected());
   EXPECT_FALSE(sock_->IsConnectedAndIdle());
 
-  bytes_read = DrainClientSocket(buf, 4096, arraysize(kServerReply) - 2,
-                                 &callback);
+  bytes_read = DrainClientSocket(
+      buf.get(), 4096, arraysize(kServerReply) - 2, &callback);
   ASSERT_EQ(bytes_read, arraysize(kServerReply) - 2);
 
   // After draining the data, the socket should be back to connected
@@ -246,15 +246,15 @@ TEST_P(TransportClientSocketTest, IsConnected) {
   set_close_server_socket_on_next_send(true);
   SendClientRequest();
 
-  bytes_read = DrainClientSocket(buf, 1, 1, &callback);
+  bytes_read = DrainClientSocket(buf.get(), 1, 1, &callback);
   ASSERT_EQ(bytes_read, 1u);
 
   // As above because of data.
   EXPECT_TRUE(sock_->IsConnected());
   EXPECT_FALSE(sock_->IsConnectedAndIdle());
 
-  bytes_read = DrainClientSocket(buf, 4096, arraysize(kServerReply) - 2,
-                                 &callback);
+  bytes_read = DrainClientSocket(
+      buf.get(), 4096, arraysize(kServerReply) - 2, &callback);
   ASSERT_EQ(bytes_read, arraysize(kServerReply) - 2);
 
   // Once the data is drained, the socket should now be seen as not
@@ -262,7 +262,7 @@ TEST_P(TransportClientSocketTest, IsConnected) {
   if (sock_->IsConnected()) {
     // In the unlikely event that the server's connection closure is not
     // processed in time, wait for the connection to be closed.
-    rv = sock_->Read(buf, 4096, callback.callback());
+    rv = sock_->Read(buf.get(), 4096, callback.callback());
     EXPECT_EQ(0, callback.GetResult(rv));
     EXPECT_FALSE(sock_->IsConnected());
   }
@@ -281,14 +281,14 @@ TEST_P(TransportClientSocketTest, Read) {
   SendClientRequest();
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
-  uint32 bytes_read = DrainClientSocket(buf, 4096, arraysize(kServerReply) - 1,
-                                        &callback);
+  uint32 bytes_read = DrainClientSocket(
+      buf.get(), 4096, arraysize(kServerReply) - 1, &callback);
   ASSERT_EQ(bytes_read, arraysize(kServerReply) - 1);
 
   // All data has been read now.  Read once more to force an ERR_IO_PENDING, and
   // then close the server socket, and note the close.
 
-  rv = sock_->Read(buf, 4096, callback.callback());
+  rv = sock_->Read(buf.get(), 4096, callback.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   CloseServerSocket();
   EXPECT_EQ(0, callback.WaitForResult());
@@ -308,7 +308,7 @@ TEST_P(TransportClientSocketTest, Read_SmallChunks) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(1));
   uint32 bytes_read = 0;
   while (bytes_read < arraysize(kServerReply) - 1) {
-    rv = sock_->Read(buf, 1, callback.callback());
+    rv = sock_->Read(buf.get(), 1, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
     if (rv == ERR_IO_PENDING)
@@ -321,7 +321,7 @@ TEST_P(TransportClientSocketTest, Read_SmallChunks) {
   // All data has been read now.  Read once more to force an ERR_IO_PENDING, and
   // then close the server socket, and note the close.
 
-  rv = sock_->Read(buf, 1, callback.callback());
+  rv = sock_->Read(buf.get(), 1, callback.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   CloseServerSocket();
   EXPECT_EQ(0, callback.WaitForResult());
@@ -340,7 +340,7 @@ TEST_P(TransportClientSocketTest, Read_Interrupted) {
 
   // Do a partial read and then exit.  This test should not crash!
   scoped_refptr<IOBuffer> buf(new IOBuffer(16));
-  rv = sock_->Read(buf, 16, callback.callback());
+  rv = sock_->Read(buf.get(), 16, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
   if (rv == ERR_IO_PENDING)
@@ -362,7 +362,7 @@ TEST_P(TransportClientSocketTest, DISABLED_FullDuplex_ReadFirst) {
   // Read first.  There's no data, so it should return ERR_IO_PENDING.
   const int kBufLen = 4096;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kBufLen));
-  rv = sock_->Read(buf, kBufLen, callback.callback());
+  rv = sock_->Read(buf.get(), kBufLen, callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   PauseServerReads();
@@ -373,7 +373,8 @@ TEST_P(TransportClientSocketTest, DISABLED_FullDuplex_ReadFirst) {
   TestCompletionCallback write_callback;
 
   while (true) {
-    rv = sock_->Write(request_buffer, kWriteBufLen, write_callback.callback());
+    rv = sock_->Write(
+        request_buffer.get(), kWriteBufLen, write_callback.callback());
     ASSERT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
     if (rv == ERR_IO_PENDING) {
@@ -409,7 +410,8 @@ TEST_P(TransportClientSocketTest, DISABLED_FullDuplex_WriteFirst) {
   TestCompletionCallback write_callback;
 
   while (true) {
-    rv = sock_->Write(request_buffer, kWriteBufLen, write_callback.callback());
+    rv = sock_->Write(
+        request_buffer.get(), kWriteBufLen, write_callback.callback());
     ASSERT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
     if (rv == ERR_IO_PENDING)
@@ -422,7 +424,7 @@ TEST_P(TransportClientSocketTest, DISABLED_FullDuplex_WriteFirst) {
   const int kBufLen = 4096;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kBufLen));
   while (true) {
-    rv = sock_->Read(buf, kBufLen, callback.callback());
+    rv = sock_->Read(buf.get(), kBufLen, callback.callback());
     ASSERT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
     if (rv == ERR_IO_PENDING)
       break;
diff --git a/net/socket/unix_domain_socket_posix.cc b/net/socket/unix_domain_socket_posix.cc
index 4eb7261..5b6b249 100644
--- a/net/socket/unix_domain_socket_posix.cc
+++ b/net/socket/unix_domain_socket_posix.cc
@@ -151,7 +151,7 @@ void UnixDomainSocket::Accept() {
       new UnixDomainSocket(conn, socket_delegate_, auth_callback_));
   // It's up to the delegate to AddRef if it wants to keep it around.
   sock->WatchSocket(WAITING_READ);
-  socket_delegate_->DidAccept(this, sock);
+  socket_delegate_->DidAccept(this, sock.get());
 }
 
 UnixDomainSocketFactory::UnixDomainSocketFactory(
diff --git a/net/socket_stream/socket_stream.cc b/net/socket_stream/socket_stream.cc
index 2aa3516..5639171 100644
--- a/net/socket_stream/socket_stream.cc
+++ b/net/socket_stream/socket_stream.cc
@@ -218,7 +218,7 @@ bool SocketStream::SendData(const char* data, int len) {
     return false;
 
   int total_buffered_bytes = len;
-  if (current_write_buf_) {
+  if (current_write_buf_.get()) {
     // Since
     // - the purpose of this check is to limit the amount of buffer used by
     //   this instance.
@@ -242,7 +242,7 @@ bool SocketStream::SendData(const char* data, int len) {
   // the loop, and therefore we don't need to enqueue DoLoop(). If b), it's ok
   // to do nothing. If current_write_buf_ is NULL, to make sure DoLoop() is
   // ran soon, enequeue it.
-  if (!current_write_buf_) {
+  if (!current_write_buf_.get()) {
     // Send pending data asynchronously, so that delegate won't be called
     // back before returning from SendData().
     base::MessageLoop::current()->PostTask(
@@ -348,7 +348,7 @@ void SocketStream::DoClose() {
   // the SocketStream.
   // If it's writing now, we should defer the closing after the current
   // writing is completed.
-  if (next_state_ == STATE_READ_WRITE && !current_write_buf_)
+  if (next_state_ == STATE_READ_WRITE && !current_write_buf_.get())
     DoLoop(ERR_ABORTED);
 
   // In other next_state_, we'll wait for callback of other APIs, such as
@@ -393,7 +393,7 @@ int SocketStream::DidEstablishConnection() {
 }
 
 int SocketStream::DidReceiveData(int result) {
-  DCHECK(read_buf_);
+  DCHECK(read_buf_.get());
   DCHECK_GT(result, 0);
   net_log_.AddEvent(NetLog::TYPE_SOCKET_STREAM_RECEIVED);
   int len = result;
@@ -408,7 +408,7 @@ int SocketStream::DidReceiveData(int result) {
 
 void SocketStream::DidSendData(int result) {
   DCHECK_GT(result, 0);
-  DCHECK(current_write_buf_);
+  DCHECK(current_write_buf_.get());
   net_log_.AddEvent(NetLog::TYPE_SOCKET_STREAM_SENT);
 
   int bytes_sent = result;
@@ -440,7 +440,7 @@ void SocketStream::OnReadCompleted(int result) {
     // 0 indicates end-of-file, so socket was closed.
     // Don't close the socket if it's still writing.
     server_closed_ = true;
-  } else if (result > 0 && read_buf_) {
+  } else if (result > 0 && read_buf_.get()) {
     result = DidReceiveData(result);
   }
   DoLoop(result);
@@ -821,7 +821,7 @@ int SocketStream::DoWriteTunnelHeaders() {
   int buf_len = static_cast<int>(tunnel_request_headers_->headers_.size() -
                                  tunnel_request_headers_bytes_sent_);
   DCHECK_GT(buf_len, 0);
-  return socket_->Write(tunnel_request_headers_, buf_len, io_callback_);
+  return socket_->Write(tunnel_request_headers_.get(), buf_len, io_callback_);
 }
 
 int SocketStream::DoWriteTunnelHeadersComplete(int result) {
@@ -864,7 +864,7 @@ int SocketStream::DoReadTunnelHeaders() {
   tunnel_response_headers_->SetDataOffset(tunnel_response_headers_len_);
   CHECK(tunnel_response_headers_->data());
 
-  return socket_->Read(tunnel_response_headers_, buf_len, io_callback_);
+  return socket_->Read(tunnel_response_headers_.get(), buf_len, io_callback_);
 }
 
 int SocketStream::DoReadTunnelHeadersComplete(int result) {
@@ -1104,7 +1104,7 @@ int SocketStream::DoReadWrite(int result) {
   // If client has requested close(), and there's nothing to write, then
   // let's close the socket.
   // We don't care about receiving data after the socket is closed.
-  if (closing_ && !current_write_buf_ && pending_write_bufs_.empty()) {
+  if (closing_ && !current_write_buf_.get() && pending_write_bufs_.empty()) {
     socket_->Disconnect();
     next_state_ = STATE_CLOSE;
     return OK;
@@ -1114,12 +1114,13 @@ int SocketStream::DoReadWrite(int result) {
 
   // If server already closed the socket, we don't try to read.
   if (!server_closed_) {
-    if (!read_buf_) {
+    if (!read_buf_.get()) {
       // No read pending and server didn't close the socket.
       read_buf_ = new IOBuffer(kReadBufferSize);
-      result = socket_->Read(read_buf_, kReadBufferSize,
-                             base::Bind(&SocketStream::OnReadCompleted,
-                                        base::Unretained(this)));
+      result = socket_->Read(
+          read_buf_.get(),
+          kReadBufferSize,
+          base::Bind(&SocketStream::OnReadCompleted, base::Unretained(this)));
       if (result > 0) {
         return DidReceiveData(result);
       } else if (result == 0) {
@@ -1138,28 +1139,27 @@ int SocketStream::DoReadWrite(int result) {
       }
     }
     // Read is pending.
-    DCHECK(read_buf_);
+    DCHECK(read_buf_.get());
   }
 
   if (waiting_for_write_completion_)
     return ERR_IO_PENDING;
 
-  if (!current_write_buf_) {
+  if (!current_write_buf_.get()) {
     if (pending_write_bufs_.empty()) {
       // Nothing buffered for send.
       return ERR_IO_PENDING;
     }
 
-    current_write_buf_ =
-        new DrainableIOBuffer(pending_write_bufs_.front(),
-                              pending_write_bufs_.front()->size());
+    current_write_buf_ = new DrainableIOBuffer(
+        pending_write_bufs_.front().get(), pending_write_bufs_.front()->size());
     pending_write_bufs_.pop_front();
   }
 
-  result = socket_->Write(current_write_buf_,
-                          current_write_buf_->BytesRemaining(),
-                          base::Bind(&SocketStream::OnWriteCompleted,
-                                     base::Unretained(this)));
+  result = socket_->Write(
+      current_write_buf_.get(),
+      current_write_buf_->BytesRemaining(),
+      base::Bind(&SocketStream::OnWriteCompleted, base::Unretained(this)));
 
   if (result == ERR_IO_PENDING) {
     waiting_for_write_completion_ = true;
@@ -1192,7 +1192,7 @@ int SocketStream::HandleCertificateRequest(int result, SSLConfig* ssl_config) {
   scoped_refptr<SSLCertRequestInfo> cert_request_info = new SSLCertRequestInfo;
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(socket_.get());
-  ssl_socket->GetSSLCertRequestInfo(cert_request_info);
+  ssl_socket->GetSSLCertRequestInfo(cert_request_info.get());
 
   HttpTransactionFactory* factory = context_->http_transaction_factory();
   if (!factory)
@@ -1219,7 +1219,7 @@ int SocketStream::HandleCertificateRequest(int result, SSLConfig* ssl_config) {
   // CertificateRequest message.
   const std::vector<std::string>& cert_authorities =
       cert_request_info->cert_authorities;
-  if (client_cert && !cert_authorities.empty() &&
+  if (client_cert.get() && !cert_authorities.empty() &&
       !client_cert->IsIssuedByEncoded(cert_authorities)) {
     return result;
   }
@@ -1240,8 +1240,8 @@ int SocketStream::AllowCertErrorForReconnection(SSLConfig* ssl_config) {
   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(socket_.get());
   SSLInfo ssl_info;
   ssl_socket->GetSSLInfo(&ssl_info);
-  if (ssl_info.cert == NULL ||
-      ssl_config->IsAllowedBadCert(ssl_info.cert, NULL)) {
+  if (ssl_info.cert.get() == NULL ||
+      ssl_config->IsAllowedBadCert(ssl_info.cert.get(), NULL)) {
     // If we already have the certificate in the set of allowed bad
     // certificates, we did try it and failed again, so we should not
     // retry again: the connection should fail at last.
diff --git a/net/spdy/spdy_http_stream.cc b/net/spdy/spdy_http_stream.cc
index d8b33fb..642da2c 100644
--- a/net/spdy/spdy_http_stream.cc
+++ b/net/spdy/spdy_http_stream.cc
@@ -141,7 +141,7 @@ int SpdyHttpStream::ReadResponseBody(
   }
 
   CHECK(callback_.is_null());
-  CHECK(!user_buffer_);
+  CHECK(!user_buffer_.get());
   CHECK_EQ(0, user_buffer_len_);
 
   callback_ = callback;
@@ -187,7 +187,7 @@ bool SpdyHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
   // The reused flag can only be correctly set once a stream has an ID.  Streams
   // get their IDs once the request has been successfully sent, so this does not
   // behave that differently from other stream types.
-  if (!spdy_session_ || (!stream_ && !stream_closed_))
+  if (!spdy_session_.get() || (!stream_ && !stream_closed_))
     return false;
 
   SpdyStreamId stream_id =
@@ -218,7 +218,7 @@ int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
   if (response_info_)
     response_info_->request_time = request_time;
 
-  CHECK(!request_body_buf_);
+  CHECK(!request_body_buf_.get());
   if (HasUploadData()) {
     // Use kMaxSpdyFrameChunkSize as the buffer size, since the request
     // body data is written with this size at a time.
@@ -347,7 +347,8 @@ int SpdyHttpStream::OnResponseHeadersReceived(const SpdyHeaderBlock& response,
     default:
       NOTREACHED();
   }
-  response_info_->vary_data.Init(*request_info_, *response_info_->headers);
+  response_info_->vary_data
+      .Init(*request_info_, *response_info_->headers.get());
   // TODO(ahendrickson): This is recorded after the entire SYN_STREAM control
   // frame has been received and processed.  Move to framer?
   response_info_->response_time = response_time;
@@ -373,7 +374,7 @@ int SpdyHttpStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   if (buffer) {
     response_body_queue_.Enqueue(buffer.Pass());
 
-    if (user_buffer_) {
+    if (user_buffer_.get()) {
       // Handing small chunks of data to the caller creates measurable overhead.
       // We buffer data in short time-spans and send a single read notification.
       ScheduleBufferedReadCallback();
@@ -429,11 +430,11 @@ void SpdyHttpStream::ReadAndSendRequestBodyData() {
     return;
 
   // Read the data from the request body stream.
-  const int rv = request_info_->upload_data_stream->Read(
-      request_body_buf_, request_body_buf_->size(),
-      base::Bind(
-          &SpdyHttpStream::OnRequestBodyReadCompleted,
-          weak_factory_.GetWeakPtr()));
+  const int rv = request_info_->upload_data_stream
+      ->Read(request_body_buf_.get(),
+             request_body_buf_->size(),
+             base::Bind(&SpdyHttpStream::OnRequestBodyReadCompleted,
+                        weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING) {
     // ERR_IO_PENDING is the only possible error.
@@ -451,7 +452,7 @@ void SpdyHttpStream::OnRequestBodyReadCompleted(int status) {
   } else {
     CHECK_GT(request_body_buf_size_, 0);
   }
-  stream_->SendData(request_body_buf_,
+  stream_->SendData(request_body_buf_.get(),
                     request_body_buf_size_,
                     eof ? NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND);
 }
@@ -508,8 +509,8 @@ bool SpdyHttpStream::DoBufferedReadCallback() {
   }
 
   int rv = 0;
-  if (user_buffer_) {
-    rv = ReadResponseBody(user_buffer_, user_buffer_len_, callback_);
+  if (user_buffer_.get()) {
+    rv = ReadResponseBody(user_buffer_.get(), user_buffer_len_, callback_);
     CHECK_NE(rv, ERR_IO_PENDING);
     user_buffer_ = NULL;
     user_buffer_len_ = 0;
diff --git a/net/spdy/spdy_http_stream_spdy2_unittest.cc b/net/spdy/spdy_http_stream_spdy2_unittest.cc
index a2396bd..06bab80 100644
--- a/net/spdy/spdy_http_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_http_stream_spdy2_unittest.cc
@@ -296,7 +296,8 @@ TEST_F(SpdyHttpStreamSpdy2Test, LoadTimingTwoRequests) {
   // Read stream 1 to completion, before making sure we can still read load
   // timing from both streams.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(1));
-  ASSERT_EQ(0, http_stream1->ReadResponseBody(buf1, 1, callback1.callback()));
+  ASSERT_EQ(
+      0, http_stream1->ReadResponseBody(buf1.get(), 1, callback1.callback()));
 
   // Stream 1 has been read to completion.
   TestLoadTimingNotReused(*http_stream1);
@@ -444,27 +445,24 @@ TEST_F(SpdyHttpStreamSpdy2Test, DelayedSendChunkedPost) {
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf1,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Read and check |chunk2| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf2(new IOBuffer(kUploadData1Size));
   ASSERT_EQ(kUploadData1Size,
-            http_stream->ReadResponseBody(buf2,
-                                          kUploadData1Size,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf2.get(), kUploadData1Size, callback.callback()));
   EXPECT_EQ(kUploadData1, std::string(buf2->data(), kUploadData1Size));
 
   // Read and check |chunk3| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf3(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf3,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf3.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf3->data(), kUploadDataSize));
 
   // Finish reading the |EOF|.
@@ -503,11 +501,11 @@ TEST_F(SpdyHttpStreamSpdy2Test, SpdyURLTest) {
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
-  ASSERT_EQ(
-      OK,
-      http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
-                                    net_log, CompletionCallback()));
+  scoped_ptr<SpdyHttpStream> http_stream(
+      new SpdyHttpStream(session_.get(), true));
+  ASSERT_EQ(OK,
+            http_stream->InitializeStream(
+                &request, DEFAULT_PRIORITY, net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
diff --git a/net/spdy/spdy_http_stream_spdy3_unittest.cc b/net/spdy/spdy_http_stream_spdy3_unittest.cc
index 2e42f70..f9482d6 100644
--- a/net/spdy/spdy_http_stream_spdy3_unittest.cc
+++ b/net/spdy/spdy_http_stream_spdy3_unittest.cc
@@ -316,7 +316,8 @@ TEST_F(SpdyHttpStreamSpdy3Test, LoadTimingTwoRequests) {
   // Read stream 1 to completion, before making sure we can still read load
   // timing from both streams.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(1));
-  ASSERT_EQ(0, http_stream1->ReadResponseBody(buf1, 1, callback1.callback()));
+  ASSERT_EQ(
+      0, http_stream1->ReadResponseBody(buf1.get(), 1, callback1.callback()));
 
   // Stream 1 has been read to completion.
   TestLoadTimingNotReused(*http_stream1);
@@ -488,27 +489,24 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPost) {
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf1,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Read and check |chunk2| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf2(new IOBuffer(kUploadData1Size));
   ASSERT_EQ(kUploadData1Size,
-            http_stream->ReadResponseBody(buf2,
-                                          kUploadData1Size,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf2.get(), kUploadData1Size, callback.callback()));
   EXPECT_EQ(kUploadData1, std::string(buf2->data(), kUploadData1Size));
 
   // Read and check |chunk3| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf3(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf3,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf3.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf3->data(), kUploadDataSize));
 
   // Finish reading the |EOF|.
@@ -622,9 +620,8 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPostWithWindowUpdate) {
   data.RunFor(1);
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf1,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Finish reading the |EOF|.
@@ -663,11 +660,11 @@ TEST_F(SpdyHttpStreamSpdy3Test, SpdyURLTest) {
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
-  ASSERT_EQ(
-      OK,
-      http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
-                                    net_log, CompletionCallback()));
+  scoped_ptr<SpdyHttpStream> http_stream(
+      new SpdyHttpStream(session_.get(), true));
+  ASSERT_EQ(OK,
+            http_stream->InitializeStream(
+                &request, DEFAULT_PRIORITY, net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
diff --git a/net/spdy/spdy_network_transaction_spdy2_unittest.cc b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
index 4d93181..35d4ea3 100644
--- a/net/spdy/spdy_network_transaction_spdy2_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
@@ -172,7 +172,7 @@ class SpdyNetworkTransactionSpdy2Test
       }
 
       // We're now ready to use SSL-npn SPDY.
-      trans_.reset(new HttpNetworkTransaction(priority_, session_));
+      trans_.reset(new HttpNetworkTransaction(priority_, session_.get()));
     }
 
     // Start the transaction, read some data, finish.
@@ -200,7 +200,7 @@ class SpdyNetworkTransactionSpdy2Test
       // Verify responses.
       const HttpResponseInfo* response = trans_->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
-      ASSERT_TRUE(response->headers != NULL);
+      ASSERT_TRUE(response->headers.get() != NULL);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);
       EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);
@@ -490,7 +490,7 @@ class SpdyNetworkTransactionSpdy2Test
     scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
-      int rv = trans->Read(buf, kSize, callback.callback());
+      int rv = trans->Read(buf.get(), kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
         // Multiple transactions may be in the data set.  Keep pulling off
         // reads until we complete our callback.
@@ -547,7 +547,7 @@ class SpdyNetworkTransactionSpdy2Test
 
     // Request the pushed path.
     scoped_ptr<HttpNetworkTransaction> trans2(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
     rv = trans2->Start(
         &CreateGetPushRequest(), callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -590,7 +590,7 @@ class SpdyNetworkTransactionSpdy2Test
       const scoped_refptr<HttpNetworkSession>& session,
       int result) {
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
     TestCompletionCallback callback;
     HttpRequestInfo request;
     request.method = "GET";
@@ -630,7 +630,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, Constructor) {
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 }
 
 TEST_P(SpdyNetworkTransactionSpdy2Test, Get) {
@@ -774,11 +774,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGets) {
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -801,7 +801,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGets) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -861,9 +861,9 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, TwoGetsLateBinding) {
   // there needs to be two sets of SSL connection data.
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -882,7 +882,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, TwoGetsLateBinding) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -892,7 +892,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, TwoGetsLateBinding) {
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
-  EXPECT_TRUE(response2->headers != NULL);
+  EXPECT_TRUE(response2->headers.get() != NULL);
   EXPECT_TRUE(response2->was_fetched_via_spdy);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
@@ -950,9 +950,9 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, TwoGetsLateBindingFromPreconnect) {
   helper.AddData(&data_placeholder);
 
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -983,7 +983,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, TwoGetsLateBindingFromPreconnect) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -993,7 +993,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, TwoGetsLateBindingFromPreconnect) {
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
-  EXPECT_TRUE(response2->headers != NULL);
+  EXPECT_TRUE(response2->headers.get() != NULL);
   EXPECT_TRUE(response2->was_fetched_via_spdy);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
@@ -1074,11 +1074,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGetsWithMaxConcurrent) {
     helper.AddData(&data_placeholder);
     helper.AddData(&data_placeholder);
     scoped_ptr<HttpNetworkTransaction> trans1(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
     scoped_ptr<HttpNetworkTransaction> trans2(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
     scoped_ptr<HttpNetworkTransaction> trans3(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
     TestCompletionCallback callback1;
     TestCompletionCallback callback2;
@@ -1108,7 +1108,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGetsWithMaxConcurrent) {
 
     const HttpResponseInfo* response1 = trans1->GetResponseInfo();
     ASSERT_TRUE(response1 != NULL);
-    EXPECT_TRUE(response1->headers != NULL);
+    EXPECT_TRUE(response1->headers.get() != NULL);
     EXPECT_TRUE(response1->was_fetched_via_spdy);
     out.status_line = response1->headers->GetStatusLine();
     out.response_info = *response1;
@@ -1213,13 +1213,13 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, FourGetsWithMaxConcurrentPriority) {
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans4(
-      new HttpNetworkTransaction(HIGHEST, helper.session()));
+      new HttpNetworkTransaction(HIGHEST, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -1252,7 +1252,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, FourGetsWithMaxConcurrentPriority) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -1346,11 +1346,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGetsWithMaxConcurrentDelete) {
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -1378,7 +1378,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGetsWithMaxConcurrentDelete) {
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -1477,10 +1477,10 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGetsWithMaxConcurrentSocketClose) {
   // there needs to be three sets of SSL connection data.
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, helper.session());
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session());
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, helper.session().get());
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session().get());
   HttpNetworkTransaction* trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -1507,7 +1507,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ThreeGetsWithMaxConcurrentSocketClose) {
 
   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -2074,7 +2074,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ResponseWithTwoSynReplies) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   std::string response_data;
   rv = ReadTransaction(trans, &response_data);
@@ -2290,7 +2290,8 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, StartTransactionOnReadCallback) {
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   rv = trans->Read(
-      buf, kSize,
+      buf.get(),
+      kSize,
       base::Bind(&SpdyNetworkTransactionSpdy2Test::StartTransactionCallback,
                  helper.session()));
   // This forces an err_IO_pending, which sets the callback.
@@ -2337,7 +2338,8 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, DeleteSessionOnReadCallback) {
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   rv = trans->Read(
-      buf, kSize,
+      buf.get(),
+      kSize,
       base::Bind(&SpdyNetworkTransactionSpdy2Test::DeleteSessionCallback,
                  base::Unretained(&helper)));
   ASSERT_EQ(ERR_IO_PENDING, rv);
@@ -2750,11 +2752,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushSingleDataFrame) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -2799,11 +2801,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushBeforeSynReply) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -2847,11 +2849,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushSingleDataFrame2) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -2911,7 +2913,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushServerAborted) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -2969,11 +2971,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushDuplicate) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3028,11 +3030,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushMultipleDataFrame) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3089,11 +3091,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3153,7 +3155,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushInvalidAssociatedStreamID0) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -3213,7 +3215,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushInvalidAssociatedStreamID9) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -3268,7 +3270,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushNoURL) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -3849,7 +3851,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferFull) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -3862,7 +3864,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferFull) {
     // Read small chunks at a time.
     const int kSmallReadSize = 3;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
@@ -3941,7 +3943,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, Buffering) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -3955,7 +3957,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, Buffering) {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
@@ -4038,7 +4040,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferedAll) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4052,7 +4054,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferedAll) {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
@@ -4128,7 +4130,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferedClosed) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4142,7 +4144,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferedClosed) {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
@@ -4208,7 +4210,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferedCancelled) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4219,7 +4221,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, BufferedCancelled) {
   do {
     const int kReadSize = 256;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kReadSize));
-    rv = trans->Read(buf, kReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       // Complete the read now, which causes buffering to start.
       data.CompleteRead();
@@ -4516,7 +4518,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, CloseWithActiveStream) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
@@ -4616,7 +4618,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ProxyConnect) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   std::string response_data;
@@ -4674,7 +4676,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, DirectConnectProxyReconnect) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(OK, out.rv);
@@ -4791,7 +4793,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, DirectConnectProxyReconnect) {
   EXPECT_EQ(0, rv);
 
   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
-  EXPECT_TRUE(response_proxy.headers != NULL);
+  EXPECT_TRUE(response_proxy.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine());
 
   std::string response_data;
@@ -4846,7 +4848,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, VerifyRetryOnConnectionReset) {
 
     for (int i = 0; i < 2; ++i) {
       scoped_ptr<HttpNetworkTransaction> trans(
-          new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+          new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
       TestCompletionCallback callback;
       int rv = trans->Start(
@@ -4870,7 +4872,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, VerifyRetryOnConnectionReset) {
 
       const HttpResponseInfo* response = trans->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
-      EXPECT_TRUE(response->headers != NULL);
+      EXPECT_TRUE(response->headers.get() != NULL);
       EXPECT_TRUE(response->was_fetched_via_spdy);
       std::string response_data;
       rv = ReadTransaction(trans.get(), &response_data);
@@ -4991,7 +4993,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, SpdyBasicAuth) {
   // Make sure the response has an auth challenge.
   const HttpResponseInfo* const response_start = trans->GetResponseInfo();
   ASSERT_TRUE(response_start != NULL);
-  ASSERT_TRUE(response_start->headers != NULL);
+  ASSERT_TRUE(response_start->headers.get() != NULL);
   EXPECT_EQ(401, response_start->headers->response_code());
   EXPECT_TRUE(response_start->was_fetched_via_spdy);
   AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get();
@@ -5012,7 +5014,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, SpdyBasicAuth) {
   // data has changed.
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
   ASSERT_TRUE(response_restart != NULL);
-  ASSERT_TRUE(response_restart->headers != NULL);
+  ASSERT_TRUE(response_restart->headers.get() != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
@@ -5088,11 +5090,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushWithHeaders) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -5188,7 +5190,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushClaimBeforeHeaders) {
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5217,11 +5219,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushClaimBeforeHeaders) {
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 
   // Read the final EOF (which will close the session)
@@ -5338,7 +5340,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushWithTwoHeaderFrames) {
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5367,11 +5369,11 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushWithTwoHeaderFrames) {
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 
   // Verify we got all the headers
@@ -5475,7 +5477,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushWithNoStatusHeaderFrames) {
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5501,7 +5503,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushWithNoStatusHeaderFrames) {
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Read the final EOF (which will close the session).
@@ -5792,7 +5794,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, ServerPushCrossOriginCorrectness) {
     VerifyStreamsClosed(helper);
 
     // Verify the SYN_REPLY.
-    EXPECT_TRUE(response.headers != NULL);
+    EXPECT_TRUE(response.headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
   }
 }
@@ -5849,7 +5851,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, RetryAfterRefused) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -5910,8 +5912,8 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, OutOfOrderSynStream) {
   // Now, start both new transactions
   HttpRequestInfo info2 = CreateGetRequest();
   TestCompletionCallback callback2;
-    scoped_ptr<HttpNetworkTransaction> trans2(
-        new HttpNetworkTransaction(MEDIUM, helper.session()));
+  scoped_ptr<HttpNetworkTransaction> trans2(
+      new HttpNetworkTransaction(MEDIUM, helper.session().get()));
   rv = trans2->Start(&info2, callback2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   base::MessageLoop::current()->RunUntilIdle();
@@ -5919,7 +5921,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, OutOfOrderSynStream) {
   HttpRequestInfo info3 = CreateGetRequest();
   TestCompletionCallback callback3;
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(HIGHEST, helper.session()));
+      new HttpNetworkTransaction(HIGHEST, helper.session().get()));
   rv = trans3->Start(&info3, callback3.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   base::MessageLoop::current()->RunUntilIdle();
diff --git a/net/spdy/spdy_network_transaction_spdy3_unittest.cc b/net/spdy/spdy_network_transaction_spdy3_unittest.cc
index 0b9304f..d7c1cc5 100644
--- a/net/spdy/spdy_network_transaction_spdy3_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy3_unittest.cc
@@ -175,7 +175,7 @@ class SpdyNetworkTransactionSpdy3Test
       }
 
       // We're now ready to use SSL-npn SPDY.
-      trans_.reset(new HttpNetworkTransaction(priority_, session_));
+      trans_.reset(new HttpNetworkTransaction(priority_, session_.get()));
     }
 
     // Start the transaction, read some data, finish.
@@ -203,7 +203,7 @@ class SpdyNetworkTransactionSpdy3Test
       // Verify responses.
       const HttpResponseInfo* response = trans_->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
-      ASSERT_TRUE(response->headers != NULL);
+      ASSERT_TRUE(response->headers.get() != NULL);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);
       if (HttpStreamFactory::spdy_enabled()) {
@@ -492,7 +492,7 @@ class SpdyNetworkTransactionSpdy3Test
     scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
-      int rv = trans->Read(buf, kSize, callback.callback());
+      int rv = trans->Read(buf.get(), kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
         // Multiple transactions may be in the data set.  Keep pulling off
         // reads until we complete our callback.
@@ -549,7 +549,7 @@ class SpdyNetworkTransactionSpdy3Test
 
     // Request the pushed path.
     scoped_ptr<HttpNetworkTransaction> trans2(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
     rv = trans2->Start(
         &CreateGetPushRequest(), callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -592,7 +592,7 @@ class SpdyNetworkTransactionSpdy3Test
       const scoped_refptr<HttpNetworkSession>& session,
       int result) {
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
     TestCompletionCallback callback;
     HttpRequestInfo request;
     request.method = "GET";
@@ -632,7 +632,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, Constructor) {
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
   scoped_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 }
 
 TEST_P(SpdyNetworkTransactionSpdy3Test, Get) {
@@ -778,11 +778,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGets) {
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -805,7 +805,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGets) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -865,9 +865,9 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, TwoGetsLateBinding) {
   // there needs to be two sets of SSL connection data.
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -886,7 +886,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, TwoGetsLateBinding) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -896,7 +896,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, TwoGetsLateBinding) {
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
-  EXPECT_TRUE(response2->headers != NULL);
+  EXPECT_TRUE(response2->headers.get() != NULL);
   EXPECT_TRUE(response2->was_fetched_via_spdy);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
@@ -954,9 +954,9 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, TwoGetsLateBindingFromPreconnect) {
   helper.AddData(&data_placeholder);
 
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -987,7 +987,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, TwoGetsLateBindingFromPreconnect) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -997,7 +997,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, TwoGetsLateBindingFromPreconnect) {
   EXPECT_EQ("hello!hello!", out.response_data);
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
-  EXPECT_TRUE(response2->headers != NULL);
+  EXPECT_TRUE(response2->headers.get() != NULL);
   EXPECT_TRUE(response2->was_fetched_via_spdy);
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
@@ -1078,11 +1078,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGetsWithMaxConcurrent) {
     helper.AddData(&data_placeholder);
     helper.AddData(&data_placeholder);
     scoped_ptr<HttpNetworkTransaction> trans1(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
     scoped_ptr<HttpNetworkTransaction> trans2(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
     scoped_ptr<HttpNetworkTransaction> trans3(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
     TestCompletionCallback callback1;
     TestCompletionCallback callback2;
@@ -1112,7 +1112,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGetsWithMaxConcurrent) {
 
     const HttpResponseInfo* response1 = trans1->GetResponseInfo();
     ASSERT_TRUE(response1 != NULL);
-    EXPECT_TRUE(response1->headers != NULL);
+    EXPECT_TRUE(response1->headers.get() != NULL);
     EXPECT_TRUE(response1->was_fetched_via_spdy);
     out.status_line = response1->headers->GetStatusLine();
     out.response_info = *response1;
@@ -1217,13 +1217,13 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, FourGetsWithMaxConcurrentPriority) {
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans4(
-      new HttpNetworkTransaction(HIGHEST, helper.session()));
+      new HttpNetworkTransaction(HIGHEST, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -1256,7 +1256,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, FourGetsWithMaxConcurrentPriority) {
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -1350,11 +1350,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGetsWithMaxConcurrentDelete) {
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
   scoped_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -1382,7 +1382,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGetsWithMaxConcurrentDelete) {
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -1481,10 +1481,10 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGetsWithMaxConcurrentSocketClose) {
   // there needs to be three sets of SSL connection data.
   helper.AddData(&data_placeholder);
   helper.AddData(&data_placeholder);
-  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, helper.session());
-  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session());
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, helper.session().get());
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session().get());
   HttpNetworkTransaction* trans3(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
@@ -1511,7 +1511,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ThreeGetsWithMaxConcurrentSocketClose) {
 
   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
-  EXPECT_TRUE(response1->headers != NULL);
+  EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
@@ -2080,7 +2080,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ResponseWithTwoSynReplies) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   std::string response_data;
   rv = ReadTransaction(trans, &response_data);
@@ -2253,14 +2253,14 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, WindowUpdateSent) {
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
-  ASSERT_TRUE(response->headers != NULL);
+  ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
 
   // Issue a read which will cause a WINDOW_UPDATE to be sent and window
   // size increased to default.
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(body_data.size()));
-  rv = trans->Read(buf, body_data.size(), CompletionCallback());
+  rv = trans->Read(buf.get(), body_data.size(), CompletionCallback());
   EXPECT_EQ(static_cast<int>(body_data.size()), rv);
   std::string content(buf->data(), buf->data() + body_data.size());
   EXPECT_EQ(body_data, content);
@@ -2877,7 +2877,8 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, StartTransactionOnReadCallback) {
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   rv = trans->Read(
-      buf, kSize,
+      buf.get(),
+      kSize,
       base::Bind(&SpdyNetworkTransactionSpdy3Test::StartTransactionCallback,
                  helper.session()));
   // This forces an err_IO_pending, which sets the callback.
@@ -2924,7 +2925,8 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, DeleteSessionOnReadCallback) {
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   rv = trans->Read(
-      buf, kSize,
+      buf.get(),
+      kSize,
       base::Bind(&SpdyNetworkTransactionSpdy3Test::DeleteSessionCallback,
                  base::Unretained(&helper)));
   ASSERT_EQ(ERR_IO_PENDING, rv);
@@ -3339,11 +3341,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushSingleDataFrame) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3388,11 +3390,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushBeforeSynReply) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3436,11 +3438,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushSingleDataFrame2) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3500,7 +3502,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushServerAborted) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -3558,11 +3560,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushDuplicate) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3617,11 +3619,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushMultipleDataFrame) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3678,11 +3680,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -3742,7 +3744,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushInvalidAssociatedStreamID0) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -3802,7 +3804,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushInvalidAssociatedStreamID9) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -3857,7 +3859,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushNoURL) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -4439,7 +4441,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferFull) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4452,7 +4454,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferFull) {
     // Read small chunks at a time.
     const int kSmallReadSize = 3;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
@@ -4531,7 +4533,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, Buffering) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4545,7 +4547,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, Buffering) {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
@@ -4628,7 +4630,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferedAll) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4642,7 +4644,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferedAll) {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
@@ -4718,7 +4720,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferedClosed) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4732,7 +4734,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferedClosed) {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
@@ -4798,7 +4800,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferedCancelled) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ -4809,7 +4811,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, BufferedCancelled) {
   do {
     const int kReadSize = 256;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kReadSize));
-    rv = trans->Read(buf, kReadSize, read_callback.callback());
+    rv = trans->Read(buf.get(), kReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       // Complete the read now, which causes buffering to start.
       data.CompleteRead();
@@ -5106,7 +5108,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, CloseWithActiveStream) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
@@ -5206,7 +5208,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ProxyConnect) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   std::string response_data;
@@ -5266,7 +5268,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, DirectConnectProxyReconnect) {
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(OK, out.rv);
@@ -5383,7 +5385,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, DirectConnectProxyReconnect) {
   EXPECT_EQ(0, rv);
 
   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
-  EXPECT_TRUE(response_proxy.headers != NULL);
+  EXPECT_TRUE(response_proxy.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine());
 
   std::string response_data;
@@ -5438,7 +5440,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, VerifyRetryOnConnectionReset) {
 
     for (int i = 0; i < 2; ++i) {
       scoped_ptr<HttpNetworkTransaction> trans(
-          new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+          new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
       TestCompletionCallback callback;
       int rv = trans->Start(
@@ -5462,7 +5464,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, VerifyRetryOnConnectionReset) {
 
       const HttpResponseInfo* response = trans->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
-      EXPECT_TRUE(response->headers != NULL);
+      EXPECT_TRUE(response->headers.get() != NULL);
       EXPECT_TRUE(response->was_fetched_via_spdy);
       std::string response_data;
       rv = ReadTransaction(trans.get(), &response_data);
@@ -5583,7 +5585,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, SpdyBasicAuth) {
   // Make sure the response has an auth challenge.
   const HttpResponseInfo* const response_start = trans->GetResponseInfo();
   ASSERT_TRUE(response_start != NULL);
-  ASSERT_TRUE(response_start->headers != NULL);
+  ASSERT_TRUE(response_start->headers.get() != NULL);
   EXPECT_EQ(401, response_start->headers->response_code());
   EXPECT_TRUE(response_start->was_fetched_via_spdy);
   AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get();
@@ -5604,7 +5606,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, SpdyBasicAuth) {
   // data has changed.
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
   ASSERT_TRUE(response_restart != NULL);
-  ASSERT_TRUE(response_restart->headers != NULL);
+  ASSERT_TRUE(response_restart->headers.get() != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
@@ -5681,11 +5683,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushWithHeaders) {
                     expected_push_result);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
@@ -5782,7 +5784,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushClaimBeforeHeaders) {
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5811,11 +5813,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushClaimBeforeHeaders) {
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 
   // Read the final EOF (which will close the session)
@@ -5933,7 +5935,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushWithTwoHeaderFrames) {
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -5962,11 +5964,11 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushWithTwoHeaderFrames) {
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
-  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 
   // Verify we got all the headers
@@ -6074,7 +6076,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushWithNoStatusHeaderFrames) {
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session()));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -6100,7 +6102,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushWithNoStatusHeaderFrames) {
   VerifyStreamsClosed(helper);
 
   // Verify the SYN_REPLY.
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Read the final EOF (which will close the session).
@@ -6391,7 +6393,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, ServerPushCrossOriginCorrectness) {
     VerifyStreamsClosed(helper);
 
     // Verify the SYN_REPLY.
-    EXPECT_TRUE(response.headers != NULL);
+    EXPECT_TRUE(response.headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
   }
 }
@@ -6448,7 +6450,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, RetryAfterRefused) {
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
-  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
@@ -6509,8 +6511,8 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, OutOfOrderSynStream) {
   // Now, start both new transactions
   HttpRequestInfo info2 = CreateGetRequest();
   TestCompletionCallback callback2;
-    scoped_ptr<HttpNetworkTransaction> trans2(
-        new HttpNetworkTransaction(MEDIUM, helper.session()));
+  scoped_ptr<HttpNetworkTransaction> trans2(
+      new HttpNetworkTransaction(MEDIUM, helper.session().get()));
   rv = trans2->Start(&info2, callback2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   base::MessageLoop::current()->RunUntilIdle();
@@ -6518,7 +6520,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, OutOfOrderSynStream) {
   HttpRequestInfo info3 = CreateGetRequest();
   TestCompletionCallback callback3;
   scoped_ptr<HttpNetworkTransaction> trans3(
-      new HttpNetworkTransaction(HIGHEST, helper.session()));
+      new HttpNetworkTransaction(HIGHEST, helper.session().get()));
   rv = trans3->Start(&info3, callback3.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   base::MessageLoop::current()->RunUntilIdle();
diff --git a/net/spdy/spdy_proxy_client_socket.cc b/net/spdy/spdy_proxy_client_socket.cc
index 096599c..bfbc722 100644
--- a/net/spdy/spdy_proxy_client_socket.cc
+++ b/net/spdy/spdy_proxy_client_socket.cc
@@ -67,7 +67,7 @@ SpdyProxyClientSocket::~SpdyProxyClientSocket() {
 }
 
 const HttpResponseInfo* SpdyProxyClientSocket::GetConnectResponseInfo() const {
-  return response_.headers ? &response_ : NULL;
+  return response_.headers.get() ? &response_ : NULL;
 }
 
 const scoped_refptr<HttpAuthController>&
@@ -192,7 +192,7 @@ bool SpdyProxyClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
 int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 const CompletionCallback& callback) {
   DCHECK(read_callback_.is_null());
-  DCHECK(!user_buffer_);
+  DCHECK(!user_buffer_.get());
 
   if (next_state_ == STATE_DISCONNECTED)
     return ERR_SOCKET_NOT_CONNECTED;
@@ -422,7 +422,7 @@ int SpdyProxyClientSocket::DoReadReplyComplete(int result) {
 
     case 407:  // Proxy Authentication Required
       next_state_ = STATE_OPEN;
-      return HandleProxyAuthChallenge(auth_, &response_, net_log_);
+      return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_);
 
     default:
       // Ignore response to avoid letting the proxy impersonate the target
diff --git a/net/spdy/spdy_proxy_client_socket_unittest.cc b/net/spdy/spdy_proxy_client_socket_unittest.cc
index 252c8f5..9c06f9c 100644
--- a/net/spdy/spdy_proxy_client_socket_unittest.cc
+++ b/net/spdy/spdy_proxy_client_socket_unittest.cc
@@ -165,7 +165,7 @@ SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
 
 void SpdyProxyClientSocketTest::TearDown() {
   sock_.reset(NULL);
-  if (session_ != NULL)
+  if (session_.get() != NULL)
     session_->spdy_session_pool()->CloseAllSessions();
 
   // Empty the current queue.
@@ -249,7 +249,7 @@ void SpdyProxyClientSocketTest::AssertConnectionEstablished() {
 void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data,
                                                      int len) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
-  ASSERT_EQ(len, sock_->Read(buf, len, CompletionCallback()));
+  ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionCallback()));
   ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
   ASSERT_TRUE(sock_->IsConnected());
 }
@@ -259,7 +259,8 @@ void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, len, read_callback_.callback()));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(buf.get(), len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
   data_->Run();
 
@@ -276,7 +277,7 @@ void SpdyProxyClientSocketTest::AssertReadStarts(const char* data,
   // Issue the read, which will be completed asynchronously
   read_buf_ = new IOBuffer(len);
   ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(read_buf_, len, read_callback_.callback()));
+            sock_->Read(read_buf_.get(), len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
 }
 
@@ -300,7 +301,8 @@ void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data,
                                                         int len,
                                                         int rv) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
-  EXPECT_EQ(rv, sock_->Write(buf, buf->size(), write_callback_.callback()));
+  EXPECT_EQ(rv,
+            sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
 }
 
 void SpdyProxyClientSocketTest::AssertWriteLength(int len) {
@@ -311,8 +313,8 @@ void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds(
     const char* data, int len, int num_reads) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
 
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(),
-                                         write_callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
 
   for (int i = 0; i < num_reads; i++) {
     Run(1);
@@ -561,7 +563,7 @@ TEST_P(SpdyProxyClientSocketTest, ConnectRedirects) {
   const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
   ASSERT_TRUE(response != NULL);
 
-  const HttpResponseHeaders* headers = response->headers;
+  const HttpResponseHeaders* headers = response->headers.get();
   ASSERT_EQ(302, headers->response_code());
   ASSERT_FALSE(headers->HasHeader("set-cookie"));
   ASSERT_TRUE(headers->HasHeaderValue("content-length", "0"));
@@ -699,8 +701,8 @@ TEST_P(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(),
                                                    big_data.length()));
 
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(),
-                                         write_callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
   data_->RunFor(3);
 
   EXPECT_EQ(buf->size(), write_callback_.WaitForResult());
@@ -901,7 +903,7 @@ TEST_P(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
 
   // Now attempt to do a read of more data than remains buffered
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33));
-  ASSERT_EQ(kLen3, sock_->Read(buf, kLen33, read_callback_.callback()));
+  ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, read_callback_.callback()));
   ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
   ASSERT_TRUE(sock_->IsConnected());
 }
@@ -1127,7 +1129,7 @@ TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
 
   ASSERT_FALSE(sock_->IsConnected());
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
-  ASSERT_EQ(kLen1, sock_->Read(buf, kLen1, CompletionCallback()));
+  ASSERT_EQ(kLen1, sock_->Read(buf.get(), kLen1, CompletionCallback()));
   ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1));
 
   ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
@@ -1158,7 +1160,7 @@ TEST_P(SpdyProxyClientSocketTest, WriteOnClosedStream) {
   Run(1);  // Read EOF which will close the stream
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
-            sock_->Write(buf, buf->size(), CompletionCallback()));
+            sock_->Write(buf.get(), buf->size(), CompletionCallback()));
 }
 
 // Calling Write() on a disconnected socket is an error
@@ -1183,7 +1185,7 @@ TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
-            sock_->Write(buf, buf->size(), CompletionCallback()));
+            sock_->Write(buf.get(), buf->size(), CompletionCallback()));
 }
 
 // If the socket is closed with a pending Write(), the callback
@@ -1209,7 +1211,7 @@ TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) {
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING,
-            sock_->Write(buf, buf->size(), write_callback_.callback()));
+            sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
 
   Run(1);
 
@@ -1239,7 +1241,7 @@ TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING,
-            sock_->Write(buf, buf->size(), write_callback_.callback()));
+            sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
 
   sock_->Disconnect();
 
@@ -1269,7 +1271,7 @@ TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(buf, kLen1, read_callback_.callback()));
+            sock_->Read(buf.get(), kLen1, read_callback_.callback()));
 
   sock_->Disconnect();
 
@@ -1302,12 +1304,13 @@ TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(read_buf, kLen1, read_callback_.callback()));
+            sock_->Read(read_buf.get(), kLen1, read_callback_.callback()));
 
   scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING,
-            sock_->Write(write_buf, write_buf->size(),
-                         write_callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      sock_->Write(
+          write_buf.get(), write_buf->size(), write_callback_.callback()));
 
   Run(2);
 
@@ -1426,11 +1429,13 @@ TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(read_buf, kLen1, read_callback.callback()));
+            sock_->Read(read_buf.get(), kLen1, read_callback.callback()));
 
   scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, write_buf->size(),
-                                         write_callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      sock_->Write(
+          write_buf.get(), write_buf->size(), write_callback_.callback()));
 
   Run(2);
 
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index 5525159..170dc82 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -244,8 +244,8 @@ int SpdyStreamRequest::StartRequest(
     RequestPriority priority,
     const BoundNetLog& net_log,
     const CompletionCallback& callback) {
-  DCHECK(session);
-  DCHECK(!session_);
+  DCHECK(session.get());
+  DCHECK(!session_.get());
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
 
@@ -266,7 +266,7 @@ int SpdyStreamRequest::StartRequest(
 }
 
 void SpdyStreamRequest::CancelRequest() {
-  if (session_)
+  if (session_.get())
     session_->CancelStreamRequest(this);
   Reset();
 }
@@ -281,7 +281,7 @@ base::WeakPtr<SpdyStream> SpdyStreamRequest::ReleaseStream() {
 
 void SpdyStreamRequest::OnRequestCompleteSuccess(
     base::WeakPtr<SpdyStream>* stream) {
-  DCHECK(session_);
+  DCHECK(session_.get());
   DCHECK(!stream_);
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
@@ -292,7 +292,7 @@ void SpdyStreamRequest::OnRequestCompleteSuccess(
 }
 
 void SpdyStreamRequest::OnRequestCompleteFailure(int rv) {
-  DCHECK(session_);
+  DCHECK(session_.get());
   DCHECK(!stream_);
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
@@ -1200,7 +1200,7 @@ void SpdySession::WriteSocket() {
     // it's okay to use GetIOBufferForRemainingData() since the socket
     // doesn't use the IOBuffer past OnWriteComplete().
     int rv = connection_->socket()->Write(
-        write_io_buffer,
+        write_io_buffer.get(),
         in_flight_write_->GetRemainingSize(),
         base::Bind(&SpdySession::OnWriteComplete, weak_factory_.GetWeakPtr()));
     // Avoid persisting |write_io_buffer| past |in_flight_write_|'s
diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc
index 64c905f..cda0102 100644
--- a/net/spdy/spdy_session_pool.cc
+++ b/net/spdy/spdy_session_pool.cc
@@ -69,7 +69,7 @@ SpdySessionPool::SpdySessionPool(
       trusted_spdy_proxy_(
           HostPortPair::FromString(trusted_spdy_proxy)) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->AddObserver(this);
   CertDatabase::GetInstance()->AddObserver(this);
 }
@@ -77,7 +77,7 @@ SpdySessionPool::SpdySessionPool(
 SpdySessionPool::~SpdySessionPool() {
   CloseAllSessions();
 
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->RemoveObserver(this);
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
   CertDatabase::GetInstance()->RemoveObserver(this);
@@ -104,7 +104,7 @@ scoped_refptr<SpdySession> SpdySessionPool::GetInternal(
   if (!list) {
     // Check if we have a Session through a domain alias.
     spdy_session = GetFromAlias(spdy_session_key, net_log, true);
-    if (spdy_session) {
+    if (spdy_session.get()) {
       UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
                                 FOUND_EXISTING_FROM_IP_POOL,
                                 SPDY_SESSION_GET_MAX);
@@ -439,7 +439,7 @@ void SpdySessionPool::CloseAllSessions() {
     SpdySessionList* list = sessions_.begin()->second;
     CHECK(list);
     const scoped_refptr<SpdySession>& session = list->front();
-    CHECK(session);
+    CHECK(session.get());
     // This call takes care of removing the session from the pool, as well as
     // removing the session list if the list is empty.
     session->CloseSessionOnError(
@@ -455,7 +455,7 @@ void SpdySessionPool::CloseCurrentSessions(net::Error error) {
     SpdySessionList* list = it->second;
     CHECK(list);
     const scoped_refptr<SpdySession>& session = list->front();
-    CHECK(session);
+    CHECK(session.get());
     session->set_spdy_session_pool(NULL);
   }
 
@@ -463,7 +463,7 @@ void SpdySessionPool::CloseCurrentSessions(net::Error error) {
     SpdySessionList* list = old_map.begin()->second;
     CHECK(list);
     const scoped_refptr<SpdySession>& session = list->front();
-    CHECK(session);
+    CHECK(session.get());
     session->CloseSessionOnError(error, false, "Closing current sessions.");
     list->pop_front();
     if (list->empty()) {
@@ -485,7 +485,7 @@ void SpdySessionPool::CloseIdleSessions() {
     // Assumes there is only 1 element in the list.
     SpdySessionList::iterator session_it = list->begin();
     const scoped_refptr<SpdySession>& session = *session_it;
-    CHECK(session);
+    CHECK(session.get());
     if (session->is_active()) {
       ++map_it;
       continue;
diff --git a/net/spdy/spdy_session_spdy2_unittest.cc b/net/spdy/spdy_session_spdy2_unittest.cc
index fded521..aad6da4 100644
--- a/net/spdy/spdy_session_spdy2_unittest.cc
+++ b/net/spdy/spdy_session_spdy2_unittest.cc
@@ -336,12 +336,13 @@ TEST_F(SpdySessionSpdy2Test, DeleteExpiredPushStreams) {
   (*request_headers)["host"] = "www.google.com";
   (*request_headers)["url"] = "/";
 
-  scoped_ptr<SpdyStream> stream(
-      new SpdyStream(SPDY_REQUEST_RESPONSE_STREAM,
-                     session, std::string(), DEFAULT_PRIORITY,
-                     kSpdyStreamInitialWindowSize,
-                     kSpdyStreamInitialWindowSize,
-                     session->net_log_));
+  scoped_ptr<SpdyStream> stream(new SpdyStream(SPDY_REQUEST_RESPONSE_STREAM,
+                                               session.get(),
+                                               std::string(),
+                                               DEFAULT_PRIORITY,
+                                               kSpdyStreamInitialWindowSize,
+                                               kSpdyStreamInitialWindowSize,
+                                               session->net_log_));
   stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
   SpdyStream* stream_ptr = stream.get();
   session->InsertCreatedStream(stream.Pass());
@@ -929,7 +930,9 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) {
                                 false,
                                 OnHostResolutionCallback()));
   IPPoolingInitializedSession(test_host_port_pair.ToString(),
-                              transport_params, http_session, session);
+                              transport_params,
+                              http_session.get(),
+                              session.get());
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress return's 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
@@ -966,7 +969,9 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) {
   // Initialize session for host 2.
   session_deps.socket_factory->AddSocketDataProvider(&data);
   IPPoolingInitializedSession(test_hosts[2].key.host_port_pair().ToString(),
-                              transport_params, http_session, session2);
+                              transport_params,
+                              http_session.get(),
+                              session2.get());
 
   // Grab the session to host 1 and verify that it is the same session
   // we got with host 0, and that is a different than host 2's session.
@@ -978,7 +983,9 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) {
   // Initialize session for host 1.
   session_deps.socket_factory->AddSocketDataProvider(&data);
   IPPoolingInitializedSession(test_hosts[2].key.host_port_pair().ToString(),
-                              transport_params, http_session, session2);
+                              transport_params,
+                              http_session.get(),
+                              session2.get());
 
   // Remove the aliases and observe that we still have a session for host1.
   pool_peer.RemoveAliases(test_hosts[0].key);
diff --git a/net/spdy/spdy_session_spdy3_unittest.cc b/net/spdy/spdy_session_spdy3_unittest.cc
index 2efd46b..5ac87d6 100644
--- a/net/spdy/spdy_session_spdy3_unittest.cc
+++ b/net/spdy/spdy_session_spdy3_unittest.cc
@@ -420,13 +420,13 @@ TEST_F(SpdySessionSpdy3Test, DeleteExpiredPushStreams) {
   (*request_headers)[":host"] = "www.google.com";
   (*request_headers)[":path"] = "/";
 
-  scoped_ptr<SpdyStream> stream(
-      new SpdyStream(
-          SPDY_REQUEST_RESPONSE_STREAM,
-          session, std::string(), DEFAULT_PRIORITY,
-          kSpdyStreamInitialWindowSize,
-          kSpdyStreamInitialWindowSize,
-          session->net_log_));
+  scoped_ptr<SpdyStream> stream(new SpdyStream(SPDY_REQUEST_RESPONSE_STREAM,
+                                               session.get(),
+                                               std::string(),
+                                               DEFAULT_PRIORITY,
+                                               kSpdyStreamInitialWindowSize,
+                                               kSpdyStreamInitialWindowSize,
+                                               session->net_log_));
   stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
   SpdyStream* stream_ptr = stream.get();
   session->InsertCreatedStream(stream.Pass());
@@ -1023,7 +1023,9 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) {
                                 false,
                                 OnHostResolutionCallback()));
   IPPoolingInitializedSession(test_host_port_pair.ToString(),
-                              transport_params, http_session, session);
+                              transport_params,
+                              http_session.get(),
+                              session.get());
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress return's 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
@@ -1060,7 +1062,9 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) {
   // Initialize session for host 2.
   session_deps.socket_factory->AddSocketDataProvider(&data);
   IPPoolingInitializedSession(test_hosts[2].key.host_port_pair().ToString(),
-                              transport_params, http_session, session2);
+                              transport_params,
+                              http_session.get(),
+                              session2.get());
 
   // Grab the session to host 1 and verify that it is the same session
   // we got with host 0, and that is a different than host 2's session.
@@ -1072,7 +1076,9 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) {
   // Initialize session for host 1.
   session_deps.socket_factory->AddSocketDataProvider(&data);
   IPPoolingInitializedSession(test_hosts[2].key.host_port_pair().ToString(),
-                              transport_params, http_session, session2);
+                              transport_params,
+                              http_session.get(),
+                              session2.get());
 
   // Remove the aliases and observe that we still have a session for host1.
   pool_peer.RemoveAliases(test_hosts[0].key);
@@ -3026,13 +3032,13 @@ void SpdySessionSpdy3Test::RunResumeAfterUnstallTest31(
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  stall_fn.Run(session, stream);
+  stall_fn.Run(session.get(), stream);
 
   data.RunFor(2);
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
-  unstall_function.Run(session, stream, kBodyDataSize);
+  unstall_function.Run(session.get(), stream, kBodyDataSize);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
@@ -3179,7 +3185,7 @@ TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
@@ -3204,7 +3210,7 @@ TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
 
   // This should unstall only stream2.
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
@@ -3215,7 +3221,7 @@ TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   // This should then unstall stream1.
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
@@ -3346,7 +3352,7 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   EXPECT_FALSE(stream3->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
@@ -3395,7 +3401,7 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
 
   // Unstall stream2, which should then close stream3.
   delegate2.set_stream_to_close(stream3);
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   data.RunFor(1);
   EXPECT_EQ(NULL, stream3.get());
@@ -3493,7 +3499,7 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedSession31) {
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
@@ -3520,7 +3526,7 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedSession31) {
   EXPECT_TRUE(spdy_session_pool_->HasSession(key_));
 
   // Unstall stream1.
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   // Close the session (since we can't do it from within the delegate
   // method, since it's in the stream's loop).
diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc
index bd6760f..cc4fd2d 100644
--- a/net/spdy/spdy_stream.cc
+++ b/net/spdy/spdy_stream.cc
@@ -397,9 +397,8 @@ int SpdyStream::OnResponseHeadersReceived(const SpdyHeaderBlock& response) {
       // For a request/response stream, we're ready for the response
       // headers once we've finished sending the request headers and
       // the request body (if we have one).
-      if ((io_state_ < STATE_OPEN) ||
-          (send_status_ == MORE_DATA_TO_SEND) ||
-          pending_send_data_)
+      if ((io_state_ < STATE_OPEN) || (send_status_ == MORE_DATA_TO_SEND) ||
+          pending_send_data_.get())
         return ERR_SPDY_PROTOCOL_ERROR;
       break;
 
@@ -596,7 +595,7 @@ int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> headers,
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK(!request_);
-  CHECK(!pending_send_data_);
+  CHECK(!pending_send_data_.get());
   CHECK_EQ(io_state_, STATE_NONE);
   request_ = headers.Pass();
   send_status_ = send_status;
@@ -610,7 +609,7 @@ void SpdyStream::SendData(IOBuffer* data,
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK_GE(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
-  CHECK(!pending_send_data_);
+  CHECK(!pending_send_data_.get());
   pending_send_data_ = new DrainableIOBuffer(data, length);
   send_status_ = send_status;
   QueueNextDataFrame();
@@ -946,16 +945,17 @@ void SpdyStream::QueueNextDataFrame() {
   // that our stream_id is correct.
   DCHECK_GT(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
   CHECK_GT(stream_id_, 0u);
-  CHECK(pending_send_data_);
+  CHECK(pending_send_data_.get());
   CHECK_GT(pending_send_data_->BytesRemaining(), 0);
 
   SpdyDataFlags flags =
       (send_status_ == NO_MORE_DATA_TO_SEND) ?
       DATA_FLAG_FIN : DATA_FLAG_NONE;
-  scoped_ptr<SpdyBuffer> data_buffer(session_->CreateDataBuffer(
-      stream_id_,
-      pending_send_data_, pending_send_data_->BytesRemaining(),
-      flags));
+  scoped_ptr<SpdyBuffer> data_buffer(
+      session_->CreateDataBuffer(stream_id_,
+                                 pending_send_data_.get(),
+                                 pending_send_data_->BytesRemaining(),
+                                 flags));
   // We'll get called again by PossiblyResumeIfSendStalled().
   if (!data_buffer)
     return;
diff --git a/net/spdy/spdy_stream_spdy2_unittest.cc b/net/spdy/spdy_stream_spdy2_unittest.cc
index 7ef8244..dff8457 100644
--- a/net/spdy/spdy_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_stream_spdy2_unittest.cc
@@ -163,7 +163,7 @@ TEST_F(SpdyStreamSpdy2Test, PushedStream) {
 
   // Conjure up a stream.
   SpdyStream stream(SPDY_PUSH_STREAM,
-                    spdy_session,
+                    spdy_session.get(),
                     std::string(),
                     DEFAULT_PRIORITY,
                     kSpdyStreamInitialWindowSize,
diff --git a/net/spdy/spdy_stream_spdy3_unittest.cc b/net/spdy/spdy_stream_spdy3_unittest.cc
index 2da85ff..a63b04d 100644
--- a/net/spdy/spdy_stream_spdy3_unittest.cc
+++ b/net/spdy/spdy_stream_spdy3_unittest.cc
@@ -172,7 +172,7 @@ TEST_F(SpdyStreamSpdy3Test, PushedStream) {
 
   // Conjure up a stream.
   SpdyStream stream(SPDY_PUSH_STREAM,
-                    spdy_session,
+                    spdy_session.get(),
                     std::string(),
                     DEFAULT_PRIORITY,
                     kSpdyStreamInitialWindowSize,
diff --git a/net/spdy/spdy_stream_test_util.cc b/net/spdy/spdy_stream_test_util.cc
index e72f408..3fd48bb 100644
--- a/net/spdy/spdy_stream_test_util.cc
+++ b/net/spdy/spdy_stream_test_util.cc
@@ -129,7 +129,7 @@ int StreamDelegateSendImmediate::OnResponseHeadersReceived(
           response, response_time, status);
   if (data_.data()) {
     scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(data_.as_string()));
-    stream()->SendData(buf, buf->size(), MORE_DATA_TO_SEND);
+    stream()->SendData(buf.get(), buf->size(), MORE_DATA_TO_SEND);
   }
   return status;
 }
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index bed9389..9dacc94 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -411,7 +411,7 @@ net::HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
   params.host_resolver = session_deps->host_resolver.get();
   params.cert_verifier = session_deps->cert_verifier.get();
   params.proxy_service = session_deps->proxy_service.get();
-  params.ssl_config_service = session_deps->ssl_config_service;
+  params.ssl_config_service = session_deps->ssl_config_service.get();
   params.http_auth_handler_factory =
       session_deps->http_auth_handler_factory.get();
   params.http_server_properties = &session_deps->http_server_properties;
@@ -456,8 +456,7 @@ SpdyURLRequestContext::SpdyURLRequestContext(NextProto protocol)
   SpdySessionPoolPeer pool_peer(network_session->spdy_session_pool());
   pool_peer.EnableSendingInitialSettings(false);
   storage_.set_http_transaction_factory(new HttpCache(
-      network_session,
-      HttpCache::DefaultBackend::InMemory(0)));
+      network_session.get(), HttpCache::DefaultBackend::InMemory(0)));
 }
 
 SpdyURLRequestContext::~SpdyURLRequestContext() {
diff --git a/net/spdy/spdy_websocket_stream.cc b/net/spdy/spdy_websocket_stream.cc
index 61ee5eb..0713c9a 100644
--- a/net/spdy/spdy_websocket_stream.cc
+++ b/net/spdy/spdy_websocket_stream.cc
@@ -23,7 +23,7 @@ SpdyWebSocketStream::SpdyWebSocketStream(
       spdy_session_(spdy_session),
       pending_send_data_length_(0),
       delegate_(delegate) {
-  DCHECK(spdy_session_);
+  DCHECK(spdy_session_.get());
   DCHECK(delegate_);
 }
 
diff --git a/net/spdy/spdy_websocket_stream_spdy2_unittest.cc b/net/spdy/spdy_websocket_stream_spdy2_unittest.cc
index cfdff57..7b72321 100644
--- a/net/spdy/spdy_websocket_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_websocket_stream_spdy2_unittest.cc
@@ -348,7 +348,7 @@ TEST_F(SpdyWebSocketStreamSpdy2Test, Basic) {
       base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendClosingFrame,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
@@ -421,7 +421,7 @@ TEST_F(SpdyWebSocketStreamSpdy2Test, DestructionBeforeClose) {
       base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSync,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
@@ -484,7 +484,7 @@ TEST_F(SpdyWebSocketStreamSpdy2Test, DestructionAfterExplicitClose) {
       base::Bind(&SpdyWebSocketStreamSpdy2Test::DoClose,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
@@ -550,7 +550,7 @@ TEST_F(SpdyWebSocketStreamSpdy2Test, IOPending) {
   SpdyWebSocketStreamEventRecorder block_delegate((CompletionCallback()));
 
   scoped_ptr<SpdyWebSocketStream> block_stream(
-      new SpdyWebSocketStream(session_, &block_delegate));
+      new SpdyWebSocketStream(session_.get(), &block_delegate));
   BoundNetLog block_net_log;
   GURL block_url("ws://example.com/block");
   ASSERT_EQ(OK,
@@ -568,7 +568,7 @@ TEST_F(SpdyWebSocketStreamSpdy2Test, IOPending) {
       base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendClosingFrame,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
   ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
diff --git a/net/spdy/spdy_websocket_stream_spdy3_unittest.cc b/net/spdy/spdy_websocket_stream_spdy3_unittest.cc
index dee8cbf..6ce2901 100644
--- a/net/spdy/spdy_websocket_stream_spdy3_unittest.cc
+++ b/net/spdy/spdy_websocket_stream_spdy3_unittest.cc
@@ -349,7 +349,7 @@ TEST_F(SpdyWebSocketStreamSpdy3Test, Basic) {
       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendClosingFrame,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
@@ -422,7 +422,7 @@ TEST_F(SpdyWebSocketStreamSpdy3Test, DestructionBeforeClose) {
       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSync,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
@@ -485,7 +485,7 @@ TEST_F(SpdyWebSocketStreamSpdy3Test, DestructionAfterExplicitClose) {
       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoClose,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
@@ -551,7 +551,7 @@ TEST_F(SpdyWebSocketStreamSpdy3Test, IOPending) {
   SpdyWebSocketStreamEventRecorder block_delegate((CompletionCallback()));
 
   scoped_ptr<SpdyWebSocketStream> block_stream(
-      new SpdyWebSocketStream(session_, &block_delegate));
+      new SpdyWebSocketStream(session_.get(), &block_delegate));
   BoundNetLog block_net_log;
   GURL block_url("ws://example.com/block");
   ASSERT_EQ(OK,
@@ -569,7 +569,7 @@ TEST_F(SpdyWebSocketStreamSpdy3Test, IOPending) {
       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendClosingFrame,
                  base::Unretained(this)));
 
-  websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
+  websocket_stream_.reset(new SpdyWebSocketStream(session_.get(), &delegate));
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
   ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
diff --git a/net/ssl/client_cert_store_impl_unittest.cc b/net/ssl/client_cert_store_impl_unittest.cc
index 5e66f3d..7b05ef2 100644
--- a/net/ssl/client_cert_store_impl_unittest.cc
+++ b/net/ssl/client_cert_store_impl_unittest.cc
@@ -61,7 +61,7 @@ TEST_F(ClientCertStoreImplTest, EmptyQuery) {
   scoped_refptr<SSLCertRequestInfo> request(new SSLCertRequestInfo());
 
   std::vector<scoped_refptr<X509Certificate> > selected_certs;
-  bool rv = SelectClientCerts(certs, *request, &selected_certs);
+  bool rv = SelectClientCerts(certs, *request.get(), &selected_certs);
   EXPECT_TRUE(rv);
   EXPECT_EQ(0u, selected_certs.size());
 }
@@ -71,17 +71,17 @@ TEST_F(ClientCertStoreImplTest, EmptyQuery) {
 TEST_F(ClientCertStoreImplTest, AllIssuersAllowed) {
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), "client_1.pem"));
-  ASSERT_TRUE(cert);
+  ASSERT_TRUE(cert.get());
 
   std::vector<scoped_refptr<X509Certificate> > certs;
   certs.push_back(cert);
   scoped_refptr<SSLCertRequestInfo> request(new SSLCertRequestInfo());
 
   std::vector<scoped_refptr<X509Certificate> > selected_certs;
-  bool rv = SelectClientCerts(certs, *request, &selected_certs);
+  bool rv = SelectClientCerts(certs, *request.get(), &selected_certs);
   EXPECT_TRUE(rv);
   ASSERT_EQ(1u, selected_certs.size());
-  EXPECT_TRUE(selected_certs[0]->Equals(cert));
+  EXPECT_TRUE(selected_certs[0]->Equals(cert.get()));
 }
 
 // Verify that certificates are correctly filtered against CertRequestInfo with
@@ -89,10 +89,10 @@ TEST_F(ClientCertStoreImplTest, AllIssuersAllowed) {
 TEST_F(ClientCertStoreImplTest, CertAuthorityFiltering) {
   scoped_refptr<X509Certificate> cert_1(
       ImportCertFromFile(GetTestCertsDirectory(), "client_1.pem"));
-  ASSERT_TRUE(cert_1);
+  ASSERT_TRUE(cert_1.get());
   scoped_refptr<X509Certificate> cert_2(
       ImportCertFromFile(GetTestCertsDirectory(), "client_2.pem"));
-  ASSERT_TRUE(cert_2);
+  ASSERT_TRUE(cert_2.get());
 
   std::vector<std::string> authority_1(
       1, std::string(reinterpret_cast<const char*>(kAuthority1DN),
@@ -112,10 +112,10 @@ TEST_F(ClientCertStoreImplTest, CertAuthorityFiltering) {
   request->cert_authorities = authority_1;
 
   std::vector<scoped_refptr<X509Certificate> > selected_certs;
-  bool rv = SelectClientCerts(certs, *request, &selected_certs);
+  bool rv = SelectClientCerts(certs, *request.get(), &selected_certs);
   EXPECT_TRUE(rv);
   ASSERT_EQ(1u, selected_certs.size());
-  EXPECT_TRUE(selected_certs[0]->Equals(cert_1));
+  EXPECT_TRUE(selected_certs[0]->Equals(cert_1.get()));
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
diff --git a/net/ssl/default_server_bound_cert_store.cc b/net/ssl/default_server_bound_cert_store.cc
index 371a165..2d38aba 100644
--- a/net/ssl/default_server_bound_cert_store.cc
+++ b/net/ssl/default_server_bound_cert_store.cc
@@ -315,7 +315,7 @@ void DefaultServerBoundCertStore::SetForceKeepSessionState() {
   DCHECK(CalledOnValidThread());
   InitIfNecessary();
 
-  if (store_)
+  if (store_.get())
     store_->SetForceKeepSessionState();
 }
 
@@ -335,7 +335,7 @@ void DefaultServerBoundCertStore::DeleteAllInMemory() {
 
 void DefaultServerBoundCertStore::InitStore() {
   DCHECK(CalledOnValidThread());
-  DCHECK(store_) << "Store must exist to initialize";
+  DCHECK(store_.get()) << "Store must exist to initialize";
   DCHECK(!loaded_);
 
   store_->Load(base::Bind(&DefaultServerBoundCertStore::OnLoaded,
@@ -412,7 +412,7 @@ void DefaultServerBoundCertStore::SyncDeleteAllCreatedBetween(
     ServerBoundCert* cert = cur->second;
     if ((delete_begin.is_null() || cert->creation_time() >= delete_begin) &&
         (delete_end.is_null() || cert->creation_time() < delete_end)) {
-      if (store_)
+      if (store_.get())
         store_->DeleteServerBoundCert(*cert);
       delete cert;
       server_bound_certs_.erase(cur);
@@ -459,7 +459,7 @@ void DefaultServerBoundCertStore::InternalDeleteServerBoundCert(
     return;  // There is nothing to delete.
 
   ServerBoundCert* cert = it->second;
-  if (store_)
+  if (store_.get())
     store_->DeleteServerBoundCert(*cert);
   server_bound_certs_.erase(it);
   delete cert;
@@ -471,7 +471,7 @@ void DefaultServerBoundCertStore::InternalInsertServerBoundCert(
   DCHECK(CalledOnValidThread());
   DCHECK(loaded_);
 
-  if (store_)
+  if (store_.get())
     store_->AddServerBoundCert(*cert);
   server_bound_certs_[server_identifier] = cert;
 }
diff --git a/net/ssl/default_server_bound_cert_store.h b/net/ssl/default_server_bound_cert_store.h
index a932959..8ec6805 100644
--- a/net/ssl/default_server_bound_cert_store.h
+++ b/net/ssl/default_server_bound_cert_store.h
@@ -90,7 +90,7 @@ class NET_EXPORT DefaultServerBoundCertStore : public ServerBoundCertStore {
   // loading?
   void InitIfNecessary() {
     if (!initialized_) {
-      if (store_) {
+      if (store_.get()) {
         InitStore();
       } else {
         loaded_ = true;
diff --git a/net/ssl/server_bound_cert_service_unittest.cc b/net/ssl/server_bound_cert_service_unittest.cc
index 51c74bf..0c5105e 100644
--- a/net/ssl/server_bound_cert_service_unittest.cc
+++ b/net/ssl/server_bound_cert_service_unittest.cc
@@ -38,7 +38,7 @@ class ServerBoundCertServiceTest : public testing::Test {
   }
 
   virtual ~ServerBoundCertServiceTest() {
-    if (sequenced_worker_pool_)
+    if (sequenced_worker_pool_.get())
       sequenced_worker_pool_->Shutdown();
   }
 
@@ -323,7 +323,7 @@ TEST_F(ServerBoundCertServiceTest, ExtractValuesFromBytesEC) {
   // Check that we can retrieve the cert from the bytes.
   scoped_refptr<X509Certificate> x509cert(
       X509Certificate::CreateFromBytes(der_cert.data(), der_cert.size()));
-  EXPECT_TRUE(x509cert != NULL);
+  EXPECT_TRUE(x509cert.get() != NULL);
 }
 
 // Tests that the callback of a canceled request is never made.
diff --git a/net/ssl/ssl_client_auth_cache_unittest.cc b/net/ssl/ssl_client_auth_cache_unittest.cc
index ef507e4..7a1be3b 100644
--- a/net/ssl/ssl_client_auth_cache_unittest.cc
+++ b/net/ssl/ssl_client_auth_cache_unittest.cc
@@ -34,13 +34,13 @@ TEST(SSLClientAuthCacheTest, LookupAddRemove) {
   EXPECT_FALSE(cache.Lookup(server1, &cached_cert));
 
   // Add client certificate for server1.
-  cache.Add(server1, cert1);
+  cache.Add(server1, cert1.get());
   cached_cert = NULL;
   EXPECT_TRUE(cache.Lookup(server1, &cached_cert));
   EXPECT_EQ(cert1, cached_cert);
 
   // Add client certificate for server2.
-  cache.Add(server2, cert2);
+  cache.Add(server2, cert2.get());
   cached_cert = NULL;
   EXPECT_TRUE(cache.Lookup(server1, &cached_cert));
   EXPECT_EQ(cert1, cached_cert.get());
@@ -49,7 +49,7 @@ TEST(SSLClientAuthCacheTest, LookupAddRemove) {
   EXPECT_EQ(cert2, cached_cert);
 
   // Overwrite the client certificate for server1.
-  cache.Add(server1, cert3);
+  cache.Add(server1, cert3.get());
   cached_cert = NULL;
   EXPECT_TRUE(cache.Lookup(server1, &cached_cert));
   EXPECT_EQ(cert3, cached_cert);
@@ -125,7 +125,7 @@ TEST(SSLClientAuthCacheTest, LookupNullPreference) {
   EXPECT_FALSE(cache.Lookup(server1, &cached_cert));
 
   // Add a new preference for a specific certificate.
-  cache.Add(server1, cert1);
+  cache.Add(server1, cert1.get());
   cached_cert = NULL;
   EXPECT_TRUE(cache.Lookup(server1, &cached_cert));
   EXPECT_EQ(cert1, cached_cert);
@@ -147,7 +147,7 @@ TEST(SSLClientAuthCacheTest, OnCertAdded) {
   scoped_refptr<X509Certificate> cert1(
       new X509Certificate("foo", "CA", start_date, expiration_date));
 
-  cache.Add(server1, cert1);
+  cache.Add(server1, cert1.get());
 
   std::string server2("foo2:443");
   cache.Add(server2, NULL);
diff --git a/net/ssl/ssl_info.h b/net/ssl/ssl_info.h
index d8333a3..3f1dd2d 100644
--- a/net/ssl/ssl_info.h
+++ b/net/ssl/ssl_info.h
@@ -35,7 +35,7 @@ class NET_EXPORT SSLInfo {
 
   void Reset();
 
-  bool is_valid() const { return cert != NULL; }
+  bool is_valid() const { return cert.get() != NULL; }
 
   // Adds the specified |error| to the cert status.
   void SetCertError(int error);
diff --git a/net/test/embedded_test_server/embedded_test_server.cc b/net/test/embedded_test_server/embedded_test_server.cc
index 95ccbcb..3d71282 100644
--- a/net/test/embedded_test_server/embedded_test_server.cc
+++ b/net/test/embedded_test_server/embedded_test_server.cc
@@ -74,7 +74,7 @@ EmbeddedTestServer::EmbeddedTestServer(
     : io_thread_(io_thread),
       port_(-1),
       weak_factory_(this) {
-  DCHECK(io_thread_);
+  DCHECK(io_thread_.get());
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
diff --git a/net/tools/dump_cache/simple_cache_dumper.cc b/net/tools/dump_cache/simple_cache_dumper.cc
index e5240b1..65cb6f5 100644
--- a/net/tools/dump_cache/simple_cache_dumper.cc
+++ b/net/tools/dump_cache/simple_cache_dumper.cc
@@ -183,7 +183,7 @@ int SimpleCacheDumper::DoReadHeaders() {
   state_ = STATE_READ_HEADERS_COMPLETE;
   int32 size = src_entry_->GetDataSize(0);
   buf_ = new IOBufferWithSize(size);
-  return src_entry_->ReadData(0, 0, buf_, size, io_callback_);
+  return src_entry_->ReadData(0, 0, buf_.get(), size, io_callback_);
 }
 
 int SimpleCacheDumper::DoReadHeadersComplete(int rv) {
@@ -195,8 +195,8 @@ int SimpleCacheDumper::DoReadHeadersComplete(int rv) {
 }
 
 int SimpleCacheDumper::DoWriteHeaders() {
-  int rv = writer_->WriteEntry(dst_entry_, 0, 0, buf_, buf_->size(),
-                               io_callback_);
+  int rv = writer_->WriteEntry(
+      dst_entry_, 0, 0, buf_.get(), buf_->size(), io_callback_);
   if (rv == 0)
     return ERR_FAILED;
 
@@ -222,7 +222,7 @@ int SimpleCacheDumper::DoReadBody() {
     return OK;
   }
   buf_ = new IOBufferWithSize(size);
-  return src_entry_->ReadData(1, 0, buf_, size, io_callback_);
+  return src_entry_->ReadData(1, 0, buf_.get(), size, io_callback_);
 }
 
 int SimpleCacheDumper::DoReadBodyComplete(int rv) {
@@ -234,8 +234,8 @@ int SimpleCacheDumper::DoReadBodyComplete(int rv) {
 }
 
 int SimpleCacheDumper::DoWriteBody() {
-  int rv = writer_->WriteEntry(dst_entry_, 1, 0, buf_, buf_->size(),
-                               io_callback_);
+  int rv = writer_->WriteEntry(
+      dst_entry_, 1, 0, buf_.get(), buf_->size(), io_callback_);
   if (rv == 0)
     return ERR_FAILED;
 
diff --git a/net/tools/fetch/fetch_client.cc b/net/tools/fetch/fetch_client.cc
index db7941c..c65c502 100644
--- a/net/tools/fetch/fetch_client.cc
+++ b/net/tools/fetch/fetch_client.cc
@@ -161,15 +161,15 @@ int main(int argc, char** argv) {
   session_params.proxy_service = proxy_service.get();
   session_params.http_auth_handler_factory = http_auth_handler_factory.get();
   session_params.http_server_properties = &http_server_properties;
-  session_params.ssl_config_service = ssl_config_service;
+  session_params.ssl_config_service = ssl_config_service.get();
 
   scoped_refptr<net::HttpNetworkSession> network_session(
       new net::HttpNetworkSession(session_params));
   if (use_cache) {
-    factory = new net::HttpCache(network_session,
+    factory = new net::HttpCache(network_session.get(),
                                  net::HttpCache::DefaultBackend::InMemory(0));
   } else {
-    factory = new net::HttpNetworkLayer(network_session);
+    factory = new net::HttpNetworkLayer(network_session.get());
   }
 
   {
diff --git a/net/tools/fetch/http_listen_socket.cc b/net/tools/fetch/http_listen_socket.cc
index 7f6544a..6c81814 100644
--- a/net/tools/fetch/http_listen_socket.cc
+++ b/net/tools/fetch/http_listen_socket.cc
@@ -31,7 +31,7 @@ void HttpListenSocket::Accept() {
     scoped_refptr<HttpListenSocket> sock(
         new HttpListenSocket(conn, delegate_));
     // It's up to the delegate to AddRef if it wants to keep it around.
-    DidAccept(this, sock);
+    DidAccept(this, sock.get());
   }
 }
 
diff --git a/net/udp/udp_socket_libevent.cc b/net/udp/udp_socket_libevent.cc
index 2e89f0f..d2446af 100644
--- a/net/udp/udp_socket_libevent.cc
+++ b/net/udp/udp_socket_libevent.cc
@@ -327,7 +327,8 @@ void UDPSocketLibevent::DoWriteCallback(int rv) {
 }
 
 void UDPSocketLibevent::DidCompleteRead() {
-  int result = InternalRecvFrom(read_buf_, read_buf_len_, recv_from_address_);
+  int result =
+      InternalRecvFrom(read_buf_.get(), read_buf_len_, recv_from_address_);
   if (result != ERR_IO_PENDING) {
     read_buf_ = NULL;
     read_buf_len_ = 0;
@@ -378,8 +379,8 @@ int UDPSocketLibevent::CreateSocket(const IPEndPoint& address) {
 }
 
 void UDPSocketLibevent::DidCompleteWrite() {
-  int result = InternalSendTo(write_buf_, write_buf_len_,
-                              send_to_address_.get());
+  int result =
+      InternalSendTo(write_buf_.get(), write_buf_len_, send_to_address_.get());
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
diff --git a/net/udp/udp_socket_unittest.cc b/net/udp/udp_socket_unittest.cc
index d488bea..ffb56d9 100644
--- a/net/udp/udp_socket_unittest.cc
+++ b/net/udp/udp_socket_unittest.cc
@@ -33,8 +33,8 @@ class UDPSocketTest : public PlatformTest {
   std::string RecvFromSocket(UDPServerSocket* socket) {
     TestCompletionCallback callback;
 
-    int rv = socket->RecvFrom(buffer_, kMaxRead, &recv_from_address_,
-                              callback.callback());
+    int rv = socket->RecvFrom(
+        buffer_.get(), kMaxRead, &recv_from_address_, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ -59,12 +59,12 @@ class UDPSocketTest : public PlatformTest {
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
-        new DrainableIOBuffer(io_buffer, length));
+        new DrainableIOBuffer(io_buffer.get(), length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
-      int rv = socket->SendTo(buffer, buffer->BytesRemaining(),
-                              address, callback.callback());
+      int rv = socket->SendTo(
+          buffer.get(), buffer->BytesRemaining(), address, callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
@@ -78,7 +78,7 @@ class UDPSocketTest : public PlatformTest {
   std::string ReadSocket(UDPClientSocket* socket) {
     TestCompletionCallback callback;
 
-    int rv = socket->Read(buffer_, kMaxRead, callback.callback());
+    int rv = socket->Read(buffer_.get(), kMaxRead, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ -94,12 +94,12 @@ class UDPSocketTest : public PlatformTest {
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
-        new DrainableIOBuffer(io_buffer, length));
+        new DrainableIOBuffer(io_buffer.get(), length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
-      int rv = socket->Write(buffer, buffer->BytesRemaining(),
-                             callback.callback());
+      int rv = socket->Write(
+          buffer.get(), buffer->BytesRemaining(), callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
@@ -518,7 +518,7 @@ TEST_F(UDPSocketTest, CloseWithPendingRead) {
 
   TestCompletionCallback callback;
   IPEndPoint from;
-  rv = server.RecvFrom(buffer_, kMaxRead, &from, callback.callback());
+  rv = server.RecvFrom(buffer_.get(), kMaxRead, &from, callback.callback());
   EXPECT_EQ(rv, ERR_IO_PENDING);
 
   server.Close();
diff --git a/net/url_request/test_url_fetcher_factory.cc b/net/url_request/test_url_fetcher_factory.cc
index 2db9fe8..13c64c3 100644
--- a/net/url_request/test_url_fetcher_factory.cc
+++ b/net/url_request/test_url_fetcher_factory.cc
@@ -148,7 +148,7 @@ void TestURLFetcher::SaveResponseToTemporaryFile(
 }
 
 HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
-  return fake_response_headers_;
+  return fake_response_headers_.get();
 }
 
 HostPortPair TestURLFetcher::GetSocketAddress() const {
diff --git a/net/url_request/url_fetcher_core.cc b/net/url_request/url_fetcher_core.cc
index d60f9b5..d2e0c5a 100644
--- a/net/url_request/url_fetcher_core.cc
+++ b/net/url_request/url_fetcher_core.cc
@@ -98,9 +98,9 @@ URLFetcherCore::URLFetcherCore(URLFetcher* fetcher,
 }
 
 void URLFetcherCore::Start() {
-  DCHECK(delegate_task_runner_);
-  DCHECK(request_context_getter_) << "We need an URLRequestContext!";
-  if (network_task_runner_) {
+  DCHECK(delegate_task_runner_.get());
+  DCHECK(request_context_getter_.get()) << "We need an URLRequestContext!";
+  if (network_task_runner_.get()) {
     DCHECK_EQ(network_task_runner_,
               request_context_getter_->GetNetworkTaskRunner());
   } else {
@@ -113,7 +113,7 @@ void URLFetcherCore::Start() {
 }
 
 void URLFetcherCore::Stop() {
-  if (delegate_task_runner_)  // May be NULL in tests.
+  if (delegate_task_runner_.get())  // May be NULL in tests.
     DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_ = NULL;
@@ -183,7 +183,7 @@ void URLFetcherCore::SetChunkedUpload(const std::string& content_type) {
 
 void URLFetcherCore::AppendChunkToUpload(const std::string& content,
                                          bool is_last_chunk) {
-  DCHECK(delegate_task_runner_);
+  DCHECK(delegate_task_runner_.get());
   DCHECK(network_task_runner_.get());
   network_task_runner_->PostTask(
       FROM_HERE,
@@ -220,7 +220,7 @@ void URLFetcherCore::GetExtraRequestHeaders(
 
 void URLFetcherCore::SetRequestContext(
     URLRequestContextGetter* request_context_getter) {
-  DCHECK(!request_context_getter_);
+  DCHECK(!request_context_getter_.get());
   DCHECK(request_context_getter);
   request_context_getter_ = request_context_getter;
 }
@@ -281,7 +281,7 @@ void URLFetcherCore::SaveResponseToTemporaryFile(
 }
 
 HttpResponseHeaders* URLFetcherCore::GetResponseHeaders() const {
-  return response_headers_;
+  return response_headers_.get();
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
@@ -431,14 +431,15 @@ void URLFetcherCore::OnReadCompleted(URLRequest* request,
     InformDelegateDownloadProgress();
     InformDelegateDownloadDataIfNecessary(bytes_read);
 
-    const int result = WriteBuffer(new DrainableIOBuffer(buffer_, bytes_read));
+    const int result =
+        WriteBuffer(new DrainableIOBuffer(buffer_.get(), bytes_read));
     if (result < 0) {
       // Write failed or waiting for write completion.
       if (result == ERR_IO_PENDING)
         waiting_on_write = true;
       break;
     }
-  } while (request_->Read(buffer_, kBufferSize, &bytes_read));
+  } while (request_->Read(buffer_.get(), kBufferSize, &bytes_read));
 
   const URLRequestStatus status = request_->status();
 
@@ -524,7 +525,7 @@ void URLFetcherCore::StartURLRequest() {
     return;
   }
 
-  DCHECK(request_context_getter_);
+  DCHECK(request_context_getter_.get());
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
@@ -572,12 +573,12 @@ void URLFetcherCore::StartURLRequest() {
         request_->set_upload(make_scoped_ptr(
             UploadDataStream::CreateWithReader(reader.Pass(), 0)));
       } else if (!upload_file_path_.empty()) {
-        scoped_ptr<UploadElementReader> reader(new UploadFileElementReader(
-            upload_file_task_runner_,
-            upload_file_path_,
-            upload_range_offset_,
-            upload_range_length_,
-            base::Time()));
+        scoped_ptr<UploadElementReader> reader(
+            new UploadFileElementReader(upload_file_task_runner_.get(),
+                                        upload_file_path_,
+                                        upload_range_offset_,
+                                        upload_range_length_,
+                                        base::Time()));
         request_->set_upload(make_scoped_ptr(
             UploadDataStream::CreateWithReader(reader.Pass(), 0)));
       }
@@ -635,10 +636,10 @@ void URLFetcherCore::StartURLRequestWhenAppropriate() {
   if (was_cancelled_)
     return;
 
-  DCHECK(request_context_getter_);
+  DCHECK(request_context_getter_.get());
 
   int64 delay = 0LL;
-  if (original_url_throttler_entry_ == NULL) {
+  if (original_url_throttler_entry_.get() == NULL) {
     URLRequestThrottlerManager* manager =
         request_context_getter_->GetURLRequestContext()->throttler_manager();
     if (manager) {
@@ -646,7 +647,7 @@ void URLFetcherCore::StartURLRequestWhenAppropriate() {
           manager->RegisterRequestUrl(original_url_);
     }
   }
-  if (original_url_throttler_entry_ != NULL) {
+  if (original_url_throttler_entry_.get() != NULL) {
     delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
         GetBackoffReleaseTime());
   }
@@ -699,7 +700,7 @@ void URLFetcherCore::InformDelegateFetchIsComplete() {
 
 void URLFetcherCore::NotifyMalformedContent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-  if (url_throttler_entry_ != NULL) {
+  if (url_throttler_entry_.get() != NULL) {
     int status_code = response_code_;
     if (status_code == URLFetcher::RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
@@ -788,12 +789,12 @@ void URLFetcherCore::ReleaseRequest() {
 base::TimeTicks URLFetcherCore::GetBackoffReleaseTime() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (original_url_throttler_entry_) {
+  if (original_url_throttler_entry_.get()) {
     base::TimeTicks original_url_backoff =
         original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
     base::TimeTicks destination_url_backoff;
-    if (url_throttler_entry_ != NULL &&
-        original_url_throttler_entry_ != url_throttler_entry_) {
+    if (url_throttler_entry_.get() != NULL &&
+        original_url_throttler_entry_.get() != url_throttler_entry_.get()) {
       destination_url_backoff =
           url_throttler_entry_->GetExponentialBackoffReleaseTime();
     }
@@ -823,7 +824,8 @@ void URLFetcherCore::CompleteAddingUploadDataChunk(
 int URLFetcherCore::WriteBuffer(scoped_refptr<DrainableIOBuffer> data) {
   while (data->BytesRemaining() > 0) {
     const int result = response_writer_->Write(
-        data, data->BytesRemaining(),
+        data.get(),
+        data->BytesRemaining(),
         base::Bind(&URLFetcherCore::DidWriteBuffer, this, data));
     if (result < 0)
       return result;
@@ -860,7 +862,7 @@ void URLFetcherCore::ReadResponse() {
   int bytes_read = 0;
   if (request_->status().is_success() &&
       (request_type_ != URLFetcher::HEAD))
-    request_->Read(buffer_, kBufferSize, &bytes_read);
+    request_->Read(buffer_.get(), kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
diff --git a/net/url_request/url_fetcher_impl_unittest.cc b/net/url_request/url_fetcher_impl_unittest.cc
index de4221f..f142f1e 100644
--- a/net/url_request/url_fetcher_impl_unittest.cc
+++ b/net/url_request/url_fetcher_impl_unittest.cc
@@ -461,7 +461,7 @@ class CancelTestURLRequestContextGetter
                                        0.0,
                                        4000));
       context_->throttler_manager()
-          ->OverrideEntryForTests(throttle_for_url_, entry);
+          ->OverrideEntryForTests(throttle_for_url_, entry.get());
 
       context_created_.Signal();
     }
@@ -1202,7 +1202,8 @@ TEST_F(URLFetcherProtectTest, Overload) {
                                    2.0,
                                    0.0,
                                    256));
-  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+  request_context()->throttler_manager()
+      ->OverrideEntryForTests(url, entry.get());
 
   CreateFetcher(url);
 
@@ -1230,7 +1231,8 @@ TEST_F(URLFetcherProtectTest, ServerUnavailable) {
                                    2.0,
                                    0.0,
                                    256));
-  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+  request_context()->throttler_manager()
+      ->OverrideEntryForTests(url, entry.get());
 
   CreateFetcher(url);
 
@@ -1260,7 +1262,8 @@ TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) {
                                    150000));
   // Total time if *not* for not doing automatic backoff would be 150s.
   // In reality it should be "as soon as server responds".
-  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+  request_context()->throttler_manager()
+      ->OverrideEntryForTests(url, entry.get());
 
   CreateFetcher(url);
 
@@ -1322,7 +1325,8 @@ TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) {
                                    2.0,
                                    0.0,
                                    4000));
-  request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
+  request_context()->throttler_manager()
+      ->OverrideEntryForTests(url, entry.get());
   // Fake that a request has just started.
   entry->ReserveSendingTimeForNextRequest(base::TimeTicks());
 
diff --git a/net/url_request/url_fetcher_response_writer.cc b/net/url_request/url_fetcher_response_writer.cc
index fcf6075..057296c 100644
--- a/net/url_request/url_fetcher_response_writer.cc
+++ b/net/url_request/url_fetcher_response_writer.cc
@@ -62,10 +62,9 @@ int URLFetcherFileWriter::Initialize(const CompletionCallback& callback) {
   if (file_path_.empty()) {
     base::FilePath* temp_file_path = new base::FilePath;
     base::PostTaskAndReplyWithResult(
-        file_task_runner_,
+        file_task_runner_.get(),
         FROM_HERE,
-        base::Bind(&file_util::CreateTemporaryFile,
-                   temp_file_path),
+        base::Bind(&file_util::CreateTemporaryFile, temp_file_path),
         base::Bind(&URLFetcherFileWriter::DidCreateTempFile,
                    weak_factory_.GetWeakPtr(),
                    callback,
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index 853f9ee..4522315 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -283,11 +283,11 @@ URLRequest::~URLRequest() {
 
   if (network_delegate_) {
     network_delegate_->NotifyURLRequestDestroyed(this);
-    if (job_)
+    if (job_.get())
       job_->NotifyURLRequestDestroyed();
   }
 
-  if (job_)
+  if (job_.get())
     OrphanJob();
 
   int deleted = context_->url_requests()->erase(this);
@@ -385,12 +385,12 @@ LoadStateWithParam URLRequest::GetLoadState() const {
     return LoadStateWithParam(LOAD_STATE_WAITING_FOR_DELEGATE,
                               load_state_param_);
   }
-  return LoadStateWithParam(job_ ? job_->GetLoadState() : LOAD_STATE_IDLE,
+  return LoadStateWithParam(job_.get() ? job_->GetLoadState() : LOAD_STATE_IDLE,
                             base::string16());
 }
 
 UploadProgress URLRequest::GetUploadProgress() const {
-  if (!job_) {
+  if (!job_.get()) {
     // We haven't started or the request was cancelled
     return UploadProgress();
   }
@@ -404,13 +404,13 @@ UploadProgress URLRequest::GetUploadProgress() const {
 }
 
 void URLRequest::GetResponseHeaderById(int id, string* value) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   NOTREACHED() << "implement me!";
 }
 
 void URLRequest::GetResponseHeaderByName(const string& name, string* value) {
   DCHECK(value);
-  if (response_info_.headers) {
+  if (response_info_.headers.get()) {
     response_info_.headers->GetNormalizedHeader(name, value);
   } else {
     value->clear();
@@ -419,7 +419,7 @@ void URLRequest::GetResponseHeaderByName(const string& name, string* value) {
 
 void URLRequest::GetAllResponseHeaders(string* headers) {
   DCHECK(headers);
-  if (response_info_.headers) {
+  if (response_info_.headers.get()) {
     response_info_.headers->GetNormalizedHeaders(headers);
   } else {
     headers->clear();
@@ -427,7 +427,7 @@ void URLRequest::GetAllResponseHeaders(string* headers) {
 }
 
 HostPortPair URLRequest::GetSocketAddress() const {
-  DCHECK(job_);
+  DCHECK(job_.get());
   return job_->GetSocketAddress();
 }
 
@@ -440,22 +440,22 @@ void URLRequest::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
 }
 
 bool URLRequest::GetResponseCookies(ResponseCookies* cookies) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   return job_->GetResponseCookies(cookies);
 }
 
 void URLRequest::GetMimeType(string* mime_type) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   job_->GetMimeType(mime_type);
 }
 
 void URLRequest::GetCharset(string* charset) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   job_->GetCharset(charset);
 }
 
 int URLRequest::GetResponseCode() {
-  DCHECK(job_);
+  DCHECK(job_.get());
   return job_->GetResponseCode();
 }
 
@@ -548,7 +548,7 @@ void URLRequest::Start() {
 ///////////////////////////////////////////////////////////////////////////////
 
 void URLRequest::BeforeRequestComplete(int error) {
-  DCHECK(!job_);
+  DCHECK(!job_.get());
   DCHECK_NE(ERR_IO_PENDING, error);
   DCHECK_EQ(network_delegate_, context_->network_delegate());
 
@@ -580,7 +580,7 @@ void URLRequest::BeforeRequestComplete(int error) {
 
 void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
-  DCHECK(!job_);
+  DCHECK(!job_.get());
 
   net_log_.BeginEvent(
       NetLog::TYPE_URL_REQUEST_START_JOB,
@@ -609,9 +609,9 @@ void URLRequest::StartJob(URLRequestJob* job) {
 
 void URLRequest::Restart() {
   // Should only be called if the original job didn't make any progress.
-  DCHECK(job_ && !job_->has_response_started());
-  RestartWithJob(URLRequestJobManager::GetInstance()->CreateJob(
-      this, network_delegate_));
+  DCHECK(job_.get() && !job_->has_response_started());
+  RestartWithJob(
+      URLRequestJobManager::GetInstance()->CreateJob(this, network_delegate_));
 }
 
 void URLRequest::RestartWithJob(URLRequestJob *job) {
@@ -630,7 +630,7 @@ void URLRequest::CancelWithError(int error) {
 
 void URLRequest::CancelWithSSLError(int error, const SSLInfo& ssl_info) {
   // This should only be called on a started request.
-  if (!is_pending_ || !job_ || job_->has_response_started()) {
+  if (!is_pending_ || !job_.get() || job_->has_response_started()) {
     NOTREACHED();
     return;
   }
@@ -655,7 +655,7 @@ void URLRequest::DoCancel(int error, const SSLInfo& ssl_info) {
     }
   }
 
-  if (is_pending_ && job_)
+  if (is_pending_ && job_.get())
     job_->Kill();
 
   // We need to notify about the end of this job here synchronously. The
@@ -669,7 +669,7 @@ void URLRequest::DoCancel(int error, const SSLInfo& ssl_info) {
 }
 
 bool URLRequest::Read(IOBuffer* dest, int dest_size, int* bytes_read) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   DCHECK(bytes_read);
   *bytes_read = 0;
 
@@ -699,7 +699,7 @@ bool URLRequest::Read(IOBuffer* dest, int dest_size, int* bytes_read) {
 }
 
 void URLRequest::StopCaching() {
-  DCHECK(job_);
+  DCHECK(job_.get());
   job_->StopCaching();
 }
 
@@ -751,40 +751,40 @@ void URLRequest::NotifyResponseStarted() {
 }
 
 void URLRequest::FollowDeferredRedirect() {
-  CHECK(job_);
+  CHECK(job_.get());
   CHECK(status_.is_success());
 
   job_->FollowDeferredRedirect();
 }
 
 void URLRequest::SetAuth(const AuthCredentials& credentials) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   DCHECK(job_->NeedsAuth());
 
   job_->SetAuth(credentials);
 }
 
 void URLRequest::CancelAuth() {
-  DCHECK(job_);
+  DCHECK(job_.get());
   DCHECK(job_->NeedsAuth());
 
   job_->CancelAuth();
 }
 
 void URLRequest::ContinueWithCertificate(X509Certificate* client_cert) {
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   job_->ContinueWithCertificate(client_cert);
 }
 
 void URLRequest::ContinueDespiteLastError() {
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   job_->ContinueDespiteLastError();
 }
 
 void URLRequest::PrepareToRestart() {
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   // Close the current URL_REQUEST_START_JOB, since we will be starting a new
   // one.
@@ -887,7 +887,7 @@ const URLRequestContext* URLRequest::context() const {
 
 int64 URLRequest::GetExpectedContentSize() const {
   int64 expected_content_size = -1;
-  if (job_)
+  if (job_.get())
     expected_content_size = job_->expected_content_size();
 
   return expected_content_size;
@@ -900,7 +900,7 @@ void URLRequest::SetPriority(RequestPriority priority) {
     return;
 
   priority_ = priority;
-  if (job_) {
+  if (job_.get()) {
     net_log_.AddEvent(NetLog::TYPE_URL_REQUEST_SET_PRIORITY,
                       NetLog::IntegerCallback("priority", priority_));
     job_->SetPriority(priority_);
@@ -1045,7 +1045,7 @@ void URLRequest::OnHeadersComplete() {
   // Cache load timing information now, as information will be lost once the
   // socket is closed and the ClientSocketHandle is Reset, which will happen
   // once the body is complete.  The start times should already be populated.
-  if (job_) {
+  if (job_.get()) {
     // Keep a copy of the two times the URLRequest sets.
     base::TimeTicks request_start = load_timing_info_.request_start;
     base::Time request_start_time = load_timing_info_.request_start_time;
@@ -1072,7 +1072,7 @@ void URLRequest::NotifyRequestCompleted() {
   is_redirecting_ = false;
   has_notified_completion_ = true;
   if (network_delegate_)
-    network_delegate_->NotifyCompleted(this, job_ != NULL);
+    network_delegate_->NotifyCompleted(this, job_.get() != NULL);
 }
 
 void URLRequest::SetBlockedOnDelegate() {
diff --git a/net/url_request/url_request_context.cc b/net/url_request/url_request_context.cc
index 318d5f9..0f238e0 100644
--- a/net/url_request/url_request_context.cc
+++ b/net/url_request/url_request_context.cc
@@ -47,10 +47,10 @@ void URLRequestContext::CopyFrom(const URLRequestContext* other) {
   set_fraudulent_certificate_reporter(other->fraudulent_certificate_reporter_);
   set_http_auth_handler_factory(other->http_auth_handler_factory_);
   set_proxy_service(other->proxy_service_);
-  set_ssl_config_service(other->ssl_config_service_);
+  set_ssl_config_service(other->ssl_config_service_.get());
   set_network_delegate(other->network_delegate_);
   set_http_server_properties(other->http_server_properties_);
-  set_cookie_store(other->cookie_store_);
+  set_cookie_store(other->cookie_store_.get());
   set_transport_security_state(other->transport_security_state_);
   set_http_transaction_factory(other->http_transaction_factory_);
   set_job_factory(other->job_factory_);
diff --git a/net/url_request/url_request_context.h b/net/url_request/url_request_context.h
index bb26897..53da67d 100644
--- a/net/url_request/url_request_context.h
+++ b/net/url_request/url_request_context.h
@@ -107,7 +107,9 @@ class NET_EXPORT URLRequestContext
   }
 
   // Get the ssl config service for this context.
-  SSLConfigService* ssl_config_service() const { return ssl_config_service_; }
+  SSLConfigService* ssl_config_service() const {
+    return ssl_config_service_.get();
+  }
   void set_ssl_config_service(SSLConfigService* service) {
     ssl_config_service_ = service;
   }
diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc
index 841d180..ac56dae 100644
--- a/net/url_request/url_request_context_builder.cc
+++ b/net/url_request/url_request_context_builder.cc
@@ -291,7 +291,7 @@ URLRequestContext* URLRequestContextBuilder::Build() {
     scoped_refptr<net::HttpNetworkSession> network_session(
         new net::HttpNetworkSession(network_session_params));
 
-    http_transaction_factory = new HttpNetworkLayer(network_session);
+    http_transaction_factory = new HttpNetworkLayer(network_session.get());
   }
   storage->set_http_transaction_factory(http_transaction_factory);
 
diff --git a/net/url_request/url_request_context_getter.cc b/net/url_request/url_request_context_getter.cc
index 44b7bf4..88a6f3d 100644
--- a/net/url_request/url_request_context_getter.cc
+++ b/net/url_request/url_request_context_getter.cc
@@ -17,8 +17,8 @@ URLRequestContextGetter::~URLRequestContextGetter() {}
 void URLRequestContextGetter::OnDestruct() const {
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner =
       GetNetworkTaskRunner();
-  DCHECK(network_task_runner);
-  if (network_task_runner) {
+  DCHECK(network_task_runner.get());
+  if (network_task_runner.get()) {
     if (network_task_runner->BelongsToCurrentThread()) {
       delete this;
     } else {
diff --git a/net/url_request/url_request_ftp_job.cc b/net/url_request/url_request_ftp_job.cc
index 4f677ef..c92ae6c 100644
--- a/net/url_request/url_request_ftp_job.cc
+++ b/net/url_request/url_request_ftp_job.cc
@@ -257,7 +257,7 @@ void URLRequestFtpJob::OnReadCompleted(int result) {
 }
 
 void URLRequestFtpJob::RestartTransactionWithAuth() {
-  DCHECK(auth_data_ && auth_data_->state == AUTH_STATE_HAVE_AUTH);
+  DCHECK(auth_data_.get() && auth_data_->state == AUTH_STATE_HAVE_AUTH);
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
@@ -292,7 +292,7 @@ LoadState URLRequestFtpJob::GetLoadState() const {
 }
 
 bool URLRequestFtpJob::NeedsAuth() {
-  return auth_data_ && auth_data_->state == AUTH_STATE_NEED_AUTH;
+  return auth_data_.get() && auth_data_->state == AUTH_STATE_NEED_AUTH;
 }
 
 void URLRequestFtpJob::GetAuthChallengeInfo(
@@ -379,7 +379,7 @@ bool URLRequestFtpJob::ReadRawData(IOBuffer* buf,
 void URLRequestFtpJob::HandleAuthNeededResponse() {
   GURL origin = request_->url().GetOrigin();
 
-  if (auth_data_) {
+  if (auth_data_.get()) {
     if (auth_data_->state == AUTH_STATE_CANCELED) {
       NotifyHeadersComplete();
       return;
diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc
index 710bd0d..d168816 100644
--- a/net/url_request/url_request_http_job.cc
+++ b/net/url_request/url_request_http_job.cc
@@ -368,7 +368,7 @@ void URLRequestHttpJob::NotifyHeadersComplete() {
   // also need this info.
   is_cached_content_ = response_info_->was_cached;
 
-  if (!is_cached_content_ && throttling_entry_) {
+  if (!is_cached_content_ && throttling_entry_.get()) {
     URLRequestThrottlerHeaderAdapter response_adapter(GetResponseHeaders());
     throttling_entry_->UpdateWithResponse(request_info_.url.host(),
                                           &response_adapter);
@@ -488,7 +488,7 @@ void URLRequestHttpJob::StartTransactionInternal() {
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         priority_, &transaction_, http_transaction_delegate_.get());
     if (rv == OK) {
-      if (!throttling_entry_ ||
+      if (!throttling_entry_.get() ||
           !throttling_entry_->ShouldRejectRequest(*request_)) {
         rv = transaction_->Start(
             &request_info_, start_callback_, request_->net_log());
@@ -859,8 +859,10 @@ void URLRequestHttpJob::OnStartCompleted(int result) {
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
       int error = network_delegate()->NotifyHeadersReceived(
-          request_, on_headers_received_callback_,
-          headers, &override_response_headers_);
+          request_,
+          on_headers_received_callback_,
+          headers.get(),
+          &override_response_headers_);
       if (error != net::OK) {
         if (error == net::ERR_IO_PENDING) {
           awaiting_callback_ = true;
@@ -892,7 +894,7 @@ void URLRequestHttpJob::OnStartCompleted(int result) {
     NotifySSLCertificateError(transaction_->GetResponseInfo()->ssl_info, fatal);
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     NotifyCertificateRequested(
-        transaction_->GetResponseInfo()->cert_request_info);
+        transaction_->GetResponseInfo()->cert_request_info.get());
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
@@ -990,7 +992,7 @@ void URLRequestHttpJob::GetResponseInfo(HttpResponseInfo* info) {
 
   if (response_info_) {
     *info = *response_info_;
-    if (override_response_headers_)
+    if (override_response_headers_.get())
       info->headers = override_response_headers_;
   }
 }
@@ -1478,8 +1480,8 @@ HttpResponseHeaders* URLRequestHttpJob::GetResponseHeaders() const {
   DCHECK(transaction_.get());
   DCHECK(transaction_->GetResponseInfo());
   return override_response_headers_.get() ?
-      override_response_headers_ :
-      transaction_->GetResponseInfo()->headers;
+             override_response_headers_.get() :
+             transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
diff --git a/net/url_request/url_request_job.cc b/net/url_request/url_request_job.cc
index 04ba8ae..8223b15 100644
--- a/net/url_request/url_request_job.cc
+++ b/net/url_request/url_request_job.cc
@@ -71,7 +71,7 @@ bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int *bytes_read) {
   DCHECK_LT(buf_size, 1000000);  // Sanity check.
   DCHECK(buf);
   DCHECK(bytes_read);
-  DCHECK(filtered_read_buffer_ == NULL);
+  DCHECK(filtered_read_buffer_.get() == NULL);
   DCHECK_EQ(0, filtered_read_buffer_len_);
 
   *bytes_read = 0;
@@ -338,8 +338,8 @@ void URLRequestJob::NotifyHeadersComplete() {
     GetAuthChallengeInfo(&auth_info);
     // Need to check for a NULL auth_info because the server may have failed
     // to send a challenge with the 401 response.
-    if (auth_info) {
-      request_->NotifyAuthRequired(auth_info);
+    if (auth_info.get()) {
+      request_->NotifyAuthRequired(auth_info.get());
       // Wait for SetAuth or CancelAuth to be called.
       return;
     }
@@ -505,10 +505,12 @@ void URLRequestJob::FilteredDataRead(int bytes_read) {
 
 bool URLRequestJob::ReadFilteredData(int* bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
-  DCHECK(filtered_read_buffer_ != NULL);  // we need to have a buffer to fill
+  DCHECK(filtered_read_buffer_.get() !=
+         NULL);                             // we need to have a buffer to fill
   DCHECK_GT(filtered_read_buffer_len_, 0);  // sanity check
   DCHECK_LT(filtered_read_buffer_len_, 1000000);  // sanity check
-  DCHECK(raw_read_buffer_ == NULL);  // there should be no raw read buffer yet
+  DCHECK(raw_read_buffer_.get() ==
+         NULL);  // there should be no raw read buffer yet
 
   bool rv = false;
   *bytes_read = 0;
@@ -664,7 +666,7 @@ bool URLRequestJob::ReadRawDataForFilter(int* bytes_read) {
 bool URLRequestJob::ReadRawDataHelper(IOBuffer* buf, int buf_size,
                                       int* bytes_read) {
   DCHECK(!request_->status().is_io_pending());
-  DCHECK(raw_read_buffer_ == NULL);
+  DCHECK(raw_read_buffer_.get() == NULL);
 
   // Keep a pointer to the read buffer, so we have access to it in the
   // OnRawReadComplete() callback in the event that the read completes
@@ -697,7 +699,7 @@ void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
 }
 
 void URLRequestJob::OnRawReadComplete(int bytes_read) {
-  DCHECK(raw_read_buffer_);
+  DCHECK(raw_read_buffer_.get());
   if (bytes_read > 0) {
     RecordBytesRead(bytes_read);
   }
diff --git a/net/url_request/url_request_test_job.cc b/net/url_request/url_request_test_job.cc
index c456ae5..592f448 100644
--- a/net/url_request/url_request_test_job.cc
+++ b/net/url_request/url_request_test_job.cc
@@ -135,7 +135,7 @@ URLRequestTestJob::~URLRequestTestJob() {
 
 bool URLRequestTestJob::GetMimeType(std::string* mime_type) const {
   DCHECK(mime_type);
-  if (!response_headers_)
+  if (!response_headers_.get())
     return false;
   return response_headers_->GetMimeType(mime_type);
 }
@@ -153,7 +153,7 @@ void URLRequestTestJob::Start() {
 }
 
 void URLRequestTestJob::StartAsync() {
-  if (!response_headers_) {
+  if (!response_headers_.get()) {
     response_headers_ = new HttpResponseHeaders(test_headers());
     if (request_->url().spec() == test_url_1().spec()) {
       response_data_ = test_data_1();
@@ -209,7 +209,7 @@ bool URLRequestTestJob::ReadRawData(IOBuffer* buf, int buf_size,
 }
 
 void URLRequestTestJob::GetResponseInfo(HttpResponseInfo* info) {
-  if (response_headers_)
+  if (response_headers_.get())
     info->headers = response_headers_;
 }
 
@@ -225,14 +225,14 @@ void URLRequestTestJob::GetLoadTimingInfo(
 }
 
 int URLRequestTestJob::GetResponseCode() const {
-  if (response_headers_)
+  if (response_headers_.get())
     return response_headers_->response_code();
   return -1;
 }
 
 bool URLRequestTestJob::IsRedirectResponse(GURL* location,
                                            int* http_status_code) {
-  if (!response_headers_)
+  if (!response_headers_.get())
     return false;
 
   std::string value;
diff --git a/net/url_request/url_request_test_util.cc b/net/url_request/url_request_test_util.cc
index 8fd603d..95964fe 100644
--- a/net/url_request/url_request_test_util.cc
+++ b/net/url_request/url_request_test_util.cc
@@ -135,14 +135,14 @@ TestURLRequest::~TestURLRequest() {
 TestURLRequestContextGetter::TestURLRequestContextGetter(
     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner)
     : network_task_runner_(network_task_runner) {
-  DCHECK(network_task_runner_);
+  DCHECK(network_task_runner_.get());
 }
 
 TestURLRequestContextGetter::TestURLRequestContextGetter(
     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
     scoped_ptr<TestURLRequestContext> context)
     : network_task_runner_(network_task_runner), context_(context.Pass()) {
-  DCHECK(network_task_runner_);
+  DCHECK(network_task_runner_.get());
 }
 
 TestURLRequestContextGetter::~TestURLRequestContextGetter() {}
@@ -234,7 +234,7 @@ void TestDelegate::OnResponseStarted(URLRequest* request) {
   } else {
     // Initiate the first read.
     int bytes_read = 0;
-    if (request->Read(buf_, kBufferSize, &bytes_read))
+    if (request->Read(buf_.get(), kBufferSize, &bytes_read))
       OnReadCompleted(request, bytes_read);
     else if (!request->status().is_io_pending())
       OnResponseCompleted(request);
@@ -262,7 +262,7 @@ void TestDelegate::OnReadCompleted(URLRequest* request, int bytes_read) {
   // If it was not end of stream, request to read more.
   if (request->status().is_success() && bytes_read > 0) {
     bytes_read = 0;
-    while (request->Read(buf_, kBufferSize, &bytes_read)) {
+    while (request->Read(buf_.get(), kBufferSize, &bytes_read)) {
       if (bytes_read > 0) {
         data_received_.append(buf_->data(), bytes_read);
         received_bytes_count_ += bytes_read;
diff --git a/net/url_request/url_request_throttler_manager.cc b/net/url_request/url_request_throttler_manager.cc
index fa04a00..56bbe89 100644
--- a/net/url_request/url_request_throttler_manager.cc
+++ b/net/url_request/url_request_throttler_manager.cc
@@ -38,7 +38,7 @@ URLRequestThrottlerManager::~URLRequestThrottlerManager() {
   // entries, detach the entries' back-pointer to the manager.
   UrlEntryMap::iterator i = url_entries_.begin();
   while (i != url_entries_.end()) {
-    if (i->second != NULL) {
+    if (i->second.get() != NULL) {
       i->second->DetachManager();
     }
     ++i;
diff --git a/net/url_request/url_request_throttler_unittest.cc b/net/url_request/url_request_throttler_unittest.cc
index ed3eb87..61d1b5f 100644
--- a/net/url_request/url_request_throttler_unittest.cc
+++ b/net/url_request/url_request_throttler_unittest.cc
@@ -506,13 +506,13 @@ TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) {
   entry->UpdateWithResponse("www.google.com", &response_adapter);
 
   // Ensure that the same entry on error always allows everything.
-  ExpectEntryAllowsAllOnErrorIfOptedOut(entry, true, request_);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(entry.get(), true, request_);
 
   // Ensure that a freshly created entry (for a different URL on an
   // already opted-out host) also gets "always allow" behavior.
   scoped_refptr<net::URLRequestThrottlerEntryInterface> other_entry =
       manager.RegisterRequestUrl(GURL("http://www.google.com/bingobob"));
-  ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry, true, request_);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry.get(), true, request_);
 
   // Fake a response with the opt-out header incorrectly specified.
   scoped_refptr<net::URLRequestThrottlerEntryInterface> no_opt_out_entry =
@@ -520,12 +520,13 @@ TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) {
   MockURLRequestThrottlerHeaderAdapter wrong_adapter(
       std::string(), "yesplease", 200);
   no_opt_out_entry->UpdateWithResponse("www.nike.com", &wrong_adapter);
-  ExpectEntryAllowsAllOnErrorIfOptedOut(no_opt_out_entry, false, request_);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(
+      no_opt_out_entry.get(), false, request_);
 
   // A localhost entry should always be opted out.
   scoped_refptr<net::URLRequestThrottlerEntryInterface> localhost_entry =
       manager.RegisterRequestUrl(GURL("http://localhost/hello"));
-  ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry, true, request_);
+  ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry.get(), true, request_);
 }
 
 TEST_F(URLRequestThrottlerManagerTest, ClearOnNetworkChange) {
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 4ad170a..4b2ef4a 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -1759,7 +1759,7 @@ TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) {
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(&req, &default_network_delegate_);
-  AddTestInterceptor()->set_main_intercept_job(job);
+  AddTestInterceptor()->set_main_intercept_job(job.get());
   EXPECT_EQ(DEFAULT_PRIORITY, job->priority());
 
   req.SetPriority(LOW);
@@ -1776,7 +1776,7 @@ TEST_F(URLRequestTest, SetJobPriority) {
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(&req, &default_network_delegate_);
-  AddTestInterceptor()->set_main_intercept_job(job);
+  AddTestInterceptor()->set_main_intercept_job(job.get());
 
   req.SetPriority(LOW);
   req.Start();
@@ -1812,7 +1812,7 @@ TEST_F(URLRequestTest, DelayedCookieCallback) {
   scoped_refptr<DelayedCookieMonster> delayed_cm =
       new DelayedCookieMonster();
   scoped_refptr<CookieStore> cookie_store = delayed_cm;
-  context.set_cookie_store(delayed_cm);
+  context.set_cookie_store(delayed_cm.get());
 
   // Set up a cookie.
   {
@@ -4575,7 +4575,7 @@ TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
       new URLRequestRedirectJob(
           &req, &default_network_delegate_, test_server_.GetURL("echo"),
           URLRequestRedirectJob::REDIRECT_302_FOUND);
-  AddTestInterceptor()->set_main_intercept_job(redirect_job);
+  AddTestInterceptor()->set_main_intercept_job(redirect_job.get());
 
   req.SetPriority(LOW);
   req.Start();
@@ -4583,7 +4583,7 @@ TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(&req, &default_network_delegate_);
-  AddTestInterceptor()->set_main_intercept_job(job);
+  AddTestInterceptor()->set_main_intercept_job(job.get());
 
   // Should trigger |job| to be started.
   base::MessageLoop::current()->Run();
@@ -5182,7 +5182,7 @@ class HTTPSOCSPTest : public HTTPSRequestTest {
     scoped_refptr<net::X509Certificate> root_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem");
     CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert);
-    test_root_.reset(new ScopedTestRoot(root_cert));
+    test_root_.reset(new ScopedTestRoot(root_cert.get()));
 
 #if defined(USE_NSS) || defined(OS_IOS)
     SetURLRequestContextForNSSHttpIO(&context_);
diff --git a/net/url_request/view_cache_helper.cc b/net/url_request/view_cache_helper.cc
index 9f7f05e..9ca2d41 100644
--- a/net/url_request/view_cache_helper.cc
+++ b/net/url_request/view_cache_helper.cc
@@ -288,7 +288,10 @@ int ViewCacheHelper::DoReadResponse() {
 
   buf_ = new IOBuffer(buf_len_);
   return entry_->ReadData(
-      0, 0, buf_, buf_len_,
+      0,
+      0,
+      buf_.get(),
+      buf_len_,
       base::Bind(&ViewCacheHelper::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
@@ -296,9 +299,9 @@ int ViewCacheHelper::DoReadResponseComplete(int result) {
   if (result && result == buf_len_) {
     HttpResponseInfo response;
     bool truncated;
-    if (HttpCache::ParseResponseInfo(buf_->data(), buf_len_, &response,
-                                          &truncated) &&
-        response.headers) {
+    if (HttpCache::ParseResponseInfo(
+            buf_->data(), buf_len_, &response, &truncated) &&
+        response.headers.get()) {
       if (truncated)
         data_->append("<pre>RESPONSE_INFO_TRUNCATED</pre>");
 
@@ -333,7 +336,10 @@ int ViewCacheHelper::DoReadData() {
 
   buf_ = new IOBuffer(buf_len_);
   return entry_->ReadData(
-      index_, 0, buf_, buf_len_,
+      index_,
+      0,
+      buf_.get(),
+      buf_len_,
       base::Bind(&ViewCacheHelper::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
diff --git a/net/url_request/view_cache_helper_unittest.cc b/net/url_request/view_cache_helper_unittest.cc
index 754ebe0..db26f70 100644
--- a/net/url_request/view_cache_helper_unittest.cc
+++ b/net/url_request/view_cache_helper_unittest.cc
@@ -49,7 +49,7 @@ void WriteHeaders(disk_cache::Entry* entry, int flags, const std::string data) {
   int len = static_cast<int>(pickle.size());
 
   net::TestCompletionCallback cb;
-  int rv = entry->WriteData(0, 0, buf, len, cb.callback(), true);
+  int rv = entry->WriteData(0, 0, buf.get(), len, cb.callback(), true);
   ASSERT_EQ(len, cb.GetResult(rv));
 }
 
@@ -62,7 +62,7 @@ void WriteData(disk_cache::Entry* entry, int index, const std::string data) {
   memcpy(buf->data(), data.data(), data.length());
 
   net::TestCompletionCallback cb;
-  int rv = entry->WriteData(index, 0, buf, len, cb.callback(), true);
+  int rv = entry->WriteData(index, 0, buf.get(), len, cb.callback(), true);
   ASSERT_EQ(len, cb.GetResult(rv));
 }
 
diff --git a/net/websockets/websocket_job.cc b/net/websockets/websocket_job.cc
index ed0b458..2884895 100644
--- a/net/websockets/websocket_job.cc
+++ b/net/websockets/websocket_job.cc
@@ -111,7 +111,7 @@ bool WebSocketJob::SendData(const char* data, int len) {
       {
         scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(len);
         memcpy(buffer->data(), data, len);
-        if (current_send_buffer_ || !send_buffer_queue_.empty()) {
+        if (current_send_buffer_.get() || !send_buffer_queue_.empty()) {
           send_buffer_queue_.push_back(buffer);
           return true;
         }
@@ -132,7 +132,7 @@ void WebSocketJob::Close() {
     return;
 
   state_ = CLOSING;
-  if (current_send_buffer_) {
+  if (current_send_buffer_.get()) {
     // Will close in SendPending.
     return;
   }
@@ -155,7 +155,7 @@ void WebSocketJob::DetachDelegate() {
   weak_ptr_factory_for_send_pending_.InvalidateWeakPtrs();
 
   delegate_ = NULL;
-  if (socket_)
+  if (socket_.get())
     socket_->DetachDelegate();
   socket_ = NULL;
   if (!callback_.is_null()) {
@@ -205,9 +205,9 @@ void WebSocketJob::OnSentData(SocketStream* socket, int amount_sent) {
   }
   if (delegate_) {
     DCHECK(state_ == OPEN || state_ == CLOSING);
-    if (!current_send_buffer_) {
-      VLOG(1) << "OnSentData current_send_buffer=NULL amount_sent="
-              << amount_sent;
+    if (!current_send_buffer_.get()) {
+      VLOG(1)
+          << "OnSentData current_send_buffer=NULL amount_sent=" << amount_sent;
       return;
     }
     current_send_buffer_->DidConsume(amount_sent);
@@ -302,7 +302,7 @@ void WebSocketJob::OnSentSpdyHeaders() {
   if (state_ != CONNECTING)
     return;
   if (delegate_)
-    delegate_->OnSentData(socket_, handshake_request_->original_length());
+    delegate_->OnSentData(socket_.get(), handshake_request_->original_length());
   handshake_request_.reset();
 }
 
@@ -329,7 +329,7 @@ void WebSocketJob::OnSentSpdyData(size_t bytes_sent) {
     return;
   if (!spdy_websocket_stream_.get())
     return;
-  OnSentData(socket_, static_cast<int>(bytes_sent));
+  OnSentData(socket_.get(), static_cast<int>(bytes_sent));
 }
 
 void WebSocketJob::OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) {
@@ -340,16 +340,16 @@ void WebSocketJob::OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) {
   if (!spdy_websocket_stream_.get())
     return;
   if (buffer) {
-    OnReceivedData(socket_, buffer->GetRemainingData(),
-                   buffer->GetRemainingSize());
+    OnReceivedData(
+        socket_.get(), buffer->GetRemainingData(), buffer->GetRemainingSize());
   } else {
-    OnReceivedData(socket_, NULL, 0);
+    OnReceivedData(socket_.get(), NULL, 0);
   }
 }
 
 void WebSocketJob::OnCloseSpdyStream() {
   spdy_websocket_stream_.reset();
-  OnClose(socket_);
+  OnClose(socket_.get());
 }
 
 bool WebSocketJob::SendHandshakeRequest(const char* data, int len) {
@@ -368,12 +368,12 @@ bool WebSocketJob::SendHandshakeRequest(const char* data, int len) {
 
 void WebSocketJob::AddCookieHeaderAndSend() {
   bool allow = true;
-  if (delegate_ && !delegate_->CanGetCookies(socket_, GetURLForCookies()))
+  if (delegate_ && !delegate_->CanGetCookies(socket_.get(), GetURLForCookies()))
     allow = false;
 
-  if (socket_ && delegate_ && state_ == CONNECTING) {
-    handshake_request_->RemoveHeaders(
-        kCookieHeaders, arraysize(kCookieHeaders));
+  if (socket_.get() && delegate_ && state_ == CONNECTING) {
+    handshake_request_->RemoveHeaders(kCookieHeaders,
+                                      arraysize(kCookieHeaders));
     if (allow && socket_->context()->cookie_store()) {
       // Add cookies, including HttpOnly cookies.
       CookieOptions cookie_options;
@@ -497,14 +497,14 @@ void WebSocketJob::NotifyHeadersComplete() {
   DCHECK(!received_data.empty());
   if (delegate_)
     delegate_->OnReceivedData(
-        socket_, &received_data.front(), received_data.size());
+        socket_.get(), &received_data.front(), received_data.size());
 
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
   WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
 }
 
 void WebSocketJob::SaveNextCookie() {
-  if (!socket_ || !delegate_ || state_ != CONNECTING)
+  if (!socket_.get() || !delegate_ || state_ != CONNECTING)
     return;
 
   callback_pending_ = false;
@@ -526,7 +526,8 @@ void WebSocketJob::SaveNextCookie() {
       std::string cookie = response_cookies_[response_cookies_save_index_];
       response_cookies_save_index_++;
 
-      if (!delegate_->CanSetCookie(socket_, url_for_cookies, cookie, &options))
+      if (!delegate_->CanSetCookie(
+              socket_.get(), url_for_cookies, cookie, &options))
         continue;
 
       callback_pending_ = true;
@@ -613,12 +614,13 @@ int WebSocketJob::TrySpdyStream() {
 
   // Create SpdyWebSocketStream.
   spdy_protocol_version_ = spdy_session->GetProtocolVersion();
-  spdy_websocket_stream_.reset(new SpdyWebSocketStream(spdy_session, this));
+  spdy_websocket_stream_.reset(
+      new SpdyWebSocketStream(spdy_session.get(), this));
 
   int result = spdy_websocket_stream_->InitializeStream(
       socket_->url(), MEDIUM, *socket_->net_log());
   if (result == OK) {
-    OnConnected(socket_, kMaxPendingSendAllowed);
+    OnConnected(socket_.get(), kMaxPendingSendAllowed);
     return ERR_PROTOCOL_SWITCHED;
   }
   if (result != ERR_IO_PENDING) {
@@ -683,7 +685,7 @@ void WebSocketJob::CloseInternal() {
 }
 
 void WebSocketJob::SendPending() {
-  if (current_send_buffer_)
+  if (current_send_buffer_.get())
     return;
 
   // Current buffer has been sent. Try next if any.
@@ -696,8 +698,8 @@ void WebSocketJob::SendPending() {
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
-  current_send_buffer_ = new DrainableIOBuffer(next_buffer,
-                                               next_buffer->size());
+  current_send_buffer_ =
+      new DrainableIOBuffer(next_buffer.get(), next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
diff --git a/net/websockets/websocket_job_spdy2_unittest.cc b/net/websockets/websocket_job_spdy2_unittest.cc
index 474a338..30315b8 100644
--- a/net/websockets/websocket_job_spdy2_unittest.cc
+++ b/net/websockets/websocket_job_spdy2_unittest.cc
@@ -388,7 +388,7 @@ class WebSocketJobSpdy2Test : public PlatformTest {
       }
 
       ssl_config_service_ = new MockSSLConfigService();
-      context_->set_ssl_config_service(ssl_config_service_);
+      context_->set_ssl_config_service(ssl_config_service_.get());
       proxy_service_.reset(ProxyService::CreateDirect());
       context_->set_proxy_service(proxy_service_.get());
       host_resolver_.reset(new MockHostResolver);
@@ -413,15 +413,15 @@ class WebSocketJobSpdy2Test : public PlatformTest {
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
-    WebSocketThrottle::GetInstance()->PutInQueue(websocket_);
+    WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get());
   }
   WebSocketJob::State GetWebSocketJobState() {
     return websocket_->state_;
   }
   void CloseWebSocketJob() {
-    if (websocket_->socket_) {
+    if (websocket_->socket_.get()) {
       websocket_->socket_->DetachDelegate();
-      WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_);
+      WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_.get());
     }
     websocket_->state_ = WebSocketJob::CLOSED;
     websocket_->delegate_ = NULL;
@@ -614,9 +614,7 @@ void WebSocketJobSpdy2Test::TestSlowHandshake() {
   for (size_t i = 0; i < lines.size() - 2; i++) {
     std::string line = lines[i] + "\r\n";
     SCOPED_TRACE("Line: " + line);
-    websocket_->OnReceivedData(socket_,
-                               line.c_str(),
-                               line.size());
+    websocket_->OnReceivedData(socket_.get(), line.c_str(), line.size());
     base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(delegate.received_data().empty());
     EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
@@ -635,10 +633,11 @@ TEST_F(WebSocketJobSpdy2Test, DelayedCookies) {
   GURL cookieUrl("http://example.com/demo");
   CookieOptions cookie_options;
   scoped_refptr<DelayedCookieMonster> cookie_store = new DelayedCookieMonster();
-  context_->set_cookie_store(cookie_store);
-  cookie_store->SetCookieWithOptionsAsync(
-      cookieUrl, "CR-test=1", cookie_options,
-      CookieMonster::SetCookiesCallback());
+  context_->set_cookie_store(cookie_store.get());
+  cookie_store->SetCookieWithOptionsAsync(cookieUrl,
+                                          "CR-test=1",
+                                          cookie_options,
+                                          CookieMonster::SetCookiesCallback());
   cookie_options.set_include_httponly();
   cookie_store->SetCookieWithOptionsAsync(
       cookieUrl, "CR-test-httponly=1", cookie_options,
@@ -654,7 +653,7 @@ TEST_F(WebSocketJobSpdy2Test, DelayedCookies) {
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_,
+  websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithFilteredCookieLength);
   EXPECT_EQ(kHandshakeRequestWithCookieLength,
             delegate.amount_sent());
@@ -689,7 +688,7 @@ void WebSocketJobSpdy2Test::TestHandshakeWithCookie() {
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_,
+  websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithFilteredCookieLength);
   EXPECT_EQ(kHandshakeRequestWithCookieLength,
             delegate.amount_sent());
@@ -733,9 +732,8 @@ void WebSocketJobSpdy2Test::TestHandshakeWithCookieButNotAllowed() {
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_, kHandshakeRequestWithoutCookieLength);
-  EXPECT_EQ(kHandshakeRequestWithCookieLength,
-            delegate.amount_sent());
+  websocket_->OnSentData(socket_.get(), kHandshakeRequestWithoutCookieLength);
+  EXPECT_EQ(kHandshakeRequestWithCookieLength, delegate.amount_sent());
 
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithCookie,
@@ -863,7 +861,7 @@ void WebSocketJobSpdy2Test::TestConnectByWebSocket(
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
-    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket);
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
     block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
@@ -979,7 +977,7 @@ void WebSocketJobSpdy2Test::TestConnectBySpdy(
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
-    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket);
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
     block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
diff --git a/net/websockets/websocket_job_spdy3_unittest.cc b/net/websockets/websocket_job_spdy3_unittest.cc
index 2b22281..7ba2ee6 100644
--- a/net/websockets/websocket_job_spdy3_unittest.cc
+++ b/net/websockets/websocket_job_spdy3_unittest.cc
@@ -388,7 +388,7 @@ class WebSocketJobSpdy3Test : public PlatformTest {
       }
 
       ssl_config_service_ = new MockSSLConfigService();
-      context_->set_ssl_config_service(ssl_config_service_);
+      context_->set_ssl_config_service(ssl_config_service_.get());
       proxy_service_.reset(ProxyService::CreateDirect());
       context_->set_proxy_service(proxy_service_.get());
       host_resolver_.reset(new MockHostResolver);
@@ -413,15 +413,15 @@ class WebSocketJobSpdy3Test : public PlatformTest {
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
-    WebSocketThrottle::GetInstance()->PutInQueue(websocket_);
+    WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get());
   }
   WebSocketJob::State GetWebSocketJobState() {
     return websocket_->state_;
   }
   void CloseWebSocketJob() {
-    if (websocket_->socket_) {
+    if (websocket_->socket_.get()) {
       websocket_->socket_->DetachDelegate();
-      WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_);
+      WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_.get());
     }
     websocket_->state_ = WebSocketJob::CLOSED;
     websocket_->delegate_ = NULL;
@@ -614,9 +614,7 @@ void WebSocketJobSpdy3Test::TestSlowHandshake() {
   for (size_t i = 0; i < lines.size() - 2; i++) {
     std::string line = lines[i] + "\r\n";
     SCOPED_TRACE("Line: " + line);
-    websocket_->OnReceivedData(socket_,
-                               line.c_str(),
-                               line.size());
+    websocket_->OnReceivedData(socket_.get(), line.c_str(), line.size());
     base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(delegate.received_data().empty());
     EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
@@ -635,10 +633,11 @@ TEST_F(WebSocketJobSpdy3Test, DelayedCookies) {
   GURL cookieUrl("http://example.com/demo");
   CookieOptions cookie_options;
   scoped_refptr<DelayedCookieMonster> cookie_store = new DelayedCookieMonster();
-  context_->set_cookie_store(cookie_store);
-  cookie_store->SetCookieWithOptionsAsync(
-      cookieUrl, "CR-test=1", cookie_options,
-      CookieMonster::SetCookiesCallback());
+  context_->set_cookie_store(cookie_store.get());
+  cookie_store->SetCookieWithOptionsAsync(cookieUrl,
+                                          "CR-test=1",
+                                          cookie_options,
+                                          CookieMonster::SetCookiesCallback());
   cookie_options.set_include_httponly();
   cookie_store->SetCookieWithOptionsAsync(
       cookieUrl, "CR-test-httponly=1", cookie_options,
@@ -654,7 +653,7 @@ TEST_F(WebSocketJobSpdy3Test, DelayedCookies) {
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_,
+  websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithFilteredCookieLength);
   EXPECT_EQ(kHandshakeRequestWithCookieLength,
             delegate.amount_sent());
@@ -689,7 +688,7 @@ void WebSocketJobSpdy3Test::TestHandshakeWithCookie() {
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_,
+  websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithFilteredCookieLength);
   EXPECT_EQ(kHandshakeRequestWithCookieLength,
             delegate.amount_sent());
@@ -733,9 +732,8 @@ void WebSocketJobSpdy3Test::TestHandshakeWithCookieButNotAllowed() {
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_, kHandshakeRequestWithoutCookieLength);
-  EXPECT_EQ(kHandshakeRequestWithCookieLength,
-            delegate.amount_sent());
+  websocket_->OnSentData(socket_.get(), kHandshakeRequestWithoutCookieLength);
+  EXPECT_EQ(kHandshakeRequestWithCookieLength, delegate.amount_sent());
 
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithCookie,
@@ -863,7 +861,7 @@ void WebSocketJobSpdy3Test::TestConnectByWebSocket(
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
-    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket);
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
     block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
@@ -979,7 +977,7 @@ void WebSocketJobSpdy3Test::TestConnectBySpdy(
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
-    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket);
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
     block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
diff --git a/net/websockets/websocket_throttle_unittest.cc b/net/websockets/websocket_throttle_unittest.cc
index a323734..4f0345c 100644
--- a/net/websockets/websocket_throttle_unittest.cc
+++ b/net/websockets/websocket_throttle_unittest.cc
@@ -76,12 +76,12 @@ TEST_F(WebSocketThrottleTest, Throttle) {
       new SocketStream(GURL("ws://host1/"), w1.get()));
   s1->set_context(&context);
   w1->InitSocketStream(s1.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s1, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s1.get(), addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to host1 will start without wait.
-  EXPECT_EQ(OK, w1->OnStartOpenConnection(s1, callback_s1.callback()));
+  EXPECT_EQ(OK, w1->OnStartOpenConnection(s1.get(), callback_s1.callback()));
 
   // Now connecting to host1, so waiting queue looks like
   // Address | head -> tail
@@ -97,13 +97,13 @@ TEST_F(WebSocketThrottleTest, Throttle) {
       new SocketStream(GURL("ws://host2/"), w2.get()));
   s2->set_context(&context);
   w2->InitSocketStream(s2.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s2, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s2.get(), addr);
 
   DVLOG(1) << "socket2";
   TestCompletionCallback callback_s2;
   // Trying to open connection to host2 will wait for w1.
   EXPECT_EQ(ERR_IO_PENDING,
-            w2->OnStartOpenConnection(s2, callback_s2.callback()));
+            w2->OnStartOpenConnection(s2.get(), callback_s2.callback()));
   // Now waiting queue looks like
   // Address | head -> tail
   // 1.2.3.4 | w1 w2
@@ -118,13 +118,13 @@ TEST_F(WebSocketThrottleTest, Throttle) {
       new SocketStream(GURL("ws://host3/"), w3.get()));
   s3->set_context(&context);
   w3->InitSocketStream(s3.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s3, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s3.get(), addr);
 
   DVLOG(1) << "socket3";
   TestCompletionCallback callback_s3;
   // Trying to open connection to host3 will wait for w1.
   EXPECT_EQ(ERR_IO_PENDING,
-            w3->OnStartOpenConnection(s3, callback_s3.callback()));
+            w3->OnStartOpenConnection(s3.get(), callback_s3.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2
   // 1.2.3.5 | w1    w3
@@ -139,13 +139,13 @@ TEST_F(WebSocketThrottleTest, Throttle) {
       new SocketStream(GURL("ws://host4/"), w4.get()));
   s4->set_context(&context);
   w4->InitSocketStream(s4.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s4, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s4.get(), addr);
 
   DVLOG(1) << "socket4";
   TestCompletionCallback callback_s4;
   // Trying to open connection to host4 will wait for w1, w2.
   EXPECT_EQ(ERR_IO_PENDING,
-            w4->OnStartOpenConnection(s4, callback_s4.callback()));
+            w4->OnStartOpenConnection(s4.get(), callback_s4.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
   // 1.2.3.5 | w1    w3
@@ -159,13 +159,13 @@ TEST_F(WebSocketThrottleTest, Throttle) {
       new SocketStream(GURL("ws://host5/"), w5.get()));
   s5->set_context(&context);
   w5->InitSocketStream(s5.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s5, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s5.get(), addr);
 
   DVLOG(1) << "socket5";
   TestCompletionCallback callback_s5;
   // Trying to open connection to host5 will wait for w1, w4
   EXPECT_EQ(ERR_IO_PENDING,
-            w5->OnStartOpenConnection(s5, callback_s5.callback()));
+            w5->OnStartOpenConnection(s5.get(), callback_s5.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
   // 1.2.3.5 | w1    w3
@@ -179,13 +179,13 @@ TEST_F(WebSocketThrottleTest, Throttle) {
       new SocketStream(GURL("ws://host6/"), w6.get()));
   s6->set_context(&context);
   w6->InitSocketStream(s6.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s6, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s6.get(), addr);
 
   DVLOG(1) << "socket6";
   TestCompletionCallback callback_s6;
   // Trying to open connection to host6 will wait for w1, w4, w5
   EXPECT_EQ(ERR_IO_PENDING,
-            w6->OnStartOpenConnection(s6, callback_s6.callback()));
+            w6->OnStartOpenConnection(s6.get(), callback_s6.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
   // 1.2.3.5 | w1    w3
@@ -292,12 +292,12 @@ TEST_F(WebSocketThrottleTest, NoThrottleForDuplicateAddress) {
       new SocketStream(GURL("ws://localhost/"), w1.get()));
   s1->set_context(&context);
   w1->InitSocketStream(s1.get());
-  WebSocketThrottleTest::MockSocketStreamConnect(s1, addr);
+  WebSocketThrottleTest::MockSocketStreamConnect(s1.get(), addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to localhost will start without wait.
-  EXPECT_EQ(OK, w1->OnStartOpenConnection(s1, callback_s1.callback()));
+  EXPECT_EQ(OK, w1->OnStartOpenConnection(s1.get(), callback_s1.callback()));
 
   DVLOG(1) << "socket1 close";
   w1->OnClose(s1.get());
@@ -321,12 +321,13 @@ TEST_F(WebSocketThrottleTest, NoThrottleForDistinctPort) {
       new SocketStream(GURL("ws://localhost:80/"), w1.get()));
   s1->set_context(&context);
   w1->InitSocketStream(s1.get());
-  MockSocketStreamConnect(s1, AddressList::CreateFromIPAddress(localhost, 80));
+  MockSocketStreamConnect(s1.get(),
+                          AddressList::CreateFromIPAddress(localhost, 80));
 
   DVLOG(1) << "connecting socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to localhost:80 will start without waiting.
-  EXPECT_EQ(OK, w1->OnStartOpenConnection(s1, callback_s1.callback()));
+  EXPECT_EQ(OK, w1->OnStartOpenConnection(s1.get(), callback_s1.callback()));
 
   // socket2: 127.0.0.1:81
   scoped_refptr<WebSocketJob> w2(new WebSocketJob(&delegate));
@@ -334,12 +335,13 @@ TEST_F(WebSocketThrottleTest, NoThrottleForDistinctPort) {
       new SocketStream(GURL("ws://localhost:81/"), w2.get()));
   s2->set_context(&context);
   w2->InitSocketStream(s2.get());
-  MockSocketStreamConnect(s2, AddressList::CreateFromIPAddress(localhost, 81));
+  MockSocketStreamConnect(s2.get(),
+                          AddressList::CreateFromIPAddress(localhost, 81));
 
   DVLOG(1) << "connecting socket2";
   TestCompletionCallback callback_s2;
   // Trying to open connection to localhost:81 will start without waiting.
-  EXPECT_EQ(OK, w2->OnStartOpenConnection(s2, callback_s2.callback()));
+  EXPECT_EQ(OK, w2->OnStartOpenConnection(s2.get(), callback_s2.callback()));
 
   DVLOG(1) << "closing socket1";
   w1->OnClose(s1.get());