Make push messaging not create InvalidationService for login and guest

chrome/browser/sync/profile_sync_service_preference_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 <map>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
 #include "chrome/browser/invalidation/invalidation_service_factory.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/glue/generic_change_processor.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/ui_data_type_controller.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "sync/api/attachments/fake_attachment_service.h"
 #include "sync/api/sync_data.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/change_record.h"
 #include "sync/internal_api/public/data_type_debug_info_listener.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONReader;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::SharedChangeProcessor;
 using browser_sync::UIDataTypeController;
 using syncer::ChangeRecord;
 using testing::Invoke;
 using testing::Return;
 using testing::_;
 
+namespace {
+const char kTestProfileName[] = "test-profile";
+}
+
 typedef std::map<const std::string, const base::Value*> PreferenceValues;
 
 ACTION_P(CreateAndSaveChangeProcessor, change_processor) {
   syncer::UserShare* user_share = arg0->GetUserShare();
   *change_processor = new GenericChangeProcessor(
       arg1,
       arg2,
       arg3,
       user_share,
       syncer::FakeAttachmentService::CreateForTest());
@@ skipping 42 matching lines @@
   // DataTypeDebugInfoListener implementation.
   virtual void OnDataTypeConfigureComplete(
       const std::vector<syncer::DataTypeConfigurationStats>&
           configuration_stats) OVERRIDE {
     ASSERT_EQ(1u, configuration_stats.size());
     association_stats_ = configuration_stats[0].association_stats;
   }
 
  protected:
   ProfileSyncServicePreferenceTest()
-      : debug_ptr_factory_(this),
+      : profile_manager_(TestingBrowserProcess::GetGlobal()),
+        debug_ptr_factory_(this),
         example_url0_("http://example.com/0"),
         example_url1_("http://example.com/1"),
         example_url2_("http://example.com/2"),
         not_synced_preference_name_("nonsense_pref_name"),
         not_synced_preference_default_value_("default"),
         non_default_charset_value_("foo") {}
 
   virtual void SetUp() {
     AbstractProfileSyncServiceTest::SetUp();
-    TestingProfile::Builder builder;
-    builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
-                              BuildAutoIssuingFakeProfileOAuth2TokenService);
-    profile_ = builder.Build().Pass();
+    ASSERT_TRUE(profile_manager_.SetUp());
+    TestingProfile::TestingFactories testing_factories;
+    testing_factories.push_back(std::make_pair(
+        ProfileOAuth2TokenServiceFactory::GetInstance(),
+        BuildAutoIssuingFakeProfileOAuth2TokenService));
+    profile_ = profile_manager_.CreateTestingProfile(
+        kTestProfileName,
+        scoped_ptr<PrefServiceSyncable>(),
+        base::UTF8ToUTF16(kTestProfileName),
+        0,
+        std::string(),
+        testing_factories);
     invalidation::InvalidationServiceFactory::GetInstance()->SetTestingFactory(
-        profile_.get(), invalidation::FakeInvalidationService::Build);
+        profile_, invalidation::FakeInvalidationService::Build);
     prefs_ = profile_->GetTestingPrefService();
 
     prefs_->registry()->RegisterStringPref(
         not_synced_preference_name_.c_str(),
         not_synced_preference_default_value_,
         user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   }
 
   virtual void TearDown() {
-    profile_.reset();
+    profile_ = NULL;
+    profile_manager_.DeleteTestingProfile(kTestProfileName);
     AbstractProfileSyncServiceTest::TearDown();
   }
 
   int GetSyncPreferenceCount() {
     syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode node(&trans);
     if (node.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::PREFERENCES)) !=
         syncer::BaseNode::INIT_OK)
       return 0;
     return node.GetTotalNodeCount() - 1;
   }
 
   bool StartSyncService(const base::Closure& callback,
                         bool will_fail_association) {
     if (sync_service_)
       return false;
 
     SigninManagerBase* signin =
-         SigninManagerFactory::GetForProfile(profile_.get());
+         SigninManagerFactory::GetForProfile(profile_);
     signin->SetAuthenticatedUsername("test");
-    sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(
-        profile_.get(), callback);
+    sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(profile_,
+                                                                    callback);
     pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>(
         prefs_->GetSyncableService(syncer::PREFERENCES));
     if (!pref_sync_service_)
       return false;
     ProfileSyncComponentsFactoryMock* components =
         sync_service_->components_factory_mock();
     EXPECT_CALL(*components, GetSyncableServiceForType(syncer::PREFERENCES)).
         WillOnce(Return(pref_sync_service_->AsWeakPtr()));
 
     EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _, _)).
         WillOnce(ReturnNewDataTypeManagerWithDebugListener(
                      syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
     dtc_ = new UIDataTypeController(base::MessageLoopProxy::current(),
                                     base::Closure(),
                                     syncer::PREFERENCES,
                                     components,
-                                    profile_.get(),
+                                    profile_,
                                     sync_service_);
     EXPECT_CALL(*components, CreateSharedChangeProcessor()).
         WillOnce(Return(new SharedChangeProcessor()));
     EXPECT_CALL(*components, CreateGenericChangeProcessor(_, _, _, _)).
         WillOnce(CreateAndSaveChangeProcessor(
                      &change_processor_));
     sync_service_->RegisterDataTypeController(dtc_);
-    ProfileOAuth2TokenServiceFactory::GetForProfile(profile_.get())
+    ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
         ->UpdateCredentials("test", "oauth2_login_token");
 
     sync_service_->Initialize();
     base::MessageLoop::current()->Run();
 
     // It's possible this test triggered an unrecoverable error, in which case
     // we can't get the preference count.
     if (sync_service_->ShouldPushChanges()) {
         EXPECT_EQ(GetSyncPreferenceCount(),
                   association_stats_.num_sync_items_after_association);
@@ skipping 58 matching lines @@
 
   // Returns whether a given preference name is a new name of a migrated
   // preference. Exposed here for testing.
   static bool IsMigratedPreference(const char* preference_name) {
     return PrefModelAssociator::IsMigratedPreference(preference_name);
   }
   static bool IsOldMigratedPreference(const char* old_preference_name) {
     return PrefModelAssociator::IsOldMigratedPreference(old_preference_name);
   }
 
-  scoped_ptr<TestingProfile> profile_;
+  TestingProfileManager profile_manager_;
+  TestingProfile* profile_;
   TestingPrefServiceSyncable* prefs_;
 
   UIDataTypeController* dtc_;
   PrefModelAssociator* pref_sync_service_;
   GenericChangeProcessor* change_processor_;
   syncer::DataTypeAssociationStats association_stats_;
   base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
 
   std::string example_url0_;
   std::string example_url1_;
@@ skipping 603 matching lines @@
   EXPECT_FALSE(pref->IsDefaultValue());
   // There should be no synced value.
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
   // Switch kHomePage back to unmanaged.
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
   // The original value should be picked up.
   EXPECT_TRUE(pref->IsDefaultValue());
   // There should still be no synced value.
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
 }