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

chrome/browser/drive/drive_uploader_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 "chrome/browser/drive/drive_uploader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 296 matching lines @@
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 0, &local_path, &data));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       local_path,
       kTestMimeType,
       std::string(),  // etag
       test_util::CreateCopyResultCallback(
           &error, &upload_location, &resource_entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
@@ skipping 13 matching lines @@
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       local_path,
       kTestMimeType,
       std::string(),  // etag
       test_util::CreateCopyResultCallback(
           &error, &upload_location, &resource_entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
@@ skipping 15 matching lines @@
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   GDataErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceNoConnectionAtInitiate mock_service;
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
-  uploader.UploadExistingFile(
-      kTestInitiateUploadResourceId,
-      local_path,
-      kTestMimeType,
-      std::string(),  // etag
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
-      google_apis::ProgressCallback());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
+  uploader.UploadExistingFile(kTestInitiateUploadResourceId,
+                              local_path,
+                              kTestMimeType,
+                              std::string(),  // etag
+                              test_util::CreateCopyResultCallback(
+                                  &error, &upload_location, &resource_entry),
+                              google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
   EXPECT_FALSE(resource_entry);
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadNoConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
-  uploader.UploadExistingFile(
-      kTestInitiateUploadResourceId,
-      local_path,
-      kTestMimeType,
-      kTestETag,
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
-      google_apis::ProgressCallback());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
+  uploader.UploadExistingFile(kTestInitiateUploadResourceId,
+                              local_path,
+                              kTestMimeType,
+                              kTestETag,
+                              test_util::CreateCopyResultCallback(
+                                  &error, &upload_location, &resource_entry),
+                              google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
   const std::string kDestinationETag("destination_etag");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
-  uploader.UploadExistingFile(
-      kTestInitiateUploadResourceId,
-      local_path,
-      kTestMimeType,
-      kDestinationETag,
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
-      google_apis::ProgressCallback());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
+  uploader.UploadExistingFile(kTestInitiateUploadResourceId,
+                              local_path,
+                              kTestMimeType,
+                              kDestinationETag,
+                              test_util::CreateCopyResultCallback(
+                                  &error, &upload_location, &resource_entry),
+                              google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CONFLICT, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, ResumeUploadFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   GDataErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceNoConnectionAtResume mock_service;
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
-  uploader.UploadExistingFile(
-      kTestInitiateUploadResourceId,
-      local_path,
-      kTestMimeType,
-      std::string(),  // etag
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
-      google_apis::ProgressCallback());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
+  uploader.UploadExistingFile(kTestInitiateUploadResourceId,
+                              local_path,
+                              kTestMimeType,
+                              std::string(),  // etag
+                              test_util::CreateCopyResultCallback(
+                                  &error, &upload_location, &resource_entry),
+                              google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_EQ(GURL(kTestUploadExistingFileURL), upload_location);
 }
 
 TEST_F(DriveUploaderTest, NonExistingSourceFile) {
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   DriveUploader uploader(NULL,  // NULL, the service won't be used.
-                         base::MessageLoopProxy::current());
+                         base::MessageLoopProxy::current().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       temp_dir_.path().AppendASCII("_this_path_should_not_exist_"),
       kTestMimeType,
-      std::string(),             // etag
+      std::string(),  // etag
       test_util::CreateCopyResultCallback(
           &error, &upload_location, &resource_entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   // Should return failure without doing any attempt to connect to the server.
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, ResumeUpload) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 1024 * 1024, &local_path, &data));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
-  DriveUploader uploader(&mock_service, base::MessageLoopProxy::current());
+  DriveUploader uploader(&mock_service,
+                         base::MessageLoopProxy::current().get());
   // Emulate the situation that the only first part is successfully uploaded,
   // but not the latter half.
   mock_service.set_received_bytes(512 * 1024);
 
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.ResumeUploadFile(
       GURL(kTestUploadExistingFileURL),
       local_path,
       kTestMimeType,
       test_util::CreateCopyResultCallback(
           &error, &upload_location, &resource_entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, mock_service.resume_upload_call_count());
   EXPECT_EQ(1024 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ(kTestDummyId, resource_entry->id());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
 }
 
 }  // namespace drive