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

webkit/appcache/appcache_response_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stack>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 140 matching lines @@
   }
 
   // Wrappers to call AppCacheResponseReader/Writer Read and Write methods
 
   void WriteBasicResponse() {
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 5\0\0";
     static const char* kHttpBody = "Hello";
     scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBody));
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
-    WriteResponse(MakeHttpResponseInfo(raw_headers), body, strlen(kHttpBody));
+    WriteResponse(
+        MakeHttpResponseInfo(raw_headers), body.get(), strlen(kHttpBody));
   }
 
   int basic_response_size() { return 5; }  // should match kHttpBody above
 
   void WriteResponse(net::HttpResponseInfo* head,
                      IOBuffer* body, int body_len) {
     DCHECK(body);
     scoped_refptr<IOBuffer> body_ref(body);
     PushNextTask(base::Bind(&AppCacheResponseTest::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_,
-        base::Bind(&AppCacheResponseTest::OnWriteInfoComplete,
-                   base::Unretained(this)));
+    writer_->WriteInfo(write_info_buffer_.get(),
+                       base::Bind(&AppCacheResponseTest::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(&AppCacheResponseTest::OnWriteComplete,
-                   base::Unretained(this)));
+    writer_->WriteData(write_buffer_.get(),
+                       buf_len,
+                       base::Bind(&AppCacheResponseTest::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(&AppCacheResponseTest::OnReadComplete,
-                   base::Unretained(this)));
+    reader_->ReadData(read_buffer_.get(),
+                      buf_len,
+                      base::Bind(&AppCacheResponseTest::OnReadComplete,
+                                 base::Unretained(this)));
   }
 
   // AppCacheResponseReader / Writer completion callbacks
 
   void OnWriteInfoComplete(int result) {
     EXPECT_FALSE(writer_->IsWritePending());
     EXPECT_EQ(expected_write_result_, result);
     ScheduleNextTask();
   }
 
@@ skipping 89 matching lines @@
     PushNextTask(base::Bind(&AppCacheResponseTest::ReadNonExistentData,
                             base::Unretained(this)));
     PushNextTask(base::Bind(&AppCacheResponseTest::ReadNonExistentInfo,
                             base::Unretained(this)));
     ScheduleNextTask();
   }
 
   void ReadNonExistentInfo() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_info_buffer_ = new HttpResponseInfoIOBuffer();
-    reader_->ReadInfo(
-        read_info_buffer_,
-        base::Bind(&AppCacheResponseTest::OnReadInfoComplete,
-                   base::Unretained(this)));
+    reader_->ReadInfo(read_info_buffer_.get(),
+                      base::Bind(&AppCacheResponseTest::OnReadInfoComplete,
+                                 base::Unretained(this)));
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   void ReadNonExistentData() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = new IOBuffer(kBlockSize);
-    reader_->ReadData(
-        read_buffer_, kBlockSize,
-        base::Bind(&AppCacheResponseTest::OnReadComplete,
-                   base::Unretained(this)));
+    reader_->ReadData(read_buffer_.get(),
+                      kBlockSize,
+                      base::Bind(&AppCacheResponseTest::OnReadComplete,
+                                 base::Unretained(this)));
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   // LoadResponseInfo_Miss ----------------------------------------------------
   void LoadResponseInfo_Miss() {
     PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Miss_Verify,
                             base::Unretained(this)));
     service_->storage()->LoadResponseInfo(GURL(), 0, kNoSuchResponseId,
                                           storage_delegate_.get());
@@ skipping 155 matching lines @@
     char* p = read_buffer_->data();
     for (int i = 0; i < kNumBlocks; ++i, p += kBlockSize)
       EXPECT_TRUE(CheckData(i + 1, p, kBlockSize));
     ScheduleNextTask();
   }
 
   void ReadPastEOF() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = new IOBuffer(kBlockSize);
     expected_read_result_ = 0;
-    reader_->ReadData(
-        read_buffer_, kBlockSize,
-        base::Bind(&AppCacheResponseTest::OnReadComplete,
-                   base::Unretained(this)));
+    reader_->ReadData(read_buffer_.get(),
+                      kBlockSize,
+                      base::Bind(&AppCacheResponseTest::OnReadComplete,
+                                 base::Unretained(this)));
   }
 
   void ReadRange() {
     PushNextTask(base::Bind(&AppCacheResponseTest::VerifyRange,
                             base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     reader_->SetReadRange(kBlockSize, kBlockSize);
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
   }
@@ skipping 193 matching lines @@
 
 TEST_F(AppCacheResponseTest, DeleteWithinCallbacks) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithinCallbacks);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithIOPending);
 }
 
 }  // namespace appcache