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

chrome/browser/chromeos/drive/drive_file_system_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/chromeos/drive/drive_file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 
 const int64 kLotsOfSpace = kMinFreeSpace * 10;
 
 struct SearchResultPair {
   const char* path;
   const bool is_directory;
 };
 
 // Callback to DriveFileSystem::Search used in ContentSearch tests.
 // Verifies returned vector of results and next feed url.
-void DriveSearchCallback(
-    MessageLoop* message_loop,
-    const SearchResultPair* expected_results,
-    size_t expected_results_size,
-    const GURL& expected_next_feed,
-    FileError error,
-    const GURL& next_feed,
-    scoped_ptr<std::vector<SearchResultInfo> > results) {
+void DriveSearchCallback(base::MessageLoop* message_loop,
+                         const SearchResultPair* expected_results,
+                         size_t expected_results_size,
+                         const GURL& expected_next_feed,
+                         FileError error,
+                         const GURL& next_feed,
+                         scoped_ptr<std::vector<SearchResultInfo> > results) {
   ASSERT_TRUE(results);
   ASSERT_EQ(expected_results_size, results->size());
 
   for (size_t i = 0; i < results->size(); i++) {
     EXPECT_EQ(base::FilePath(expected_results[i].path),
               results->at(i).path);
     EXPECT_EQ(expected_results[i].is_directory,
               results->at(i).entry_proto.file_info().is_directory());
   }
 
   EXPECT_EQ(expected_next_feed, next_feed);
 
   message_loop->Quit();
 }
 
 // Counts the number of files (not directories) in |entries|.
 int CountFiles(const DriveEntryProtoVector& entries) {
   int num_files = 0;
   for (size_t i = 0; i < entries.size(); ++i) {
     if (!entries[i].file_info().is_directory())
       ++num_files;
   }
   return num_files;
 }
 
 // Counts the number of invocation, and if it increased up to |expected_counter|
 // quits the current message loop.
-void AsyncInitializationCallback(
-    int* counter, int expected_counter, MessageLoop* message_loop,
-    FileError error, scoped_ptr<DriveEntryProto> entry) {
+void AsyncInitializationCallback(int* counter,
+                                 int expected_counter,
+                                 base::MessageLoop* message_loop,
+                                 FileError error,
+                                 scoped_ptr<DriveEntryProto> entry) {
   if (error != FILE_ERROR_OK || !entry) {
     // If we hit an error case, quit the message loop immediately.
     // Then the expectation in the test case can find it because the actual
     // value of |counter| is different from the expected one.
     message_loop->Quit();
     return;
   }
 
   (*counter)++;
   if (*counter >= expected_counter)
@@ skipping 331 matching lines @@
 
     std::string edit_url, resource_id;
     EXPECT_TRUE(dict_value->GetString("url", &edit_url));
     EXPECT_TRUE(dict_value->GetString("resource_id", &resource_id));
 
     EXPECT_EQ(entry_proto.file_specific_info().alternate_url(),
               edit_url);
     EXPECT_EQ(entry_proto.resource_id(), resource_id);
   }
 
-  MessageLoopForUI message_loop_;
+  base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
 
   scoped_ptr<DriveCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<DriveFileSystem> file_system_;
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<DriveWebAppsRegistry> drive_webapps_registry_;
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
@@ skipping 1737 matching lines @@
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_FALSE(cache_entry.is_mounted());
 }
 
 }   // namespace drive