sync: Make ProfileSyncService a ProfileKeyedService.

chrome/browser/sync/profile_sync_service_unittest.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
@@ skipping 74 matching lines @@
 
   void StartSyncServiceAndSetInitialSyncEnded(
       bool set_initial_sync_ended,
       bool issue_auth_token,
       bool synchronous_sync_configuration,
       bool sync_setup_completed,
       bool expect_create_dtm) {
     if (!service_.get()) {
       SigninManager* signin = new SigninManager();
       signin->SetAuthenticatedUsername("test");
-      service_.reset(new TestProfileSyncService(&factory_,
-                                                profile_.get(),
-                                                signin,
-                                                ProfileSyncService::AUTO_START,
-                                                true,
-                                                base::Closure()));
+      ProfileSyncComponentsFactoryMock* factory =
+          new ProfileSyncComponentsFactoryMock();
+      service_.reset(new TestProfileSyncService(
+          factory,
+          profile_.get(),
+          signin,
+          ProfileSyncService::AUTO_START,
+          true,
+          base::Closure()));
       if (!set_initial_sync_ended)
         service_->dont_set_initial_sync_ended_on_init();
       if (synchronous_sync_configuration)
         service_->set_synchronous_sync_configuration();
       if (!sync_setup_completed)
         profile_->GetPrefs()->SetBoolean(prefs::kSyncHasSetupCompleted, false);
 
       if (expect_create_dtm) {
         // Register the bookmark data type.
-        EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
+        EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
             WillOnce(ReturnNewDataTypeManager());
       } else {
-        EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).Times(0);
+        EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
+            Times(0);
       }
 
       if (issue_auth_token) {
         IssueTestTokens();
       }
       service_->Initialize();
     }
   }
 
   void IssueTestTokens() {
     profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kSyncService, "token1");
     profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kGaiaOAuth2LoginRefreshToken, "token2");
   }
 
   MessageLoop ui_loop_;
   // Needed by |service_|.
   content::TestBrowserThread ui_thread_;
   // Needed by DisableAndEnableSyncTemporarily test case.
   content::TestBrowserThread file_thread_;
   // Needed by |service| and |profile_|'s request context.
   content::TestBrowserThread io_thread_;
 
   scoped_ptr<TestProfileSyncService> service_;
   scoped_ptr<TestingProfile> profile_;
-  ProfileSyncComponentsFactoryMock factory_;
 };
 
 TEST_F(ProfileSyncServiceTest, InitialState) {
-  service_.reset(new TestProfileSyncService(&factory_,
-                                            profile_.get(),
-                                            new SigninManager(),
-                                            ProfileSyncService::MANUAL_START,
-                                            true,
-                                            base::Closure()));
+  service_.reset(new TestProfileSyncService(
+      new ProfileSyncComponentsFactoryMock(),
+      profile_.get(),
+      new SigninManager(),
+      ProfileSyncService::MANUAL_START,
+      true,
+      base::Closure()));
   EXPECT_TRUE(
       service_->sync_service_url().spec() ==
         ProfileSyncService::kSyncServerUrl ||
       service_->sync_service_url().spec() ==
         ProfileSyncService::kDevServerUrl);
 }
 
 TEST_F(ProfileSyncServiceTest, DisabledByPolicy) {
   profile_->GetTestingPrefService()->SetManagedPref(
       prefs::kSyncManaged,
       Value::CreateBooleanValue(true));
-  service_.reset(new TestProfileSyncService(&factory_,
-                                            profile_.get(),
-                                            new SigninManager(),
-                                            ProfileSyncService::MANUAL_START,
-                                            true,
-                                            base::Closure()));
+  service_.reset(new TestProfileSyncService(
+      new ProfileSyncComponentsFactoryMock(),
+      profile_.get(),
+      new SigninManager(),
+      ProfileSyncService::MANUAL_START,
+      true,
+      base::Closure()));
   service_->Initialize();
   EXPECT_TRUE(service_->IsManaged());
 }
 
 TEST_F(ProfileSyncServiceTest, AbortedByShutdown) {
   SigninManager* signin = new SigninManager();
   signin->SetAuthenticatedUsername("test");
-  service_.reset(new TestProfileSyncService(&factory_,
-                                            profile_.get(),
-                                            signin,
-                                            ProfileSyncService::AUTO_START,
-                                            true,
-                                            base::Closure()));
-  EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).Times(0);
-  EXPECT_CALL(factory_, CreateBookmarkSyncComponents(_, _)).Times(0);
+  ProfileSyncComponentsFactoryMock* factory =
+      new ProfileSyncComponentsFactoryMock();
+  service_.reset(new TestProfileSyncService(
+      factory,
+      profile_.get(),
+      signin,
+      ProfileSyncService::AUTO_START,
+      true,
+      base::Closure()));
+  EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).Times(0);
+  EXPECT_CALL(*factory, CreateBookmarkSyncComponents(_, _)).
+      Times(0);
   service_->RegisterDataTypeController(
-      new BookmarkDataTypeController(&factory_,
+      new BookmarkDataTypeController(service_->factory(),
                                      profile_.get(),
                                      service_.get()));
 
   service_->Initialize();
   service_.reset();
 }
 
 TEST_F(ProfileSyncServiceTest, DisableAndEnableSyncTemporarily) {
   SigninManager* signin = new SigninManager();
   signin->SetAuthenticatedUsername("test");
-  service_.reset(new TestProfileSyncService(&factory_,
-                                            profile_.get(),
-                                            signin,
-                                            ProfileSyncService::AUTO_START,
-                                            true,
-                                            base::Closure()));
+  ProfileSyncComponentsFactoryMock* factory =
+      new ProfileSyncComponentsFactoryMock();
+  service_.reset(new TestProfileSyncService(
+      factory,
+      profile_.get(),
+      signin,
+      ProfileSyncService::AUTO_START,
+      true,
+      base::Closure()));
   // Register the bookmark data type.
-  EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
+  EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
       WillRepeatedly(ReturnNewDataTypeManager());
 
   IssueTestTokens();
 
   service_->Initialize();
   EXPECT_TRUE(service_->sync_initialized());
   EXPECT_TRUE(service_->GetBackendForTest() != NULL);
   EXPECT_FALSE(profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart));
 
   service_->StopAndSuppress();
@@ skipping 143 matching lines @@
   // The backend is not ready.  Ensure the PSS knows this.
   EXPECT_FALSE(service_->sync_initialized());
 
   // Ensure we will be prepared to initialize a fresh DB next time.
   EXPECT_FALSE(service_->HasSyncSetupCompleted());
 }
 
 }  // namespace
 
 }  // namespace browser_sync