Remove implicit scoped_refptr operator T*

webkit/blob/blob_url_request_job_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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 183 matching lines @@
   void WriteFileSystemFile(const std::string& filename,
                            const char* buf, int buf_size,
                            base::Time* modification_time) {
     fileapi::FileSystemURL url(GURL(kFileSystemURLOrigin),
                                kFileSystemType,
                                FilePath().AppendASCII(filename));
 
     fileapi::FileSystemFileUtil* file_util =
         file_system_context_->GetFileUtil(kFileSystemType);
 
-    fileapi::FileSystemOperationContext context(file_system_context_);
+    fileapi::FileSystemOperationContext context(file_system_context_.get());
     context.set_allowed_bytes_growth(1024);
 
     base::PlatformFile handle = base::kInvalidPlatformFileValue;
     bool created = false;
     ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->CreateOrOpen(
         &context,
         url,
         base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
         &handle,
         &created));
@@ skipping 39 matching lines @@
                    BlobData* blob_data) {
     MockURLRequestDelegate url_request_delegate;
 
     request_.reset(empty_context_.CreateRequest(
         GURL("blob:blah"), &url_request_delegate));
     request_->set_method(method);
     blob_url_request_job_ = new BlobURLRequestJob(
         request_.get(),
         empty_context_.network_delegate(),
         blob_data,
-        file_system_context_,
-        base::MessageLoopProxy::current());
+        file_system_context_.get(),
+        base::MessageLoopProxy::current().get());
 
     // Start the request.
     if (!extra_headers.IsEmpty())
       request_->SetExtraRequestHeaders(extra_headers);
     request_->Start();
 
     MessageLoop::current()->Run();
 
     // Verify response.
     EXPECT_TRUE(request_->status().is_success());
@@ skipping 42 matching lines @@
   int expected_status_code_;
   std::string expected_response_;
 };
 
 // static
 BlobURLRequestJob* BlobURLRequestJobTest::blob_url_request_job_ = NULL;
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendData(kTestData1);
-  TestSuccessRequest(blob_data, kTestData1);
+  TestSuccessRequest(blob_data.get(), kTestData1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFile(temp_file1_, 0, -1, base::Time());
-  TestSuccessRequest(blob_data, kTestFileData1);
+  TestSuccessRequest(blob_data.get(), kTestFileData1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
   scoped_refptr<BlobData> blob_data(new BlobData());
   FilePath large_temp_file = temp_dir_.path().AppendASCII("LargeBlob.dat");
   std::string large_data;
   large_data.reserve(kBufferSize * 5);
   for (int i = 0; i < kBufferSize * 5; ++i)
     large_data.append(1, static_cast<char>(i % 256));
   ASSERT_EQ(static_cast<int>(large_data.size()),
             file_util::WriteFile(large_temp_file, large_data.data(),
                                  large_data.size()));
   blob_data->AppendFile(large_temp_file, 0, -1, base::Time());
-  TestSuccessRequest(blob_data, large_data);
+  TestSuccessRequest(blob_data.get(), large_data);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
   FilePath non_existent_file =
       temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na"));
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFile(non_existent_file, 0, -1, base::Time());
-  TestErrorRequest(blob_data, 404);
+  TestErrorRequest(blob_data.get(), 404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) {
   scoped_refptr<BlobData> blob_data(new BlobData());
   base::Time old_time =
       temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10);
   blob_data->AppendFile(temp_file1_, 0, 3, old_time);
-  TestErrorRequest(blob_data, 404);
+  TestErrorRequest(blob_data.get(), 404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_);
   std::string result(kTestFileData1 + 2, 4);
-  TestSuccessRequest(blob_data, result);
+  TestSuccessRequest(blob_data.get(), result);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
   SetUpFileSystem();
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFileSystemFile(temp_file_system_file1_, 0, -1,
                                   base::Time());
-  TestSuccessRequest(blob_data, kTestFileSystemFileData1);
+  TestSuccessRequest(blob_data.get(), kTestFileSystemFileData1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
   SetUpFileSystem();
   std::string large_data;
   large_data.reserve(kBufferSize * 5);
   for (int i = 0; i < kBufferSize * 5; ++i)
     large_data.append(1, static_cast<char>(i % 256));
 
   const char kFilename[] = "LargeBlob.dat";
   WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
 
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFileSystemFile(GetFileSystemURL(kFilename),
                                   0, -1, base::Time());
-  TestSuccessRequest(blob_data, large_data);
+  TestSuccessRequest(blob_data.get(), large_data);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
   SetUpFileSystem();
   GURL non_existent_file = GetFileSystemURL("non-existent.dat");
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFileSystemFile(non_existent_file, 0, -1, base::Time());
-  TestErrorRequest(blob_data, 404);
+  TestErrorRequest(blob_data.get(), 404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
   SetUpFileSystem();
   scoped_refptr<BlobData> blob_data(new BlobData());
   base::Time old_time =
       temp_file_system_file_modification_time1_ -
       base::TimeDelta::FromSeconds(10);
   blob_data->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time);
-  TestErrorRequest(blob_data, 404);
+  TestErrorRequest(blob_data.get(), 404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
   SetUpFileSystem();
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
                                   temp_file_system_file_modification_time1_);
   std::string result(kTestFileSystemFileData1 + 2, 4);
-  TestSuccessRequest(blob_data, result);
+  TestSuccessRequest(blob_data.get(), result);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) {
   SetUpFileSystem();
   std::string result;
   scoped_refptr<BlobData> blob_data = BuildComplicatedData(&result);
-  TestSuccessRequest(blob_data, result);
+  TestSuccessRequest(blob_data.get(), result);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) {
   SetUpFileSystem();
   std::string result;
   scoped_refptr<BlobData> blob_data = BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange, "bytes=5-10");
   expected_status_code_ = 206;
   expected_response_ = result.substr(5, 10 - 5 + 1);
-  TestRequest("GET", extra_headers, blob_data);
+  TestRequest("GET", extra_headers, blob_data.get());
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) {
   SetUpFileSystem();
   std::string result;
   scoped_refptr<BlobData> blob_data = BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange, "bytes=-10");
   expected_status_code_ = 206;
   expected_response_ = result.substr(result.length() - 10);
-  TestRequest("GET", extra_headers, blob_data);
+  TestRequest("GET", extra_headers, blob_data.get());
 }
 
 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
   scoped_refptr<BlobData> blob_data(new BlobData());
   blob_data->set_content_type(kTestContentType);
   blob_data->set_content_disposition(kTestContentDisposition);
   blob_data->AppendData(kTestData1);
   expected_status_code_ = 200;
   expected_response_ = kTestData1;
-  TestRequest("GET", net::HttpRequestHeaders(), blob_data);
+  TestRequest("GET", net::HttpRequestHeaders(), blob_data.get());
 
   std::string content_type;
   EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
   EXPECT_STREQ(content_type.c_str(), kTestContentType);
   void* iter = NULL;
   std::string content_disposition;
   EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
       &iter, "Content-Disposition", &content_disposition));
   EXPECT_STREQ(content_disposition.c_str(), kTestContentDisposition);
 }
 
 }  // namespace webkit_blob