Use TestBrowserThreadBundle instead of TestBrowserThread in sync code.

chrome/browser/sync/glue/sync_backend_registrar_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_registrar.h"
 
 #include "chrome/browser/sync/glue/ui_model_worker.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync_driver/change_processor_mock.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_user_share.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
 namespace {
 
 using ::testing::_;
@@ skipping 29 matching lines @@
                                  test_user_share_.user_share());
     syncer::ModelSafeRoutingInfo expected_routing_info;
     expected_routing_info[AUTOFILL] = syncer::GROUP_DB;
     ExpectRoutingInfo(registrar_.get(), expected_routing_info);
     ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet(AUTOFILL));
     TriggerChanges(registrar_.get(), AUTOFILL);
     done->Signal();
   }
 
  protected:
-  SyncBackendRegistrarTest() :
-    sync_thread_(NULL),
-    ui_thread_(BrowserThread::UI, &ui_loop_),
-    db_thread_(BrowserThread::DB),
-    file_thread_(BrowserThread::FILE),
-    io_thread_(BrowserThread::IO) {}
+  SyncBackendRegistrarTest()
+      : sync_thread_(NULL),
+        thread_bundle_(content::TestBrowserThreadBundle::REAL_DB_THREAD |
+                       content::TestBrowserThreadBundle::REAL_FILE_THREAD |
+                       content::TestBrowserThreadBundle::REAL_IO_THREAD) {}
 
   virtual ~SyncBackendRegistrarTest() {}
 
   virtual void SetUp() {
-    db_thread_.Start();
-    file_thread_.Start();
-    io_thread_.Start();
     test_user_share_.SetUp();
     registrar_.reset(new SyncBackendRegistrar("test", &profile_,
                                               scoped_ptr<base::Thread>()));
     sync_thread_ = registrar_->sync_thread();
   }
 
   virtual void TearDown() {
     registrar_->RequestWorkerStopOnUIThread();
     test_user_share_.TearDown();
     sync_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&SyncBackendRegistrar::Shutdown,
                    base::Unretained(registrar_.release())));
     sync_thread_->message_loop()->RunUntilIdle();
-    io_thread_.Stop();
-    file_thread_.Stop();
-    db_thread_.Stop();
   }
 
   void ExpectRoutingInfo(
       SyncBackendRegistrar* registrar,
       const syncer::ModelSafeRoutingInfo& expected_routing_info) {
     syncer::ModelSafeRoutingInfo routing_info;
     registrar->GetModelSafeRoutingInfo(&routing_info);
     EXPECT_EQ(expected_routing_info, routing_info);
   }
 
   void ExpectHasProcessorsForTypes(const SyncBackendRegistrar& registrar,
                                    ModelTypeSet types) {
     for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
       ModelType model_type = ModelTypeFromInt(i);
       EXPECT_EQ(types.Has(model_type),
                 registrar_->IsTypeActivatedForTest(model_type));
     }
   }
 
-  base::MessageLoop ui_loop_;
   syncer::TestUserShare test_user_share_;
   TestingProfile profile_;
   scoped_ptr<SyncBackendRegistrar> registrar_;
 
   base::Thread* sync_thread_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread db_thread_;
-  content::TestBrowserThread file_thread_;
-  content::TestBrowserThread io_thread_;
+  content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(SyncBackendRegistrarTest, ConstructorEmpty) {
   registrar_->SetInitialTypes(ModelTypeSet());
   EXPECT_FALSE(registrar_->IsNigoriEnabled());
   {
     std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
     registrar_->GetWorkers(&workers);
     EXPECT_EQ(4u, workers.size());
   }
@@ skipping 133 matching lines @@
   ExpectRoutingInfo(registrar_.get(), syncer::ModelSafeRoutingInfo());
   ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet());
 
   // Should do nothing.
   TriggerChanges(registrar_.get(), AUTOFILL);
 }
 
 }  // namespace
 
 }  // namespace browser_sync