Correctly integrate StoragePartition into TestingProfile.

chrome/browser/sync_file_system/sync_file_system_service_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/sync_file_system/local_file_sync_service.h"
 #include "chrome/browser/sync_file_system/mock_remote_file_sync_service.h"
 #include "chrome/browser/sync_file_system/sync_event_observer.h"
 #include "chrome/browser/sync_file_system/sync_file_system_service.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/syncable/canned_syncable_file_system.h"
 #include "webkit/browser/fileapi/syncable/local_file_sync_context.h"
 #include "webkit/browser/fileapi/syncable/mock_sync_status_observer.h"
 #include "webkit/browser/fileapi/syncable/sync_callbacks.h"
 #include "webkit/browser/fileapi/syncable/sync_file_metadata.h"
 #include "webkit/browser/fileapi/syncable/sync_status_code.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 
+using content::BrowserThread;
 using fileapi::FileSystemURL;
 using fileapi::FileSystemURLSet;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
 using ::testing::StrictMock;
 using ::testing::_;
 
@@ skipping 18 matching lines @@
                         typename AssignTrait<R>::ArgumentType value) {
   DCHECK(status_out);
   DCHECK(value_out);
   DCHECK(run_loop);
   *status_out = status;
   *value_out = value;
   run_loop->Quit();
 }
 
 // This is called on IO thread.
-void VerifyFileError(base::WaitableEvent* event,
+void VerifyFileError(base::RunLoop* run_loop,
                      base::PlatformFileError error) {
-  DCHECK(event);
+  DCHECK(run_loop);
   EXPECT_EQ(base::PLATFORM_FILE_OK, error);
-  event->Signal();
+  run_loop->Quit();
 }
 
 }  // namespace
 
 class MockSyncEventObserver : public SyncEventObserver {
  public:
   MockSyncEventObserver() {}
   virtual ~MockSyncEventObserver() {}
 
   MOCK_METHOD3(OnSyncStateUpdated,
@@ skipping 24 matching lines @@
       FROM_HERE, base::Bind(arg4, status));
 }
 
 ACTION_P2(MockSyncFileCallback, status, url) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE, base::Bind(arg0, status, url));
 }
 
 class SyncFileSystemServiceTest : public testing::Test {
  protected:
-  SyncFileSystemServiceTest() {}
-  virtual ~SyncFileSystemServiceTest() {}
+  SyncFileSystemServiceTest()
+      : thread_bundle_(content::TestBrowserThreadBundle::REAL_FILE_THREAD |
+                       content::TestBrowserThreadBundle::REAL_IO_THREAD) {}
 
   virtual void SetUp() OVERRIDE {
-    thread_helper_.SetUp();
-
     file_system_.reset(new CannedSyncableFileSystem(
         GURL(kOrigin),
-        thread_helper_.io_task_runner(),
-        thread_helper_.file_task_runner()));
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
 
     local_service_ = new LocalFileSyncService(&profile_);
     remote_service_ = new StrictMock<MockRemoteFileSyncService>;
     sync_service_.reset(new SyncFileSystemService(&profile_));
 
     EXPECT_CALL(*mock_remote_service(),
                 AddServiceObserver(sync_service_.get())).Times(1);
     EXPECT_CALL(*mock_remote_service(),
                 AddFileStatusObserver(sync_service_.get())).Times(1);
     EXPECT_CALL(*mock_remote_service(),
                 GetLocalChangeProcessor())
         .WillOnce(Return(&local_change_processor_));
     EXPECT_CALL(*mock_remote_service(),
                 SetRemoteChangeProcessor(local_service_)).Times(1);
 
     sync_service_->Initialize(
         make_scoped_ptr(local_service_),
         scoped_ptr<RemoteFileSyncService>(remote_service_));
 
     // Disable auto sync by default.
     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(false)).Times(1);
     sync_service_->SetSyncEnabledForTesting(false);
 
     file_system_->SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     sync_service_->Shutdown();
-
     file_system_->TearDown();
     RevokeSyncableFileSystem();
-    thread_helper_.TearDown();
+    content::RunAllPendingInMessageLoop(BrowserThread::FILE);
   }
 
   void InitializeApp() {
     base::RunLoop run_loop;
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
     EXPECT_CALL(*mock_remote_service(),
                 RegisterOriginForTrackingChanges(GURL(kOrigin), _)).Times(1);
 
     sync_service_->InitializeForApp(
@@ skipping 63 matching lines @@
     return &local_change_processor_;
   }
 
   void EnableSync() {
     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(true)).Times(1);
     sync_service_->SetSyncEnabledForTesting(true);
   }
 
   ScopedEnableSyncFSDirectoryOperation enable_directory_operation_;
 
-  MultiThreadTestHelper thread_helper_;
+  content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   scoped_ptr<CannedSyncableFileSystem> file_system_;
 
   // Their ownerships are transferred to SyncFileSystemService.
   LocalFileSyncService* local_service_;
   StrictMock<MockRemoteFileSyncService>* remote_service_;
   StrictMock<MockLocalChangeProcessor> local_change_processor_;
 
   scoped_ptr<SyncFileSystemService> sync_service_;
 };
@@ skipping 134 matching lines @@
   // We might also see an activity for local sync as we're going to make
   // a local write operation on kFile.
   EXPECT_CALL(*mock_local_change_processor(),
               ApplyLocalChange(_, _, _, kFile, _))
       .Times(AnyNumber());
 
   // This should trigger a remote sync.
   mock_remote_service()->NotifyRemoteChangeQueueUpdated(1);
 
   // Start a local operation on the same file (to make it BUSY).
-  base::WaitableEvent event(false, false);
-  thread_helper_.io_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&CannedSyncableFileSystem::DoCreateFile,
-                            base::Unretained(file_system_.get()),
-                            kFile, base::Bind(&VerifyFileError, &event)));
+  base::RunLoop verify_file_error_run_loop;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&CannedSyncableFileSystem::DoCreateFile,
+                 base::Unretained(file_system_.get()),
+                 kFile, base::Bind(&VerifyFileError,
+                                   &verify_file_error_run_loop)));
 
   run_loop.Run();
 
   mock_remote_service()->NotifyRemoteChangeQueueUpdated(0);
 
-  event.Wait();
+  verify_file_error_run_loop.Run();
 }
 
 TEST_F(SyncFileSystemServiceTest, GetFileSyncStatus) {
   InitializeApp();
 
   const FileSystemURL kFile(file_system_->URL("foo"));
 
   SyncStatusCode status;
   SyncFileStatus sync_file_status;
 
@@ skipping 69 matching lines @@
         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
   }
 }
 
 }  // namespace sync_file_system