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

webkit/appcache/appcache_url_request_job_unittest.cc

 // Copyright (c) 2011 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 <stack>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 93 matching lines @@
       } else {
         RequestComplete();
       }
     }
 
     void ReadSome(net::URLRequest* request) {
       DCHECK(amount_received_ + kBlockSize <= kNumBlocks * kBlockSize);
       scoped_refptr<IOBuffer> wrapped_buffer(
           new net::WrappedIOBuffer(received_data_->data() + amount_received_));
       int bytes_read = 0;
-      EXPECT_FALSE(request->Read(wrapped_buffer, kBlockSize, &bytes_read));
+      EXPECT_FALSE(
+          request->Read(wrapped_buffer.get(), kBlockSize, &bytes_read));
       EXPECT_EQ(0, bytes_read);
     }
 
     void RequestComplete() {
       test_->ScheduleNextTask();
     }
 
     AppCacheURLRequestJobTest* test_;
     net::HttpResponseInfo received_info_;
     scoped_refptr<net::IOBuffer> received_data_;
@@ skipping 120 matching lines @@
       task.Run();
     else
       base::MessageLoop::current()->PostTask(FROM_HERE, task);
   }
 
   // Wrappers to call AppCacheResponseReader/Writer Read and Write methods
 
   void WriteBasicResponse() {
     scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBasicBody));
     std::string raw_headers(kHttpBasicHeaders, arraysize(kHttpBasicHeaders));
-    WriteResponse(MakeHttpResponseInfo(raw_headers), body,
-                  strlen(kHttpBasicBody));
+    WriteResponse(
+        MakeHttpResponseInfo(raw_headers), body.get(), strlen(kHttpBasicBody));
   }
 
   void WriteResponse(net::HttpResponseInfo* head,
                      IOBuffer* body, int body_len) {
     DCHECK(body);
     scoped_refptr<IOBuffer> body_ref(body);
     PushNextTask(base::Bind(&AppCacheURLRequestJobTest::WriteResponseBody,
                             base::Unretained(this), body_ref, body_len));
     WriteResponseHead(head);
   }
 
   void WriteResponseHead(net::HttpResponseInfo* head) {
     EXPECT_FALSE(writer_->IsWritePending());
     expected_write_result_ = GetHttpResponseInfoSize(head);
     write_info_buffer_ = new HttpResponseInfoIOBuffer(head);
     writer_->WriteInfo(
-        write_info_buffer_,
+        write_info_buffer_.get(),
         base::Bind(&AppCacheURLRequestJobTest::OnWriteInfoComplete,
                    base::Unretained(this)));
   }
 
   void WriteResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
     EXPECT_FALSE(writer_->IsWritePending());
     write_buffer_ = io_buffer;
     expected_write_result_ = buf_len;
-    writer_->WriteData(
-        write_buffer_, buf_len,
-        base::Bind(&AppCacheURLRequestJobTest::OnWriteComplete,
-                   base::Unretained(this)));
+    writer_->WriteData(write_buffer_.get(),
+                       buf_len,
+                       base::Bind(&AppCacheURLRequestJobTest::OnWriteComplete,
+                                  base::Unretained(this)));
   }
 
   void ReadResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = io_buffer;
     expected_read_result_ = buf_len;
-    reader_->ReadData(
-        read_buffer_, buf_len,
-        base::Bind(&AppCacheURLRequestJobTest::OnReadComplete,
-                   base::Unretained(this)));
+    reader_->ReadData(read_buffer_.get(),
+                      buf_len,
+                      base::Bind(&AppCacheURLRequestJobTest::OnReadComplete,
+                                 base::Unretained(this)));
   }
 
   // AppCacheResponseReader / Writer completion callbacks
 
   void OnWriteInfoComplete(int result) {
     EXPECT_FALSE(writer_->IsWritePending());
     EXPECT_EQ(expected_write_result_, result);
     ScheduleNextTask();
   }
 
@@ skipping 230 matching lines @@
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 0, 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
           false);
       EXPECT_TRUE(job->is_delivering_appcache_response());
     }
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
-    mock_factory_job_ = job;
+    mock_factory_job_ = job.get();
     request_->Start();
     EXPECT_FALSE(mock_factory_job_);
     EXPECT_TRUE(job->has_been_started());
 
     if (!start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 0, 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
           false);
       EXPECT_TRUE(job->is_delivering_appcache_response());
@@ skipping 38 matching lines @@
 
   void WriteLargeResponse() {
     // 3, 1k blocks
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 3072\0\0";
     scoped_refptr<IOBuffer> body(new IOBuffer(kBlockSize * 3));
     char* p = body->data();
     for (int i = 0; i < 3; ++i, p += kBlockSize)
       FillData(i + 1, p, kBlockSize);
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
-    WriteResponse(MakeHttpResponseInfo(raw_headers), body, kBlockSize * 3);
+    WriteResponse(
+        MakeHttpResponseInfo(raw_headers), body.get(), kBlockSize * 3);
   }
 
   void VerifyDeliverLargeAppCachedResponse() {
     EXPECT_TRUE(request_->status().is_success());
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         &url_request_delegate_->received_info_));
     EXPECT_EQ(3072, url_request_delegate_->amount_received_);
     char* p = url_request_delegate_->received_data_->data();
     for (int i = 0; i < 3; ++i, p += kBlockSize)
@@ skipping 33 matching lines @@
     scoped_refptr<AppCacheURLRequestJob> job(new AppCacheURLRequestJob(
         request_.get(), NULL, storage));
     job->DeliverAppCachedResponse(
         GURL(), 0, 111,
         AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
         false);
     EXPECT_TRUE(job->is_delivering_appcache_response());
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
-    mock_factory_job_ = job;
+    mock_factory_job_ = job.get();
     request_->Start();
     EXPECT_FALSE(mock_factory_job_);
     EXPECT_TRUE(job->has_been_started());
     // Completion is async.
   }
 
   void VerifyDeliverPartialResponse() {
     EXPECT_TRUE(request_->status().is_success());
     EXPECT_EQ(3, url_request_delegate_->amount_received_);
     EXPECT_EQ(0, memcmp(kHttpBasicBody + 1,
@@ skipping 128 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace appcache