Implement device-local account policy pushing

chrome/browser/chromeos/policy/affiliated_invalidation_service_provider_impl_unittest.cc

 // Copyright 2015 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/chromeos/policy/affiliated_invalidation_service_provider.h"
+#include "chrome/browser/chromeos/policy/affiliated_invalidation_service_provider_impl.h"
 
 #include <string>
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
@@ skipping 45 matching lines @@
   MockConsumer();
   ~MockConsumer() override;
 
   MOCK_METHOD1(OnInvalidationServiceSet,
                void(invalidation::InvalidationService*));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockConsumer);
 };
 
-class AffiliatedInvalidationServiceProviderTest : public testing::Test {
+class AffiliatedInvalidationServiceProviderImplTest : public testing::Test {
  public:
-  AffiliatedInvalidationServiceProviderTest();
+  AffiliatedInvalidationServiceProviderImplTest();
 
   // testing::Test:
   virtual void SetUp() override;
   virtual void TearDown() override;
 
   // Ownership is not passed. The Profile is owned by the global ProfileManager.
   Profile* LogInAndReturnProfile(const std::string& user_id);
 
   // Logs in as an affiliated user and indicates that the per-profile
   // invalidation service for this user connected. Verifies that this
@@ skipping 14 matching lines @@
   // Indicates that the logged-in user's per-profile invalidation service
   // disconnected. Verifies that the |consumer_| is informed about this and a
   // device-global invalidation service is created.
   void DisconnectPerProfileInvalidationService();
 
   invalidation::FakeInvalidationService* GetProfileInvalidationService(
       Profile* profile,
       bool create);
 
  protected:
-  scoped_ptr<AffiliatedInvalidationServiceProvider> provider_;
+  scoped_ptr<AffiliatedInvalidationServiceProviderImpl> provider_;
   StrictMock<MockConsumer> consumer_;
   invalidation::TiclInvalidationService* device_invalidation_service_;
   invalidation::FakeInvalidationService* profile_invalidation_service_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   chromeos::FakeUserManager* fake_user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   ScopedStubEnterpriseInstallAttributes install_attributes_;
   scoped_ptr<chromeos::ScopedTestDeviceSettingsService>
       test_device_settings_service_;
   scoped_ptr<chromeos::ScopedTestCrosSettings> test_cros_settings_;
   TestingProfileManager profile_manager_;
 };
 
 MockConsumer::MockConsumer() {
 }
 
 MockConsumer::~MockConsumer() {
 }
 
-AffiliatedInvalidationServiceProviderTest::
-AffiliatedInvalidationServiceProviderTest()
+AffiliatedInvalidationServiceProviderImplTest::
+AffiliatedInvalidationServiceProviderImplTest()
     : device_invalidation_service_(nullptr),
       profile_invalidation_service_(nullptr),
       fake_user_manager_(new chromeos::FakeUserManager),
       user_manager_enabler_(fake_user_manager_),
       install_attributes_("example.com",
                           "user@example.com",
                           "device_id",
                           DEVICE_MODE_ENTERPRISE),
       profile_manager_(TestingBrowserProcess::GetGlobal()) {
 }
 
-void AffiliatedInvalidationServiceProviderTest::SetUp() {
+void AffiliatedInvalidationServiceProviderImplTest::SetUp() {
   chromeos::SystemSaltGetter::Initialize();
   chromeos::DBusThreadManager::Initialize();
   chromeos::DeviceOAuth2TokenServiceFactory::Initialize();
   ASSERT_TRUE(profile_manager_.SetUp());
 
   test_device_settings_service_.reset(new
       chromeos::ScopedTestDeviceSettingsService);
   test_cros_settings_.reset(new chromeos::ScopedTestCrosSettings);
 
   invalidation::ProfileInvalidationProviderFactory::GetInstance()->
       RegisterTestingFactory(BuildProfileInvalidationProvider);
 
-  provider_.reset(new AffiliatedInvalidationServiceProvider);
+  provider_.reset(new AffiliatedInvalidationServiceProviderImpl);
 }
 
-void AffiliatedInvalidationServiceProviderTest::TearDown() {
+void AffiliatedInvalidationServiceProviderImplTest::TearDown() {
   provider_->Shutdown();
   provider_.reset();
 
   invalidation::ProfileInvalidationProviderFactory::GetInstance()->
       RegisterTestingFactory(nullptr);
   chromeos::DeviceOAuth2TokenServiceFactory::Shutdown();
   chromeos::DBusThreadManager::Shutdown();
   chromeos::SystemSaltGetter::Shutdown();
 }
 
-Profile* AffiliatedInvalidationServiceProviderTest::LogInAndReturnProfile(
+Profile* AffiliatedInvalidationServiceProviderImplTest::LogInAndReturnProfile(
     const std::string& user_id) {
   fake_user_manager_->AddUser(user_id);
   Profile* profile = profile_manager_.CreateTestingProfile(user_id);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile));
   return profile;
 }
 
-void AffiliatedInvalidationServiceProviderTest::
+void AffiliatedInvalidationServiceProviderImplTest::
     LogInAsAffiliatedUserAndConnectInvalidationService() {
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Log in as an affiliated user.
   Profile* profile = LogInAndReturnProfile(kAffiliatedUserID1);
   EXPECT_TRUE(profile);
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Verify that a per-profile invalidation service has been created.
   profile_invalidation_service_ =
@@ skipping 10 matching lines @@
   profile_invalidation_service_->SetInvalidatorState(
       syncer::INVALIDATIONS_ENABLED);
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Verify that the device-global invalidation service has been destroyed.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-void AffiliatedInvalidationServiceProviderTest::
+void AffiliatedInvalidationServiceProviderImplTest::
     LogInAsUnaffiliatedUserAndConnectInvalidationService() {
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Log in as an unaffiliated user.
   Profile* profile = LogInAndReturnProfile(kUnaffiliatedUserID);
   EXPECT_TRUE(profile);
 
   // Verify that a per-profile invalidation service has been created.
   profile_invalidation_service_ =
       GetProfileInvalidationService(profile, false /* create */);
   ASSERT_TRUE(profile_invalidation_service_);
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Indicate that the per-profile invalidation service has connected. Verify
   // that the consumer is not called back.
   profile_invalidation_service_->SetInvalidatorState(
       syncer::INVALIDATIONS_ENABLED);
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-void AffiliatedInvalidationServiceProviderTest::
+void AffiliatedInvalidationServiceProviderImplTest::
     ConnectDeviceGlobalInvalidationService() {
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Verify that a device-global invalidation service has been created.
   device_invalidation_service_ =
       provider_->GetDeviceInvalidationServiceForTest();
   ASSERT_TRUE(device_invalidation_service_);
 
   // Indicate that the device-global invalidation service has connected. Verify
   // that the consumer is informed about this.
   EXPECT_CALL(consumer_, OnInvalidationServiceSet(device_invalidation_service_))
       .Times(1);
   device_invalidation_service_->OnInvalidatorStateChange(
       syncer::INVALIDATIONS_ENABLED);
 
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-void AffiliatedInvalidationServiceProviderTest::
+void AffiliatedInvalidationServiceProviderImplTest::
     DisconnectPerProfileInvalidationService() {
   Mock::VerifyAndClearExpectations(&consumer_);
 
   ASSERT_TRUE(profile_invalidation_service_);
 
   // Indicate that the per-profile invalidation service has disconnected. Verify
   // that the consumer is informed about this.
   EXPECT_CALL(consumer_, OnInvalidationServiceSet(nullptr)).Times(1);
   profile_invalidation_service_->SetInvalidatorState(
       syncer::INVALIDATION_CREDENTIALS_REJECTED);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
 invalidation::FakeInvalidationService*
-AffiliatedInvalidationServiceProviderTest::GetProfileInvalidationService(
+AffiliatedInvalidationServiceProviderImplTest::GetProfileInvalidationService(
     Profile* profile, bool create) {
   invalidation::ProfileInvalidationProvider* invalidation_provider =
       static_cast<invalidation::ProfileInvalidationProvider*>(
           invalidation::ProfileInvalidationProviderFactory::GetInstance()->
               GetServiceForBrowserContext(profile, create));
   if (!invalidation_provider)
     return nullptr;
   return static_cast<invalidation::FakeInvalidationService*>(
       invalidation_provider->GetInvalidationService());
 }
 
-// No consumers are registered with the AffiliatedInvalidationServiceProvider.
-// Verifies that no device-global invalidation service is created, whether an
-// affiliated user is logged in or not.
-TEST_F(AffiliatedInvalidationServiceProviderTest, NoConsumers) {
+// No consumers are registered with the
+// AffiliatedInvalidationServiceProviderImpl. Verifies that no device-global
+// invalidation service is created, whether an affiliated user is logged in or
+// not.
+TEST_F(AffiliatedInvalidationServiceProviderImplTest, NoConsumers) {
   // Verify that no device-global invalidation service has been created.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as an affiliated user.
   EXPECT_TRUE(LogInAndReturnProfile(kAffiliatedUserID1));
 
   // Verify that no device-global invalidation service has been created.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider.
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
 // Verifies that when no per-profile invalidation service belonging to an
 // affiliated user is available, a device-global invalidation service is
 // created. Further verifies that when the device-global invalidation service
 // connects, it is made available to the consumer.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        UseDeviceInvalidationService) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Indicate that the device-global invalidation service connected. Verify that
   // that the consumer is informed about this.
   ConnectDeviceGlobalInvalidationService();
 
   // Indicate that the device-global invalidation service has disconnected.
   // Verify that the consumer is informed about this.
   EXPECT_CALL(consumer_, OnInvalidationServiceSet(nullptr)).Times(1);
   device_invalidation_service_->OnInvalidatorStateChange(
       syncer::INVALIDATION_CREDENTIALS_REJECTED);
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider.
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
 // Verifies that when a per-profile invalidation service belonging to an
 // affiliated user connects, it is made available to the consumer.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        UseAffiliatedProfileInvalidationService) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as an affiliated user and indicate that the per-profile invalidation
   // service for this user connected. Verify that this invalidation service is
   // made available to the |consumer_| and the device-global invalidation
   // service is destroyed.
   LogInAsAffiliatedUserAndConnectInvalidationService();
 
   // Indicate that the logged-in user's per-profile invalidation service
   // disconnected. Verify that the consumer is informed about this and a
   // device-global invalidation service is created.
   DisconnectPerProfileInvalidationService();
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider.
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
 // Verifies that when a per-profile invalidation service belonging to an
 // unaffiliated user connects, it is ignored.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        DoNotUseUnaffiliatedProfileInvalidationService) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as an unaffiliated user and indicate that the per-profile
   // invalidation service for this user connected. Verify that this invalidation
   // service is ignored and the device-global invalidation service is not
   // destroyed.
   LogInAsUnaffiliatedUserAndConnectInvalidationService();
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider. A
-// device-global invalidation service exists, is connected and is made available
-// to the consumer. Verifies that when a per-profile invalidation service
-// belonging to an affiliated user connects, it is made available to the
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
+// A device-global invalidation service exists, is connected and is made
+// available to the consumer. Verifies that when a per-profile invalidation
+// service belonging to an affiliated user connects, it is made available to the
 // consumer instead and the device-global invalidation service is destroyed.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        SwitchToAffiliatedProfileInvalidationService) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Indicate that the device-global invalidation service connected. Verify that
   // that the consumer is informed about this.
   ConnectDeviceGlobalInvalidationService();
 
   // Log in as an affiliated user and indicate that the per-profile invalidation
   // service for this user connected. Verify that this invalidation service is
   // made available to the |consumer_| and the device-global invalidation
   // service is destroyed.
   LogInAsAffiliatedUserAndConnectInvalidationService();
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider. A
-// device-global invalidation service exists, is connected and is made available
-// to the consumer. Verifies that when a per-profile invalidation service
-// belonging to an unaffiliated user connects, it is ignored and the
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
+// A device-global invalidation service exists, is connected and is made
+// available to the consumer. Verifies that when a per-profile invalidation
+// service belonging to an unaffiliated user connects, it is ignored and the
 // device-global invalidation service continues to be made available to the
 // consumer.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        DoNotSwitchToUnaffiliatedProfileInvalidationService) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Indicate that the device-global invalidation service connected. Verify that
   // that the consumer is informed about this.
   ConnectDeviceGlobalInvalidationService();
 
   // Log in as an unaffiliated user and indicate that the per-profile
   // invalidation service for this user connected. Verify that this invalidation
   // service is ignored and the device-global invalidation service is not
   // destroyed.
   LogInAsUnaffiliatedUserAndConnectInvalidationService();
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider. A
-// per-profile invalidation service belonging to an affiliated user exists, is
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
+// A per-profile invalidation service belonging to an affiliated user exists, is
 // connected and is made available to the consumer. Verifies that when the
 // per-profile invalidation service disconnects, a device-global invalidation
 // service is created. Further verifies that when the device-global invalidation
 // service connects, it is made available to the consumer.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        SwitchToDeviceInvalidationService) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as an affiliated user and indicate that the per-profile invalidation
   // service for this user connected. Verify that this invalidation service is
   // made available to the |consumer_| and the device-global invalidation
   // service is destroyed.
   LogInAsAffiliatedUserAndConnectInvalidationService();
 
   // Indicate that the logged-in user's per-profile invalidation service
   // disconnected. Verify that the consumer is informed about this and a
   // device-global invalidation service is created.
   DisconnectPerProfileInvalidationService();
 
   // Indicate that the device-global invalidation service connected. Verify that
   // that the consumer is informed about this.
   ConnectDeviceGlobalInvalidationService();
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider. A
-// per-profile invalidation service belonging to a first affiliated user exists,
-// is connected and is made available to the consumer. A per-profile
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
+// A per-profile invalidation service belonging to a first affiliated user
+// exists, is connected and is made available to the consumer. A per-profile
 // invalidation service belonging to a second affiliated user also exists and is
 // connected. Verifies that when the per-profile invalidation service belonging
 // to the first user disconnects, the per-profile invalidation service belonging
 // to the second user is made available to the consumer instead.
-TEST_F(AffiliatedInvalidationServiceProviderTest,
+TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        SwitchBetweenAffiliatedProfileInvalidationServices) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as a first affiliated user and indicate that the per-profile
   // invalidation service for this user connected. Verify that this invalidation
@@ skipping 32 matching lines @@
   Mock::VerifyAndClearExpectations(&consumer_);
 
   // Verify that the device-global invalidation service still does not exist.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider. A
-// device-global invalidation service exists, is connected and is made available
-// to the consumer. Verifies that when a second consumer registers, the
-// device-global invalidation service is made available to it as well. Further
-// verifies that when the first consumer unregisters, the device-global
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
+// A device-global invalidation service exists, is connected and is made
+// available to the consumer. Verifies that when a second consumer registers,
+// the device-global invalidation service is made available to it as well.
+// Further verifies that when the first consumer unregisters, the device-global
 // invalidation service is not destroyed and remains available to the second
 // consumer. Further verifies that when the second consumer also unregisters,
 // the device-global invalidation service is destroyed.
-TEST_F(AffiliatedInvalidationServiceProviderTest, MultipleConsumers) {
+TEST_F(AffiliatedInvalidationServiceProviderImplTest, MultipleConsumers) {
   // Register a first consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Indicate that the device-global invalidation service connected. Verify that
   // that the consumer is informed about this.
   ConnectDeviceGlobalInvalidationService();
 
   // Register a second consumer. Verify that the consumer is called back
   // immediately as a connected invalidation service is available.
@@ skipping 11 matching lines @@
 
   // Unregister the second consumer.
   provider_->UnregisterConsumer(&second_consumer);
 
   // Verify that the device-global invalidation service has been destroyed.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
   Mock::VerifyAndClearExpectations(&consumer_);
   Mock::VerifyAndClearExpectations(&second_consumer);
 }
 
-// A consumer is registered with the AffiliatedInvalidationServiceProvider. A
-// per-profile invalidation service belonging to a first affiliated user exists,
-// is connected and is made available to the consumer. Verifies that when the
-// provider is shut down, the consumer is informed that no invalidation service
-// is available for use anymore. Also verifies that no device-global
-// invalidation service is created and a per-profile invalidation service
-// belonging to a second affiliated user that subsequently connects is ignored.
-TEST_F(AffiliatedInvalidationServiceProviderTest, NoServiceAfterShutdown) {
+// A consumer is registered with the AffiliatedInvalidationServiceProviderImpl.
+// A per-profile invalidation service belonging to a first affiliated user
+// exists, is connected and is made available to the consumer. Verifies that
+// when the provider is shut down, the consumer is informed that no
+// invalidation service is available for use anymore. Also verifies that no
+// device-global invalidation service is created and a per-profile invalidation
+// service belonging to a second affiliated user that subsequently connects is
+// ignored.
+TEST_F(AffiliatedInvalidationServiceProviderImplTest, NoServiceAfterShutdown) {
   // Register a consumer. Verify that the consumer is not called back
   // immediately as no connected invalidation service exists yet.
   provider_->RegisterConsumer(&consumer_);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as a first affiliated user and indicate that the per-profile
   // invalidation service for this user connected. Verify that this invalidation
   // service is made available to the |consumer_| and the device-global
@@ skipping 28 matching lines @@
 
   // Verify that the device-global invalidation service still does not exist.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Unregister the consumer.
   provider_->UnregisterConsumer(&consumer_);
   Mock::VerifyAndClearExpectations(&consumer_);
 }
 
 }  // namespace policy