chrome: Use base::MessageLoop. (Part 3)

chrome/browser/google_apis/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/google_apis/drive_uploader.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <string>
 #include <utility>
@@ skipping 68 matching lines @@
       const std::string& title,
       const InitiateUploadCallback& callback) OVERRIDE {
     EXPECT_EQ(kTestDocumentTitle, title);
     EXPECT_EQ(kTestMimeType, content_type);
     const int64 expected_size = expected_upload_content_.size();
     EXPECT_EQ(expected_size, content_length);
     EXPECT_EQ(kTestInitiateUploadParentResourceId, parent_resource_id);
 
     // Calls back the upload URL for subsequent ResumeUpload operations.
     // InitiateUpload is an asynchronous function, so don't callback directly.
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
   }
 
   virtual void InitiateUploadExistingFile(
       const base::FilePath& drive_file_path,
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const std::string& etag,
       const InitiateUploadCallback& callback) OVERRIDE {
     EXPECT_EQ(kTestMimeType, content_type);
     const int64 expected_size = expected_upload_content_.size();
     EXPECT_EQ(expected_size, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
 
     if (!etag.empty() && etag != kTestETag) {
-      MessageLoop::current()->PostTask(FROM_HERE,
-          base::Bind(callback, HTTP_PRECONDITION, GURL()));
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(callback, HTTP_PRECONDITION, GURL()));
       return;
     }
 
     // Calls back the upload URL for subsequent ResumeUpload operations.
     // InitiateUpload is an asynchronous function, so don't callback directly.
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
   }
 
   // Handles a request for uploading a chunk of bytes.
   virtual void ResumeUpload(
       UploadMode upload_mode,
       const base::FilePath& drive_file_path,
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
@@ skipping 26 matching lines @@
     EXPECT_EQ(kTestMimeType, content_type);
 
     // Update the internal status of the current upload session.
     resume_upload_call_count_++;
     received_bytes_ = end_position;
 
     // Callback progress
     if (!progress_callback.is_null()) {
       // For the testing purpose, it always notifies the progress at the end of
       // each chunk uploading.
-      MessageLoop::current()->PostTask(FROM_HERE,
-          base::Bind(progress_callback, expected_chunk_size,
-                     expected_chunk_size));
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(
+              progress_callback, expected_chunk_size, expected_chunk_size));
     }
 
     // Callback with response.
     UploadRangeResponse response;
     scoped_ptr<ResourceEntry> entry;
     if (received_bytes_ == content_length) {
       response = UploadRangeResponse(
           upload_mode == UPLOAD_NEW_FILE ? HTTP_CREATED : HTTP_SUCCESS,
           -1, -1);
 
       base::DictionaryValue dict;
       dict.Set("id.$t", new base::StringValue(kTestDummyId));
       entry = ResourceEntry::CreateFrom(dict);
     } else {
       response = UploadRangeResponse(HTTP_RESUME_INCOMPLETE, 0, end_position);
     }
     // ResumeUpload is an asynchronous function, so don't callback directly.
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, response, base::Passed(&entry)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, response, base::Passed(&entry)));
   }
 
   std::string expected_upload_content_;
   int64 received_bytes_;
   int64 resume_upload_call_count_;
 };
 
 // Mock DriveService that returns a failure at InitiateUpload().
 class MockDriveServiceNoConnectionAtInitiate : public DummyDriveService {
   // Returns error.
   virtual void InitiateUploadNewFile(
       const base::FilePath& drive_file_path,
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const InitiateUploadCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
   }
 
   virtual void InitiateUploadExistingFile(
       const base::FilePath& drive_file_path,
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const std::string& etag,
       const InitiateUploadCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
   }
 
   // Should not be used.
   virtual void ResumeUpload(
       UploadMode upload_mode,
       const base::FilePath& drive_file_path,
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const scoped_refptr<net::IOBuffer>& buf,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) OVERRIDE {
     NOTREACHED();
   }
 };
 
 // Mock DriveService that returns a failure at ResumeUpload().
 class MockDriveServiceNoConnectionAtResume : public DummyDriveService {
   // Succeeds and returns an upload location URL.
   virtual void InitiateUploadNewFile(
       const base::FilePath& drive_file_path,
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const InitiateUploadCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
   }
 
   virtual void InitiateUploadExistingFile(
       const base::FilePath& drive_file_path,
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const std::string& etag,
       const InitiateUploadCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadURL)));
   }
 
   // Returns error.
   virtual void ResumeUpload(
       UploadMode upload_mode,
       const base::FilePath& drive_file_path,
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const scoped_refptr<net::IOBuffer>& buf,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(GDATA_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<ResourceEntry>())));
   }
 };
 
 class DriveUploaderTest : public testing::Test {
  public:
   DriveUploaderTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(temp_dir_.Delete());
   }
 
  protected:
-  MessageLoopForUI message_loop_;
+  base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   base::ScopedTempDir temp_dir_;
 };
 
 }  // namespace
 
 TEST_F(DriveUploaderTest, UploadExisting0KB) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(CreateFileOfSpecifiedSize(temp_dir_.path(), 0,
@@ skipping 272 matching lines @@
       test_util::CreateCopyResultCallback(
           &error, &drive_path, &file_path, &resource_entry),
       google_apis::ProgressCallback());
   test_util::RunBlockingPoolTask();
 
   // Should return failure without doing any attempt to connect to the server.
   EXPECT_EQ(DRIVE_UPLOAD_ERROR_NOT_FOUND, error);
 }
 
 }  // namespace google_apis