Introduce ProfileInvalidationProvider wrapper for InvalidationService

chrome/browser/policy/cloud/cloud_policy_browsertest.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 "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
-#include "chrome/browser/invalidation/invalidation_service_factory.h"
+#include "chrome/browser/invalidation/profile_invalidation_provider.h"
+#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/policy/test/local_policy_test_server.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
+#include "components/invalidation/invalidation_service.h"
+#include "components/keyed_service/core/keyed_service.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_service.h"
 #include "components/policy/core/common/policy_switches.h"
 #include "components/policy/core/common/policy_test_utils.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 20 matching lines @@
 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
 #include "components/signin/core/browser/signin_manager.h"
 #endif
 
 using testing::AnyNumber;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::Return;
 using testing::_;
 
+namespace content {
+class BrowserContext;
+}
+
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
+KeyedService* BuildFakeProfileInvalidationProvider(
+    content::BrowserContext* context) {
+  return new invalidation::ProfileInvalidationProvider(
+      scoped_ptr<invalidation::InvalidationService>(
+          new invalidation::FakeInvalidationService));
+}
+
 const char* GetTestUser() {
 #if defined(OS_CHROMEOS)
   return chromeos::UserManager::kStubUser;
 #else
   return "user@example.com";
 #endif
 }
 
 std::string GetEmptyPolicy() {
   const char kEmptyPolicy[] =
@@ skipping 85 matching lines @@
     ASSERT_NO_FATAL_FAILURE(SetServerPolicy(GetEmptyPolicy()));
 
     test_server_.reset(new LocalPolicyTestServer(policy_file_path()));
     ASSERT_TRUE(test_server_->Start());
 
     std::string url = test_server_->GetServiceURL().spec();
 
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     command_line->AppendSwitchASCII(switches::kDeviceManagementUrl, url);
 
-    invalidation::InvalidationServiceFactory::GetInstance()->
-        RegisterTestingFactory(invalidation::FakeInvalidationService::Build);
+    invalidation::ProfileInvalidationProviderFactory::GetInstance()->
+        RegisterTestingFactory(BuildFakeProfileInvalidationProvider);
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     ASSERT_TRUE(PolicyServiceIsEmpty(g_browser_process->policy_service()))
         << "Pre-existing policies in this machine will make this test fail.";
 
     BrowserPolicyConnector* connector =
         g_browser_process->browser_policy_connector();
     connector->ScheduleServiceInitialization(0);
 
@@ skipping 59 matching lines @@
   }
 
   PolicyService* GetPolicyService() {
     ProfilePolicyConnector* profile_connector =
         ProfilePolicyConnectorFactory::GetForProfile(browser()->profile());
     return profile_connector->policy_service();
   }
 
   invalidation::FakeInvalidationService* GetInvalidationService() {
     return static_cast<invalidation::FakeInvalidationService*>(
-        invalidation::InvalidationServiceFactory::GetForProfile(
-            browser()->profile()));
+        static_cast<invalidation::ProfileInvalidationProvider*>(
+            invalidation::ProfileInvalidationProviderFactory::GetInstance()->
+                GetForProfile(browser()->profile()))->GetInvalidationService());
   }
 
   void SetServerPolicy(const std::string& policy) {
     int result = base::WriteFile(policy_file_path(), policy.data(),
                                  policy.size());
     ASSERT_EQ(static_cast<int>(policy.size()), result);
   }
 
   base::FilePath policy_file_path() const {
     return temp_dir_.path().AppendASCII("policy.json");
@@ skipping 173 matching lines @@
 
   // They should now serialize to the same bytes.
   std::string chrome_settings_serialized;
   std::string cloud_policy_serialized;
   ASSERT_TRUE(chrome_settings.SerializeToString(&chrome_settings_serialized));
   ASSERT_TRUE(cloud_policy.SerializeToString(&cloud_policy_serialized));
   EXPECT_EQ(chrome_settings_serialized, cloud_policy_serialized);
 }
 
 }  // namespace policy