Introduce ProfileInvalidationProvider wrapper for InvalidationService

chrome/browser/sync/test/integration/sync_test.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/test/integration/sync_test.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
-#include "chrome/browser/invalidation/invalidation_service_factory.h"
+#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/signin/profile_identity_provider.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/test/integration/fake_server_invalidation_service.h"
 #include "chrome/browser/sync/test/integration/p2p_invalidation_forwarder.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/single_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/google/core/browser/google_url_tracker.h"
+#include "components/invalidation/invalidation_service.h"
 #include "components/invalidation/invalidation_switches.h"
 #include "components/invalidation/p2p_invalidation_service.h"
 #include "components/invalidation/p2p_invalidator.h"
+#include "components/invalidation/profile_invalidation_provider.h"
+#include "components/keyed_service/core/keyed_service.h"
 #include "components/os_crypt/os_crypt.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_service.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/engine/sync_scheduler_impl.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/test/fake_server/fake_server.h"
 #include "sync/test/fake_server/fake_server_network_resources.h"
 #include "url/gurl.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
 #endif
 
 using content::BrowserThread;
-using invalidation::InvalidationServiceFactory;
 
 namespace switches {
 const char kPasswordFileForTest[] = "password-file-for-test";
 const char kSyncUserForTest[] = "sync-user-for-test";
 const char kSyncPasswordForTest[] = "sync-password-for-test";
 const char kSyncServerCommandLine[] = "sync-server-command-line";
 }
 
 namespace {
 
@@ skipping 40 matching lines @@
     base::WaitableEvent* done,
     net::URLRequestContextGetter* url_request_context_getter,
     const net::ProxyConfig& proxy_config) {
   net::ProxyService* proxy_service =
       url_request_context_getter->GetURLRequestContext()->proxy_service();
   proxy_service->ResetConfigService(
       new net::ProxyConfigServiceFixed(proxy_config));
   done->Signal();
 }
 
-KeyedService* BuildP2PInvalidationService(
+KeyedService* BuildFakeServerProfileInvalidationProvider(
+    content::BrowserContext* context) {
+  return new invalidation::ProfileInvalidationProvider(
+      scoped_ptr<invalidation::InvalidationService>(
+          new fake_server::FakeServerInvalidationService));
+}
+
+KeyedService* BuildP2PProfileInvalidationProvider(
     content::BrowserContext* context,
     syncer::P2PNotificationTarget notification_target) {
   Profile* profile = static_cast<Profile*>(context);
-  return new invalidation::P2PInvalidationService(
-      scoped_ptr<IdentityProvider>(new ProfileIdentityProvider(
-          SigninManagerFactory::GetForProfile(profile),
-          ProfileOAuth2TokenServiceFactory::GetForProfile(profile),
-          LoginUIServiceFactory::GetForProfile(profile))),
-      profile->GetRequestContext(),
-      notification_target);
+  return new invalidation::ProfileInvalidationProvider(
+      scoped_ptr<invalidation::InvalidationService>(
+          new invalidation::P2PInvalidationService(
+              scoped_ptr<IdentityProvider>(new ProfileIdentityProvider(
+                  SigninManagerFactory::GetForProfile(profile),
+                  ProfileOAuth2TokenServiceFactory::GetForProfile(profile),
+                  LoginUIServiceFactory::GetForProfile(profile))),
+              profile->GetRequestContext(),
+              notification_target)));
 }
 
-KeyedService* BuildSelfNotifyingP2PInvalidationService(
+KeyedService* BuildSelfNotifyingP2PProfileInvalidationProvider(
     content::BrowserContext* context) {
-  return BuildP2PInvalidationService(context, syncer::NOTIFY_ALL);
+  return BuildP2PProfileInvalidationProvider(context, syncer::NOTIFY_ALL);
 }
 
-KeyedService* BuildRealisticP2PInvalidationService(
+KeyedService* BuildRealisticP2PProfileInvalidationProvider(
     content::BrowserContext* context) {
-  return BuildP2PInvalidationService(context, syncer::NOTIFY_OTHERS);
+  return BuildP2PProfileInvalidationProvider(context, syncer::NOTIFY_OTHERS);
 }
 
 }  // namespace
 
 SyncTest::SyncTest(TestType test_type)
     : test_type_(test_type),
       server_type_(SERVER_TYPE_UNDECIDED),
       num_clients_(-1),
       use_verifier_(true),
       notifications_enabled_(true),
@@ skipping 218 matching lines @@
       GetProfile(index), Profile::EXPLICIT_ACCESS));
   ui_test_utils::WaitForTemplateURLServiceToLoad(
       TemplateURLServiceFactory::GetForProfile(GetProfile(index)));
 }
 
 void SyncTest::InitializeInvalidations(int index) {
   if (server_type_ == IN_PROCESS_FAKE_SERVER) {
     CHECK(fake_server_.get());
     fake_server::FakeServerInvalidationService* invalidation_service =
         static_cast<fake_server::FakeServerInvalidationService*>(
-            InvalidationServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-                GetProfile(index),
-                fake_server::FakeServerInvalidationService::Build));
+            static_cast<invalidation::ProfileInvalidationProvider*>(
+                invalidation::ProfileInvalidationProviderFactory::
+                    GetInstance()->SetTestingFactoryAndUse(
+                        GetProfile(index),
+                        BuildFakeServerProfileInvalidationProvider))->
+                            GetInvalidationService());
     fake_server_->AddObserver(invalidation_service);
     if (TestUsesSelfNotifications()) {
       invalidation_service->EnableSelfNotifications();
     } else {
       invalidation_service->DisableSelfNotifications();
     }
     fake_server_invalidation_services_[index] = invalidation_service;
   } else {
     invalidation::P2PInvalidationService* p2p_invalidation_service =
         static_cast<invalidation::P2PInvalidationService*>(
-            InvalidationServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-                GetProfile(index),
-                TestUsesSelfNotifications() ?
-                    BuildSelfNotifyingP2PInvalidationService
-                    : BuildRealisticP2PInvalidationService));
+            static_cast<invalidation::ProfileInvalidationProvider*>(
+                invalidation::ProfileInvalidationProviderFactory::
+                    GetInstance()->SetTestingFactoryAndUse(
+                        GetProfile(index),
+                        TestUsesSelfNotifications() ?
+                            BuildSelfNotifyingP2PProfileInvalidationProvider :
+                            BuildRealisticP2PProfileInvalidationProvider))->
+                                GetInvalidationService());
     p2p_invalidation_service->UpdateCredentials(username_, password_);
     // Start listening for and emitting notifications of commits.
     invalidation_forwarders_[index] =
         new P2PInvalidationForwarder(clients_[index]->service(),
                                      p2p_invalidation_service);
   }
 }
 
 bool SyncTest::SetupSync() {
   // Create sync profiles and clients if they haven't already been created.
@@ skipping 599 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SetProxyConfigCallback, &done,
                  make_scoped_refptr(context_getter), proxy_config));
   done.Wait();
 }
 
 fake_server::FakeServer* SyncTest::GetFakeServer() const {
   return fake_server_.get();
 }