Do not use unaffiliated users' connections for device policy pushing

chrome/browser/chromeos/policy/device_cloud_policy_invalidator_unittest.cc

 // Copyright 2014 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/device_cloud_policy_invalidator.h"
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #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/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_policy_builder.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"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
@@ skipping 21 matching lines @@
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
+const char kAffiliatedUserID1[] = "test_1@example.com";
+const char kAffiliatedUserID2[] = "test_2@example.com";
+const char kUnaffiliatedUserID[] = "test_2@other_domain.test";
+
 KeyedService* BuildProfileInvalidationProvider(
     content::BrowserContext* context) {
   scoped_ptr<invalidation::FakeInvalidationService> invalidation_service(
       new invalidation::FakeInvalidationService);
   invalidation_service->SetInvalidatorState(
       syncer::TRANSIENT_INVALIDATION_ERROR);
   return new invalidation::ProfileInvalidationProvider(
       invalidation_service.PassAs<invalidation::InvalidationService>());
 }
 
 }  // namespace
 
 class DeviceCloudPolicyInvalidatorTest : public testing::Test {
  public:
   DeviceCloudPolicyInvalidatorTest();
   virtual ~DeviceCloudPolicyInvalidatorTest();
 
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   // Ownership is not passed. The Profile is owned by the global ProfileManager.
-  Profile *CreateProfile(const std::string& profile_name);
+  Profile *LogInAndReturnProfile(const std::string& user_id);
 
   invalidation::TiclInvalidationService* GetDeviceInvalidationService();
   bool HasDeviceInvalidationServiceObserver() const;
 
   invalidation::FakeInvalidationService* GetProfileInvalidationService(
       Profile* profile);
   int GetProfileInvalidationServiceObserverCount() const;
 
   const invalidation::InvalidationService* GetInvalidationService() const;
   CloudPolicyInvalidator* GetCloudPolicyInvalidator() const;
 
   void ConnectDeviceInvalidationService();
 
  protected:
   DevicePolicyBuilder device_policy_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<net::URLRequestContextGetter> system_request_context_;
   TestingProfileManager profile_manager_;
+  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_;
   chromeos::DeviceSettingsTestHelper device_settings_test_helper_;
 
   scoped_ptr<DeviceCloudPolicyInvalidator> invalidator_;
 };
 
 DeviceCloudPolicyInvalidatorTest::DeviceCloudPolicyInvalidatorTest()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
       system_request_context_(new net::TestURLRequestContextGetter(
           base::MessageLoopProxy::current())),
       profile_manager_(TestingBrowserProcess::GetGlobal()),
+      fake_user_manager_(new chromeos::FakeUserManager),
+      user_manager_enabler_(fake_user_manager_),
       install_attributes_("example.com",
                           "user@example.com",
                           "device_id",
                           DEVICE_MODE_ENTERPRISE) {
 }
 
 DeviceCloudPolicyInvalidatorTest::~DeviceCloudPolicyInvalidatorTest() {
 }
 
 void DeviceCloudPolicyInvalidatorTest::SetUp() {
@@ skipping 41 matching lines @@
 
   invalidation::ProfileInvalidationProviderFactory::GetInstance()->
       RegisterTestingFactory(NULL);
   chromeos::DeviceSettingsService::Get()->UnsetSessionManager();
   TestingBrowserProcess::GetGlobal()->SetBrowserPolicyConnector(NULL);
   chromeos::DeviceOAuth2TokenServiceFactory::Shutdown();
   chromeos::DBusThreadManager::Shutdown();
   chromeos::SystemSaltGetter::Shutdown();
 }
 
-Profile *DeviceCloudPolicyInvalidatorTest::CreateProfile(
-    const std::string& profile_name) {
-  Profile* profile = profile_manager_.CreateTestingProfile(profile_name);
+Profile *DeviceCloudPolicyInvalidatorTest::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;
 }
 
 invalidation::TiclInvalidationService*
 DeviceCloudPolicyInvalidatorTest::GetDeviceInvalidationService() {
   return invalidator_->device_invalidation_service_.get();
@@ skipping 76 matching lines @@
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(GetDeviceInvalidationService());
   EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
 
   // Verify that the invalidator has been destroyed.
   EXPECT_FALSE(GetCloudPolicyInvalidator());
   EXPECT_FALSE(GetInvalidationService());
 }
 
-// Verifies that a DeviceCloudPolicyInvalidator backed by a per-profile
-// invalidation service is created/destroyed as the service
-// connects/disconnects.
-TEST_F(DeviceCloudPolicyInvalidatorTest, UseProfileInvalidationService) {
-  // Create a user profile.
-  Profile* profile = CreateProfile("test");
+// Verifies that when the per-profile invalidation service for an affiliated
+// user connect/disconnects, a DeviceCloudPolicyInvalidator backed by it is
+// created/destroyed.
+TEST_F(DeviceCloudPolicyInvalidatorTest,
+       UseAffiliatedProfileInvalidationService) {
+  // Log in as an affiliated user.
+  Profile* profile = LogInAndReturnProfile(kAffiliatedUserID1);
   ASSERT_TRUE(profile);
 
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(GetDeviceInvalidationService());
   EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
 
   // Verify that a per-profile invalidation service has been created.
   invalidation::FakeInvalidationService* profile_invalidation_service =
       GetProfileInvalidationService(profile);
   ASSERT_TRUE(profile_invalidation_service);
   EXPECT_EQ(1, GetProfileInvalidationServiceObserverCount());
 
-  // Verify that no invalidator exists yet
+  // Verify that no invalidator exists yet.
   EXPECT_FALSE(GetCloudPolicyInvalidator());
   EXPECT_FALSE(GetInvalidationService());
 
   // Indicate that the per-profile invalidation service has connected.
   profile_invalidation_service->SetInvalidatorState(
       syncer::INVALIDATIONS_ENABLED);
 
   // Verify that the device-global invalidator has been destroyed.
   EXPECT_FALSE(GetDeviceInvalidationService());
   EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
@@ skipping 19 matching lines @@
   // Verify that a per-profile invalidation service still exists.
   profile_invalidation_service = GetProfileInvalidationService(profile);
   EXPECT_TRUE(profile_invalidation_service);
   EXPECT_EQ(1, GetProfileInvalidationServiceObserverCount());
 
   // Verify that the invalidator has been destroyed.
   EXPECT_FALSE(GetCloudPolicyInvalidator());
   EXPECT_FALSE(GetInvalidationService());
 }
 
+// Verifies that even if the per-profile invalidation service for an
+// unaffiliated user connects, no DeviceCloudPolicyInvalidator backed by it is
+// created.
+TEST_F(DeviceCloudPolicyInvalidatorTest,
+       DoNotUseUnaffiliatedProfileInvalidationService) {
+  // Log in as an unaffiliated user.
+  Profile* profile = LogInAndReturnProfile(kUnaffiliatedUserID);
+  ASSERT_TRUE(profile);
+
+  // Verify that a device-global invalidation service has been created.
+  EXPECT_TRUE(GetDeviceInvalidationService());
+  EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
+
+  // Verify that a per-profile invalidation service has been created.
+  invalidation::FakeInvalidationService* profile_invalidation_service =
+      GetProfileInvalidationService(profile);
+  ASSERT_TRUE(profile_invalidation_service);
+  EXPECT_EQ(0, GetProfileInvalidationServiceObserverCount());
+
+  // Verify that no invalidator exists yet.
+  EXPECT_FALSE(GetCloudPolicyInvalidator());
+  EXPECT_FALSE(GetInvalidationService());
+
+  // Indicate that the per-profile invalidation service has connected.
+  profile_invalidation_service->SetInvalidatorState(
+      syncer::INVALIDATIONS_ENABLED);
+
+  // Verify that the device-global invalidator still exists.
+  EXPECT_TRUE(GetDeviceInvalidationService());
+  EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
+
+  // Verify that a per-profile invalidation service still exists.
+  profile_invalidation_service = GetProfileInvalidationService(profile);
+  EXPECT_TRUE(profile_invalidation_service);
+  EXPECT_EQ(0, GetProfileInvalidationServiceObserverCount());
+
+  // Verify that no invalidator has been created.
+  EXPECT_FALSE(GetCloudPolicyInvalidator());
+  EXPECT_FALSE(GetInvalidationService());
+}
+
 // Verifies that a DeviceCloudPolicyInvalidator exists whenever a connected
 // invalidation service is available, automatically switching between
 // device-global and per-profile invalidation services as they
 // connect/disconnect, giving priority to per-profile invalidation services.
 // Also verifies that the highest handled invalidation version is preserved when
 // switching invalidation services.
 TEST_F(DeviceCloudPolicyInvalidatorTest, SwitchInvalidationServices) {

[pastarmovj, 2014/09/17 16:04:57]

nit: This is a GIANT test. Is there any chance you can split this into few
smaller ones. I think if this test fails it will be hard to fix the issue
because the first failed ASSERT can hide more errors along the test. I don't
have enough context to say if this is feasible but it will be great if it is.

   CloudPolicyStore* store = static_cast<CloudPolicyStore*>(
       TestingBrowserProcess::GetGlobal()->platform_part()->
           browser_policy_connector_chromeos()->GetDeviceCloudPolicyManager()->
               device_store());
   ASSERT_TRUE(store);
 
   // Verify that an invalidator backed by the device-global invalidation service
   // is created when the service connects.
   ConnectDeviceInvalidationService();
   CloudPolicyInvalidator* invalidator = GetCloudPolicyInvalidator();
   ASSERT_TRUE(invalidator);
   ASSERT_TRUE(GetDeviceInvalidationService());
 
   // Verify that the invalidator's highest handled invalidation version starts
   // out as zero.
   EXPECT_EQ(0, invalidator->highest_handled_invalidation_version());
 
-  // Create a first user profile.
-  Profile* profile_1 = CreateProfile("test_1");
+  // Log in as a first affiliated user.
+  Profile* profile_1 = LogInAndReturnProfile(kAffiliatedUserID1);
   ASSERT_TRUE(profile_1);
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(GetDeviceInvalidationService());
   EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
 
   // Verify that a per-profile invalidation service has been created for the
-  // first user profile.
+  // first user.
   invalidation::FakeInvalidationService* profile_1_invalidation_service =
       GetProfileInvalidationService(profile_1);
   ASSERT_TRUE(profile_1_invalidation_service);
   EXPECT_EQ(1, GetProfileInvalidationServiceObserverCount());
 
   // Verify that an invalidator backed by the device-global invalidation service
   // still exists.
   EXPECT_TRUE(GetCloudPolicyInvalidator());
   EXPECT_EQ(GetDeviceInvalidationService(), GetInvalidationService());
 
-  // Indicate that the first user profile's per-profile invalidation service has
+  // Indicate that the first user's per-profile invalidation service has
   // connected.
   profile_1_invalidation_service->SetInvalidatorState(
       syncer::INVALIDATIONS_ENABLED);
 
   // Verify that the device-global invalidator has been destroyed.
   EXPECT_FALSE(GetDeviceInvalidationService());
   EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
 
   // Verify that a per-profile invalidation service still exists for the first
-  // user profile.
+  // user.
   profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
   EXPECT_TRUE(profile_1_invalidation_service);
   EXPECT_EQ(1, GetProfileInvalidationServiceObserverCount());
 
   // Verify that an invalidator backed by the per-profile invalidation service
-  // for the first user profile has been created.
+  // for the first user has been created.
   invalidator = GetCloudPolicyInvalidator();
   ASSERT_TRUE(invalidator);
   EXPECT_EQ(profile_1_invalidation_service, GetInvalidationService());
 
   // Verify that the invalidator's highest handled invalidation version starts
   // out as zero.
   EXPECT_EQ(0, invalidator->highest_handled_invalidation_version());
 
   // Handle an invalidation with version 1. Verify that the invalidator's
   // highest handled invalidation version is updated accordingly.
   store->Store(device_policy_.policy(), 1);
   invalidator->OnStoreLoaded(store);
   EXPECT_EQ(1, invalidator->highest_handled_invalidation_version());
 
-  // Create a second user profile.
-  Profile* profile_2 = CreateProfile("test_2");
+  // Log in as a second affiliated user.
+  Profile* profile_2 = LogInAndReturnProfile(kAffiliatedUserID2);
   ASSERT_TRUE(profile_2);
 
   // Verify that the device-global invalidator still does not exist.
   EXPECT_FALSE(GetDeviceInvalidationService());
   EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
 
   // Verify that a per-profile invalidation service still exists for the first
-  // user profile and one has been created for the second user profile.
+  // user and one has been created for the second user.
   profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
   EXPECT_TRUE(profile_1_invalidation_service);
   invalidation::FakeInvalidationService* profile_2_invalidation_service =
       GetProfileInvalidationService(profile_2);
   ASSERT_TRUE(profile_2_invalidation_service);
   EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
 
   // Verify that an invalidator backed by the per-profile invalidation service
-  // for the first user profile still exists.
+  // for the first user still exists.
   EXPECT_TRUE(GetCloudPolicyInvalidator());
   EXPECT_EQ(profile_1_invalidation_service, GetInvalidationService());
 
-  // Indicate that the second user profile's per-profile invalidation service
-  // has connected.
+  // Indicate that the second user's per-profile invalidation service has
+  // connected.
   profile_2_invalidation_service->SetInvalidatorState(
       syncer::INVALIDATIONS_ENABLED);
 
   // Verify that the device-global invalidator still does not exist.
   EXPECT_FALSE(GetDeviceInvalidationService());
   EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
 
-  // Verify that per-profile invalidation services still exist for both user
-  // profiles.
+  // Verify that per-profile invalidation services still exist for both users.
   profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
   ASSERT_TRUE(profile_1_invalidation_service);
   profile_2_invalidation_service = GetProfileInvalidationService(profile_2);
   EXPECT_TRUE(profile_2_invalidation_service);
   EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
 
   // Verify that an invalidator backed by the per-profile invalidation service
-  // for the first user profile still exists.
+  // for the first user still exists.
   EXPECT_TRUE(GetCloudPolicyInvalidator());
   EXPECT_EQ(profile_1_invalidation_service, GetInvalidationService());
 
-  // Indicate that the per-profile invalidation service for the first user
-  // profile has disconnected.
+  // Indicate that the per-profile invalidation service for the first user has
+  // disconnected.
   profile_1_invalidation_service->SetInvalidatorState(
       syncer::INVALIDATION_CREDENTIALS_REJECTED);
 
   // Verify that the device-global invalidator still does not exist.
   EXPECT_FALSE(GetDeviceInvalidationService());
   EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
 
-  // Verify that per-profile invalidation services still exist for both user
-  // profiles.
+  // Verify that per-profile invalidation services still exist for both users.
   profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
   EXPECT_TRUE(profile_1_invalidation_service);
   profile_2_invalidation_service = GetProfileInvalidationService(profile_2);
   ASSERT_TRUE(profile_2_invalidation_service);
   EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
 
   // Verify that an invalidator backed by the per-profile invalidation service
-  // for the second user profile has been created.
+  // for the second user has been created.
   invalidator = GetCloudPolicyInvalidator();
   ASSERT_TRUE(invalidator);
   EXPECT_EQ(profile_2_invalidation_service, GetInvalidationService());
 
   // Verify that the invalidator's highest handled invalidation version starts
   // out as 1.
   EXPECT_EQ(1, invalidator->highest_handled_invalidation_version());
 
   // Handle an invalidation with version 2. Verify that the invalidator's
   // highest handled invalidation version is updated accordingly.
   store->Store(device_policy_.policy(), 2);
   invalidator->OnStoreLoaded(store);
   EXPECT_EQ(2, invalidator->highest_handled_invalidation_version());
 
+  // Log in as an unaffiliated user.
+  Profile* profile_3 = LogInAndReturnProfile(kUnaffiliatedUserID);
+  ASSERT_TRUE(profile_3);
+
+  // Verify that the device-global invalidator still does not exist.
+  EXPECT_FALSE(GetDeviceInvalidationService());
+  EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
+
+  // Verify that a per-profile invalidation service still exists for the two
+  // affiliated user sand one has been created for the unaffiliated user.
+  profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
+  EXPECT_TRUE(profile_1_invalidation_service);
+  profile_2_invalidation_service = GetProfileInvalidationService(profile_2);
+  ASSERT_TRUE(profile_2_invalidation_service);
+  invalidation::FakeInvalidationService* profile_3_invalidation_service =
+      GetProfileInvalidationService(profile_3);
+  EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
+
+  // Verify that an invalidator backed by the per-profile invalidation service
+  // for the second affiliated user still exists.
+  EXPECT_TRUE(GetCloudPolicyInvalidator());
+  EXPECT_EQ(profile_2_invalidation_service, GetInvalidationService());
+
+  // Indicate that the unaffiliated user's per-profile invalidation service has
+  // connected.
+  profile_3_invalidation_service->SetInvalidatorState(
+      syncer::INVALIDATIONS_ENABLED);
+
+  // Verify that the device-global invalidator still does not exist.
+  EXPECT_FALSE(GetDeviceInvalidationService());
+  EXPECT_FALSE(HasDeviceInvalidationServiceObserver());
+
+  // Verify that per-profile invalidation services still exist for all three
+  // users.
+  profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
+  ASSERT_TRUE(profile_1_invalidation_service);
+  profile_2_invalidation_service = GetProfileInvalidationService(profile_2);
+  EXPECT_TRUE(profile_2_invalidation_service);
+  profile_3_invalidation_service = GetProfileInvalidationService(profile_3);
+  EXPECT_TRUE(profile_3_invalidation_service);
+  EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
+
+  // Verify that an invalidator backed by the per-profile invalidation service
+  // for the second affiliated user still exists.
+  EXPECT_TRUE(GetCloudPolicyInvalidator());
+
   // Indicate that the per-profile invalidation service for the second user
   // profile has disconnected.
   profile_2_invalidation_service->SetInvalidatorState(
       syncer::INVALIDATION_CREDENTIALS_REJECTED);
 
   // Verify that a device-global invalidation service has been created.
   ASSERT_TRUE(GetDeviceInvalidationService());
   EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
 
-  // Verify that per-profile invalidation services still exist for both user
-  // profiles.
+  // Verify that per-profile invalidation services still exist for all three
+  // users.
   profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
-  EXPECT_TRUE(profile_1_invalidation_service);
+  ASSERT_TRUE(profile_1_invalidation_service);
   profile_2_invalidation_service = GetProfileInvalidationService(profile_2);
   EXPECT_TRUE(profile_2_invalidation_service);
+  profile_3_invalidation_service = GetProfileInvalidationService(profile_3);
+  EXPECT_TRUE(profile_3_invalidation_service);
   EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
 
   // Verify that the invalidator has been destroyed.
   EXPECT_FALSE(GetCloudPolicyInvalidator());
   EXPECT_FALSE(GetInvalidationService());
 
   // Indicate that the device-global invalidation service has connected.
   GetDeviceInvalidationService()->OnInvalidatorStateChange(
       syncer::INVALIDATIONS_ENABLED);
   base::RunLoop().RunUntilIdle();
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(GetDeviceInvalidationService());
   EXPECT_TRUE(HasDeviceInvalidationServiceObserver());
 
-  // Verify that per-profile invalidation services still exist for both user
-  // profiles.
+  // Verify that per-profile invalidation services still exist for all three
+  // users.
   profile_1_invalidation_service = GetProfileInvalidationService(profile_1);
-  EXPECT_TRUE(profile_1_invalidation_service);
+  ASSERT_TRUE(profile_1_invalidation_service);
   profile_2_invalidation_service = GetProfileInvalidationService(profile_2);
   EXPECT_TRUE(profile_2_invalidation_service);
+  profile_3_invalidation_service = GetProfileInvalidationService(profile_3);
+  EXPECT_TRUE(profile_3_invalidation_service);
   EXPECT_EQ(2, GetProfileInvalidationServiceObserverCount());
 
   // Verify that an invalidator backed by the device-global invalidation service
   // has been created.
   invalidator = GetCloudPolicyInvalidator();
   ASSERT_TRUE(invalidator);
   EXPECT_EQ(GetDeviceInvalidationService(), GetInvalidationService());
 
   // Verify that the invalidator's highest handled invalidation version starts
   // out as 2.
   EXPECT_EQ(2, invalidator->highest_handled_invalidation_version());
 }
 
 }  // namespace policy