Correctly integrate StoragePartition into TestingProfile.

chrome/browser/sync/glue/sync_backend_host_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/sync/glue/sync_backend_host.h"
 
 #include <cstddef>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "chrome/browser/invalidation/invalidator_storage.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/sync/glue/device_info.h"
 #include "chrome/browser/sync/glue/synced_device_tracker.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_service.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/test/fake_sync_manager.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/notifier/invalidator_state.h"
 #include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "sync/protocol/encryption.pb.h"
@@ skipping 93 matching lines @@
  private:
   syncer::ModelTypeSet initial_sync_ended_types_;
   syncer::ModelTypeSet progress_marker_types_;
   syncer::ModelTypeSet configure_fail_types_;
   FakeSyncManager* fake_manager_;
 };
 
 class SyncBackendHostTest : public testing::Test {
  protected:
   SyncBackendHostTest()
-      : ui_thread_(BrowserThread::UI, &ui_loop_),
-        db_thread_(BrowserThread::DB),
-        file_thread_(BrowserThread::FILE),
-        io_thread_(BrowserThread::IO),
+      : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD),
         fake_manager_(NULL) {}
 
   virtual ~SyncBackendHostTest() {}
 
   virtual void SetUp() OVERRIDE {
-    io_thread_.StartIOThread();
-    db_thread_.Start();
-    file_thread_.Start();
     profile_.reset(new TestingProfile());
-    profile_->CreateRequestContext();
     sync_prefs_.reset(new SyncPrefs(profile_->GetPrefs()));
     backend_.reset(new SyncBackendHost(
         profile_->GetDebugName(),
         profile_.get(),
         sync_prefs_->AsWeakPtr()));
     credentials_.email = "user@example.com";
     credentials_.sync_token = "sync_token";
 
     // These types are always implicitly enabled.
     enabled_types_.PutAll(syncer::ControlTypes());
@@ skipping 13 matching lines @@
   virtual void TearDown() OVERRIDE {
     if (backend_) {
       backend_->StopSyncingForShutdown();
       backend_->Shutdown(false);
     }
     backend_.reset();
     sync_prefs_.reset();
     profile_.reset();
     // Pump messages posted by the sync thread (which may end up
     // posting on the IO thread).
-    ui_loop_.RunUntilIdle();
-    io_thread_.Stop();
-    file_thread_.Stop();
-    db_thread_.Stop();
+    base::RunLoop().RunUntilIdle();
+    content::RunAllPendingInMessageLoop(BrowserThread::IO);
     // Pump any messages posted by the IO thread.
-    ui_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   // Synchronously initializes the backend.
   void InitializeBackend(bool expect_success) {
     EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, expect_success)).
         WillOnce(InvokeWithoutArgs(QuitMessageLoop));
     backend_->Initialize(&mock_frontend_,
                          scoped_ptr<base::Thread>(),
                          syncer::WeakHandle<syncer::JsEventHandler>(),
                          GURL(std::string()),
                          credentials_,
                          true,
                          &fake_manager_factory_,
                          &handler_,
                          NULL);
-    ui_loop_.PostDelayedTask(FROM_HERE,
-        ui_loop_.QuitClosure(), TestTimeouts::action_timeout());
-    ui_loop_.Run();
+    base::RunLoop run_loop;
+    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
+                                   run_loop.QuitClosure(),
+                                   TestTimeouts::action_timeout());
+    run_loop.Run();
     // |fake_manager_factory_|'s fake_manager() is set on the sync
     // thread, but we can rely on the message loop barriers to
     // guarantee that we see the updated value.
     fake_manager_ = fake_manager_factory_.fake_manager();
     DCHECK(fake_manager_);
   }
 
   // Synchronously configures the backend's datatypes.
   void ConfigureDataTypes(syncer::ModelTypeSet types_to_add,
                           syncer::ModelTypeSet types_to_remove) {
     BackendDataTypeConfigurer::DataTypeConfigStateMap config_state_map;
     BackendDataTypeConfigurer::SetDataTypesState(
         BackendDataTypeConfigurer::CONFIGURE_ACTIVE,
         types_to_add,
         &config_state_map);
     BackendDataTypeConfigurer::SetDataTypesState(
         BackendDataTypeConfigurer::DISABLED,
         types_to_remove, &config_state_map);
 
     types_to_add.PutAll(syncer::ControlTypes());
     backend_->ConfigureDataTypes(
         syncer::CONFIGURE_REASON_RECONFIGURATION,
         config_state_map,
         base::Bind(&SyncBackendHostTest::DownloadReady,
                    base::Unretained(this)),
         base::Bind(&SyncBackendHostTest::OnDownloadRetry,
                    base::Unretained(this)));
-    ui_loop_.PostDelayedTask(FROM_HERE,
-        ui_loop_.QuitClosure(), TestTimeouts::action_timeout());
-    ui_loop_.Run();
+    base::RunLoop run_loop;
+    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
+                                   run_loop.QuitClosure(),
+                                   TestTimeouts::action_timeout());
+    run_loop.Run();
   }
 
   void IssueRefreshRequest(syncer::ModelTypeSet types) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     syncer::ModelTypeInvalidationMap invalidation_map(
         ModelTypeSetToInvalidationMap(types, std::string()));
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
         content::Source<Profile>(profile_.get()),
         content::Details<syncer::ModelTypeInvalidationMap>(
             &invalidation_map));
   }
 
  protected:
   void DownloadReady(syncer::ModelTypeSet succeeded_types,
                      syncer::ModelTypeSet failed_types) {
     base::MessageLoop::current()->Quit();
   }
 
   void OnDownloadRetry() {
     NOTIMPLEMENTED();
   }
 
-  base::MessageLoop ui_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread db_thread_;
-  content::TestBrowserThread file_thread_;
-  content::TestBrowserThread io_thread_;
+  content::TestBrowserThreadBundle thread_bundle_;
   StrictMock<MockSyncFrontend> mock_frontend_;
   syncer::SyncCredentials credentials_;
   syncer::TestUnrecoverableErrorHandler handler_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<SyncPrefs> sync_prefs_;
   scoped_ptr<SyncBackendHost> backend_;
   FakeSyncManager* fake_manager_;
   FakeSyncManagerFactory fake_manager_factory_;
   syncer::ModelTypeSet enabled_types_;
 };
@@ skipping 418 matching lines @@
 TEST_F(SyncBackendHostTest, DownloadControlTypesRestart) {
   sync_prefs_->SetSyncSetupCompleted();
   InitializeBackend(true);
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE,
             fake_manager_->GetAndResetConfigureReason());
 }
 
 }  // namespace
 
 }  // namespace browser_sync