Clean up code path for "Cloud Policy over Tango"

Since Tango is being shut down & feature "Cloud Policy over FCM" is
being enabled:
* Enabled on ToT (M81)
* Enabled 100% on Finch experiment starting from M78

Bug: 1048214
Change-Id: Ie69bf1b89d2b9c4496479374b310eae9394be1fa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2035880
Commit-Queue: Askar Aitzhan <askaraitzhan@google.com>
Reviewed-by: Maksim Ivanov <emaxx@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738696}

chrome/browser/chromeos/policy/affiliated_cloud_policy_invalidator_unittest.cc

@@ -10,12 +10,10 @@
 
 #include "base/macros.h"
 #include "base/run_loop.h"
-#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/policy/device_policy_builder.h"
 #include "chrome/browser/chromeos/policy/fake_affiliated_invalidation_service_provider.h"
 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
-#include "chrome/common/chrome_features.h"
 #include "components/invalidation/impl/fake_invalidation_service.h"
 #include "components/invalidation/public/invalidation.h"
 #include "components/invalidation/public/invalidation_util.h"
@@ -41,8 +39,6 @@ namespace policy {
 
 namespace {
 
-const int kInvalidationSource = 123;
-const char kInvalidationName[] = "invalidation";
 const char kPolicyInvalidationTopic[] = "policy_invalidation_topic";
 
 class FakeCloudPolicyStore : public CloudPolicyStore {
@@ -72,28 +68,11 @@ void FakeCloudPolicyStore::Load() {
 
 }  // namespace
 
-// Accepts boolean param is_fcm_enabled.
-// true if FCM (Firebase Cloud Messaging) is enabled,
-// and false otherwise.
-class AffiliatedCloudPolicyInvalidatorTest
-    : public testing::TestWithParam<bool> {
- public:
-  AffiliatedCloudPolicyInvalidatorTest();
-
- private:
-  base::test::ScopedFeatureList feature_list_;
-};
-
-AffiliatedCloudPolicyInvalidatorTest::AffiliatedCloudPolicyInvalidatorTest() {
-  feature_list_.InitWithFeatureState(features::kPolicyFcmInvalidations,
-                                     GetParam() /* is_fcm_enabled */);
-}
-
 // Verifies that an invalidator is created/destroyed as an invalidation service
 // becomes available/unavailable. Also verifies that invalidations are handled
 // correctly and the highest handled invalidation version is preserved when
 // switching invalidation services.
-TEST_P(AffiliatedCloudPolicyInvalidatorTest, CreateUseDestroy) {
+TEST(AffiliatedCloudPolicyInvalidatorTest, CreateUseDestroy) {
   content::BrowserTaskEnvironment task_environment;
 
   // Set up a CloudPolicyCore backed by a simple CloudPolicyStore that does no
@@ -120,19 +99,8 @@ TEST_P(AffiliatedCloudPolicyInvalidatorTest, CreateUseDestroy) {
 
   DevicePolicyBuilder policy;
 
-  const bool is_fcm_enabled = GetParam();
-  if (is_fcm_enabled) {
-    // Pass deprecated source if FCM (Firebase Cloud Messaging) is enabled,
-    // because server does not support source field with FCM and
-    // InvalidationService fills the source field with kDeprecatedSourceForFCM.
-    policy.policy_data().set_invalidation_source(
-        syncer::kDeprecatedSourceForFCM);
-    policy.policy_data().set_policy_invalidation_topic(
-        kPolicyInvalidationTopic);
-  } else {
-    policy.policy_data().set_invalidation_source(kInvalidationSource);
-    policy.policy_data().set_invalidation_name(kInvalidationName);
-  }
+  policy.policy_data().set_policy_invalidation_topic(kPolicyInvalidationTopic);
+
   policy.Build();
   store.Store(policy.policy());
 
@@ -161,15 +129,11 @@ TEST_P(AffiliatedCloudPolicyInvalidatorTest, CreateUseDestroy) {
   // timestamp in microseconds. The policy blob contains a timestamp in
   // milliseconds. Convert from one to the other by multiplying by 1000.
   const int64_t invalidation_version = policy.policy_data().timestamp() * 1000;
-  syncer::Invalidation invalidation =
-      is_fcm_enabled
-          ? syncer::Invalidation::Init(
-                invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
-                                       kPolicyInvalidationTopic),
-                invalidation_version, "dummy payload")
-          : syncer::Invalidation::Init(
-                invalidation::ObjectId(kInvalidationSource, kInvalidationName),
-                invalidation_version, "dummy payload");
+  syncer::Invalidation invalidation = syncer::Invalidation::Init(
+      invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
+                             kPolicyInvalidationTopic),
+      invalidation_version, "dummy payload");
+
   syncer::ObjectIdInvalidationMap invalidation_map;
   invalidation_map.Insert(invalidation);
   invalidator->OnIncomingInvalidation(invalidation_map);
@@ -233,8 +197,4 @@ TEST_P(AffiliatedCloudPolicyInvalidatorTest, CreateUseDestroy) {
   affiliated_invalidator.OnInvalidationServiceSet(nullptr);
 }
 
-INSTANTIATE_TEST_SUITE_P(FCMEnabledAndFCMDisabled,
-                         AffiliatedCloudPolicyInvalidatorTest,
-                         testing::Bool() /* is_fcm_enabled */);
-
 }  // namespace policy

chrome/browser/chromeos/policy/affiliated_invalidation_service_provider_impl.cc

@@ -7,47 +7,36 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/task/post_task.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
-#include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/device_identity_provider.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
-#include "chrome/browser/invalidation/deprecated_profile_invalidation_provider_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/net/system_network_context_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/common/chrome_features.h"
 #include "components/gcm_driver/instance_id/instance_id_driver.h"
 #include "components/invalidation/impl/fcm_invalidation_service.h"
 #include "components/invalidation/impl/fcm_network_handler.h"
 #include "components/invalidation/impl/invalidation_state_tracker.h"
-#include "components/invalidation/impl/invalidator_storage.h"
 #include "components/invalidation/impl/per_user_topic_subscription_manager.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
-#include "components/invalidation/impl/ticl_invalidation_service.h"
 #include "components/invalidation/public/identity_provider.h"
 #include "components/invalidation/public/invalidation_handler.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/invalidator_state.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/user_manager/user.h"
-#include "content/public/browser/browser_task_traits.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/network_service_instance.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
-#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
-#include "services/network/public/mojom/network_context.mojom.h"
 
 namespace policy {
 
@@ -77,36 +66,8 @@ constexpr int kTransientErrorDisconnectLimit = 3;
 
 invalidation::ProfileInvalidationProvider* GetInvalidationProvider(
     Profile* profile) {
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    return invalidation::ProfileInvalidationProviderFactory::GetForProfile(
-        profile);
-  }
-  return invalidation::DeprecatedProfileInvalidationProviderFactory::
-      GetForProfile(profile);
-}
-
-// Runs on UI thread.
-void RequestProxyResolvingSocketFactoryOnUIThread(
-    base::WeakPtr<invalidation::TiclInvalidationService> owner,
-    mojo::PendingReceiver<network::mojom::ProxyResolvingSocketFactory>
-        receiver) {
-  if (!owner)
-    return;
-  if (g_browser_process->system_network_context_manager()) {
-    g_browser_process->system_network_context_manager()
-        ->GetContext()
-        ->CreateProxyResolvingSocketFactory(std::move(receiver));
-  }
-}
-
-// Runs on IO thread.
-void RequestProxyResolvingSocketFactory(
-    base::WeakPtr<invalidation::TiclInvalidationService> owner,
-    mojo::PendingReceiver<network::mojom::ProxyResolvingSocketFactory>
-        receiver) {
-  base::PostTask(FROM_HERE, {content::BrowserThread::UI},
-                 base::BindOnce(&RequestProxyResolvingSocketFactoryOnUIThread,
-                                owner, std::move(receiver)));
+  return invalidation::ProfileInvalidationProviderFactory::GetForProfile(
+      profile);
 }
 
 }  // namespace
@@ -294,13 +255,9 @@ void AffiliatedInvalidationServiceProviderImpl::Observe(
 
   // Create a state observer for the user's invalidation service.
   invalidation::InvalidationService* invalidation_service;
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    invalidation_service =
-        invalidation_provider->GetInvalidationServiceForCustomSender(
-            policy::kPolicyFCMInvalidationSenderID);
-  } else {
-    invalidation_service = invalidation_provider->GetInvalidationService();
-  }
+  invalidation_service =
+      invalidation_provider->GetInvalidationServiceForCustomSender(
+          policy::kPolicyFCMInvalidationSenderID);
   profile_invalidation_service_observers_.push_back(
       std::make_unique<InvalidationServiceObserver>(this,
                                                     invalidation_service));
@@ -483,39 +440,23 @@ AffiliatedInvalidationServiceProviderImpl::
       std::make_unique<chromeos::DeviceIdentityProvider>(
           chromeos::DeviceOAuth2TokenServiceFactory::Get());
 
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    device_instance_id_driver_ =
-        std::make_unique<instance_id::InstanceIDDriver>(
-            g_browser_process->gcm_driver());
-    DCHECK(device_instance_id_driver_);
-    auto device_invalidation_service =
-        std::make_unique<invalidation::FCMInvalidationService>(
-            device_identity_provider_.get(),
-            base::BindRepeating(&syncer::FCMNetworkHandler::Create,
-                                g_browser_process->gcm_driver(),
-                                device_instance_id_driver_.get()),
-            base::BindRepeating(
-                &syncer::PerUserTopicSubscriptionManager::Create,
-                device_identity_provider_.get(),
-                g_browser_process->local_state(),
-                base::RetainedRef(url_loader_factory)),
-            device_instance_id_driver_.get(), g_browser_process->local_state(),
-            policy::kPolicyFCMInvalidationSenderID);
-    device_invalidation_service->Init();
-    return device_invalidation_service;
-  }
+  device_instance_id_driver_ = std::make_unique<instance_id::InstanceIDDriver>(
+      g_browser_process->gcm_driver());
+
+  DCHECK(device_instance_id_driver_);
   auto device_invalidation_service =
-      std::make_unique<invalidation::TiclInvalidationService>(
-          GetUserAgent(), device_identity_provider_.get(),
-          g_browser_process->gcm_driver(),
-          base::BindRepeating(&RequestProxyResolvingSocketFactory),
-          base::CreateSingleThreadTaskRunner({content::BrowserThread::IO}),
-          std::move(url_loader_factory),
-          content::GetNetworkConnectionTracker());
-
-  device_invalidation_service->Init(
-      std::make_unique<invalidation::InvalidatorStorage>(
-          g_browser_process->local_state()));
+      std::make_unique<invalidation::FCMInvalidationService>(
+          device_identity_provider_.get(),
+          base::BindRepeating(&syncer::FCMNetworkHandler::Create,
+                              g_browser_process->gcm_driver(),
+                              device_instance_id_driver_.get()),
+          base::BindRepeating(&syncer::PerUserTopicSubscriptionManager::Create,
+                              device_identity_provider_.get(),
+                              g_browser_process->local_state(),
+                              base::RetainedRef(url_loader_factory)),
+          device_instance_id_driver_.get(), g_browser_process->local_state(),
+          policy::kPolicyFCMInvalidationSenderID);
+  device_invalidation_service->Init();
   return device_invalidation_service;
 }
 

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.cc

@@ -122,13 +122,7 @@ class UserCloudPolicyManagerChromeOSNotifierFactory
   UserCloudPolicyManagerChromeOSNotifierFactory()
       : BrowserContextKeyedServiceShutdownNotifierFactory(
             "UserRemoteCommandsInvalidator") {
-    if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-      DependsOn(
-          invalidation::ProfileInvalidationProviderFactory::GetInstance());
-      return;
-    }
-    DependsOn(invalidation::DeprecatedProfileInvalidationProviderFactory::
-                  GetInstance());
+    DependsOn(invalidation::ProfileInvalidationProviderFactory::GetInstance());
   }
 
   ~UserCloudPolicyManagerChromeOSNotifierFactory() override = default;
@@ -793,17 +787,8 @@ void UserCloudPolicyManagerChromeOS::OnProfileAdded(Profile* profile) {
 
   observed_profile_manager_.RemoveAll();
 
-  // If true FCMInvalidationService will be used as invalidation service and
-  // TiclInvalidationService otherwise.
-  const bool is_fcm_enabled =
-      base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations);
-
   invalidation::ProfileInvalidationProvider* const invalidation_provider =
-      is_fcm_enabled
-          ? invalidation::ProfileInvalidationProviderFactory::GetForProfile(
-                profile_)
-          : invalidation::DeprecatedProfileInvalidationProviderFactory::
-                GetForProfile(profile_);
+      invalidation::ProfileInvalidationProviderFactory::GetForProfile(profile_);
 
   if (!invalidation_provider)
     return;
@@ -813,10 +798,8 @@ void UserCloudPolicyManagerChromeOS::OnProfileAdded(Profile* profile) {
   invalidator_ = std::make_unique<RemoteCommandsInvalidatorImpl>(core());
 
   invalidator_->Initialize(
-      is_fcm_enabled
-          ? invalidation_provider->GetInvalidationServiceForCustomSender(
-                policy::kPolicyFCMInvalidationSenderID)
-          : invalidation_provider->GetInvalidationService());
+      invalidation_provider->GetInvalidationServiceForCustomSender(
+          policy::kPolicyFCMInvalidationSenderID));
 
   shutdown_notifier_ =
       UserCloudPolicyManagerChromeOSNotifierFactory::GetInstance()

chrome/browser/policy/cloud/cloud_policy_browsertest.cc

@@ -7,7 +7,6 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
-#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ -20,7 +19,6 @@
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/invalidation/deprecated_profile_invalidation_provider_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/policy/chrome_browser_policy_connector.h"
 #include "chrome/browser/policy/cloud/cloud_policy_test_utils.h"
@@ -28,7 +26,6 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/identity_manager_factory.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/common/chrome_features.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/invalidation/impl/fake_invalidation_service.h"
 #include "components/invalidation/impl/profile_identity_provider.h"
@@ -93,34 +90,21 @@ namespace policy {
 
 namespace {
 
-constexpr int invalidation_source = 16;
-constexpr char invalidation_name[] = "test_policy";
 constexpr char policy_invalidation_topic[] = "test_policy_topic";
 
-bool IsFcmEnabled() {
-  return base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations);
-}
-
 std::unique_ptr<invalidation::InvalidationService>
 CreateInvalidationServiceForSenderId(const std::string& fcm_sender_id) {
   return std::make_unique<invalidation::FakeInvalidationService>();
 }
 
 std::unique_ptr<KeyedService> BuildFakeProfileInvalidationProvider(
-    bool is_fcm_enabled,
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
-  if (is_fcm_enabled) {
-    return std::make_unique<invalidation::ProfileInvalidationProvider>(
-        std::make_unique<invalidation::FakeInvalidationService>(),
-        std::make_unique<invalidation::ProfileIdentityProvider>(
-            IdentityManagerFactory::GetForProfile(profile)),
-        base::BindRepeating(&CreateInvalidationServiceForSenderId));
-  }
   return std::make_unique<invalidation::ProfileInvalidationProvider>(
       std::make_unique<invalidation::FakeInvalidationService>(),
       std::make_unique<invalidation::ProfileIdentityProvider>(
-          IdentityManagerFactory::GetForProfile(profile)));
+          IdentityManagerFactory::GetForProfile(profile)),
+      base::BindRepeating(&CreateInvalidationServiceForSenderId));
 }
 
 const char* GetTestUser() {
@@ -164,14 +148,11 @@ std::string GetTestPolicy(const char* homepage, int key_version) {
       "  \"managed_users\": [ \"*\" ],"
       "  \"policy_user\": \"%s\","
       "  \"current_key_index\": %d,"
-      "  \"invalidation_source\": %d,"
-      "  \"invalidation_name\": \"%s\","
       "  \"policy_invalidation_topic\": \"%s\""
       "}";
 
   return base::StringPrintf(kTestPolicy, dm_protocol::kChromeUserPolicyType,
                             homepage, GetTestUser(), key_version,
-                            invalidation_source, invalidation_name,
                             policy_invalidation_topic);
 }
 
@@ -221,15 +202,9 @@ class CloudPolicyTest : public InProcessBrowserTest,
 
   void CreatedBrowserMainParts(
       content::BrowserMainParts* browser_main_parts) override {
-    if (IsFcmEnabled()) {
-      invalidation::ProfileInvalidationProviderFactory::GetInstance()
-          ->RegisterTestingFactory(base::BindRepeating(
-              &BuildFakeProfileInvalidationProvider, IsFcmEnabled()));
-    } else {
-      invalidation::DeprecatedProfileInvalidationProviderFactory::GetInstance()
-          ->RegisterTestingFactory(base::BindRepeating(
-              &BuildFakeProfileInvalidationProvider, IsFcmEnabled()));
-    }
+    invalidation::ProfileInvalidationProviderFactory::GetInstance()
+        ->RegisterTestingFactory(
+            base::BindRepeating(&BuildFakeProfileInvalidationProvider));
   }
 
   void SetUpOnMainThread() override {
@@ -325,22 +300,6 @@ class CloudPolicyTest : public InProcessBrowserTest,
     return profile_connector->policy_service();
   }
 
-  invalidation::FakeInvalidationService* GetInvalidationService() {
-    if (IsFcmEnabled()) {
-      return static_cast<invalidation::FakeInvalidationService*>(
-          static_cast<invalidation::ProfileInvalidationProvider*>(
-              invalidation::ProfileInvalidationProviderFactory::GetInstance()
-                  ->GetForProfile(browser()->profile()))
-              ->GetInvalidationService());
-    }
-    return static_cast<invalidation::FakeInvalidationService*>(
-        static_cast<invalidation::ProfileInvalidationProvider*>(
-            invalidation::DeprecatedProfileInvalidationProviderFactory::
-                GetInstance()
-                    ->GetForProfile(browser()->profile()))
-            ->GetInvalidationService());
-  }
-
   invalidation::FakeInvalidationService* GetInvalidationServiceForSenderId(
       std::string sender_id) {
     return static_cast<invalidation::FakeInvalidationService*>(
@@ -445,18 +404,11 @@ IN_PROC_BROWSER_TEST_F(CloudPolicyTest, InvalidatePolicy) {
   base::TimeDelta now =
       base::Time::NowFromSystemTime() - base::Time::UnixEpoch();
 
-  if (IsFcmEnabled()) {
-    GetInvalidationServiceForSenderId(kPolicyFCMInvalidationSenderID)
-        ->EmitInvalidationForTest(syncer::Invalidation::Init(
-            invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
-                                   policy_invalidation_topic),
-            now.InMicroseconds() /* version */, "payload"));
-  } else {
-    GetInvalidationService()->EmitInvalidationForTest(
-        syncer::Invalidation::Init(
-            invalidation::ObjectId(invalidation_source, invalidation_name),
-            now.InMicroseconds() /* version */, "payload"));
-  }
+  GetInvalidationServiceForSenderId(kPolicyFCMInvalidationSenderID)
+      ->EmitInvalidationForTest(syncer::Invalidation::Init(
+          invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
+                                 policy_invalidation_topic),
+          now.InMicroseconds() /* version */, "payload"));
   {
     base::RunLoop run_loop;
     on_policy_updated_ = run_loop.QuitClosure();

chrome/browser/policy/cloud/cloud_policy_invalidator.cc

@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/feature_list.h"
 #include "base/hash/hash.h"
 #include "base/location.h"
 #include "base/metrics/histogram_functions.h"
@@ -17,7 +16,6 @@
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/policy/cloud/policy_invalidation_util.h"
-#include "chrome/common/chrome_features.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
@@ -30,10 +28,6 @@ namespace policy {
 
 namespace {
 
-bool IsFcmEnabled() {
-  return base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations);
-}
-
 // Get the kMetricPolicyInvalidations histogram metric which should be
 // incremented when an invalidation is received.
 MetricPolicyRefresh GetPolicyRefreshMetric(bool invalidations_enabled,
@@ -62,16 +56,14 @@ void RecordPolicyRefreshMetric(
     base::UmaHistogramEnumeration(kMetricDevicePolicyRefresh,
                                   metric_policy_refresh,
                                   METRIC_POLICY_REFRESH_SIZE);
-    base::UmaHistogramEnumeration(
-        IsFcmEnabled() ? kMetricDevicePolicyRefreshFcm
-                       : kMetricDevicePolicyRefreshTicl,
-        metric_policy_refresh, METRIC_POLICY_REFRESH_SIZE);
+    base::UmaHistogramEnumeration(kMetricDevicePolicyRefreshFcm,
+                                  metric_policy_refresh,
+                                  METRIC_POLICY_REFRESH_SIZE);
   } else {
     base::UmaHistogramEnumeration(kMetricUserPolicyRefresh,
                                   metric_policy_refresh,
                                   METRIC_POLICY_REFRESH_SIZE);
-    base::UmaHistogramEnumeration(IsFcmEnabled() ? kMetricUserPolicyRefreshFcm
-                                                 : kMetricUserPolicyRefreshTicl,
+    base::UmaHistogramEnumeration(kMetricUserPolicyRefreshFcm,
                                   metric_policy_refresh,
                                   METRIC_POLICY_REFRESH_SIZE);
   }
@@ -285,18 +277,16 @@ void CloudPolicyInvalidator::HandleInvalidation(
     base::UmaHistogramEnumeration(kMetricDevicePolicyInvalidations,
                                   policy_invalidation_type,
                                   POLICY_INVALIDATION_TYPE_SIZE);
-    base::UmaHistogramEnumeration(
-        IsFcmEnabled() ? kMetricDevicePolicyInvalidationsFcm
-                       : kMetricDevicePolicyInvalidationsTicl,
-        policy_invalidation_type, POLICY_INVALIDATION_TYPE_SIZE);
+    base::UmaHistogramEnumeration(kMetricDevicePolicyInvalidationsFcm,
+                                  policy_invalidation_type,
+                                  POLICY_INVALIDATION_TYPE_SIZE);
   } else {
     base::UmaHistogramEnumeration(kMetricUserPolicyInvalidations,
                                   policy_invalidation_type,
                                   POLICY_INVALIDATION_TYPE_SIZE);
-    base::UmaHistogramEnumeration(
-        IsFcmEnabled() ? kMetricUserPolicyInvalidationsFcm
-                       : kMetricUserPolicyInvalidationsTicl,
-        policy_invalidation_type, POLICY_INVALIDATION_TYPE_SIZE);
+    base::UmaHistogramEnumeration(kMetricUserPolicyInvalidationsFcm,
+                                  policy_invalidation_type,
+                                  POLICY_INVALIDATION_TYPE_SIZE);
   }
   if (is_expired) {
     invalidation.Acknowledge();
@@ -375,10 +365,7 @@ void CloudPolicyInvalidator::Register(const invalidation::ObjectId& object_id) {
                << " for policy invalidations";
   }
   base::UmaHistogramBoolean(kMetricPolicyInvalidationRegistration, success);
-  base::UmaHistogramBoolean(IsFcmEnabled()
-                                ? kMetricPolicyInvalidationRegistrationFcm
-                                : kMetricPolicyInvalidationRegistrationTicl,
-                            success);
+  base::UmaHistogramBoolean(kMetricPolicyInvalidationRegistrationFcm, success);
 }
 
 void CloudPolicyInvalidator::Unregister() {

chrome/browser/policy/cloud/policy_invalidation_util.cc

@@ -4,9 +4,7 @@
 
 #include "chrome/browser/policy/cloud/policy_invalidation_util.h"
 
-#include "base/feature_list.h"
 #include "base/strings/string_piece.h"
-#include "chrome/common/chrome_features.h"
 #include "components/invalidation/public/invalidation.h"
 #include "components/policy/proto/device_management_backend.pb.h"
 #include "google/cacheinvalidation/include/types.h"
@@ -26,43 +24,24 @@ bool IsPublicInvalidationTopic(const syncer::Topic& topic) {
 bool GetCloudPolicyObjectIdFromPolicy(
     const enterprise_management::PolicyData& policy,
     invalidation::ObjectId* object_id) {
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    if (!policy.has_policy_invalidation_topic() ||
-        policy.policy_invalidation_topic().empty()) {
-      return false;
-    }
-    *object_id = invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
-                                        policy.policy_invalidation_topic());
-  } else {
-    if (!policy.has_invalidation_source() || !policy.has_invalidation_name() ||
-        policy.invalidation_name().empty()) {
-      return false;
-    }
-    *object_id = invalidation::ObjectId(policy.invalidation_source(),
-                                        policy.invalidation_name());
+  if (!policy.has_policy_invalidation_topic() ||
+      policy.policy_invalidation_topic().empty()) {
+    return false;
   }
+  *object_id = invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
+                                      policy.policy_invalidation_topic());
   return true;
 }
 
 bool GetRemoteCommandObjectIdFromPolicy(
     const enterprise_management::PolicyData& policy,
     invalidation::ObjectId* object_id) {
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    if (!policy.has_command_invalidation_topic() ||
-        policy.command_invalidation_topic().empty()) {
-      return false;
-    }
-    *object_id = invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
-                                        policy.command_invalidation_topic());
-  } else {
-    if (!policy.has_command_invalidation_source() ||
-        !policy.has_command_invalidation_name() ||
-        policy.command_invalidation_name().empty()) {
-      return false;
-    }
-    *object_id = invalidation::ObjectId(policy.command_invalidation_source(),
-                                        policy.command_invalidation_name());
+  if (!policy.has_command_invalidation_topic() ||
+      policy.command_invalidation_topic().empty()) {
+    return false;
   }
+  *object_id = invalidation::ObjectId(syncer::kDeprecatedSourceForFCM,
+                                      policy.command_invalidation_topic());
   return true;
 }
 

chrome/browser/policy/cloud/remote_commands_invalidator.cc

@@ -6,10 +6,8 @@
 
 #include <string>
 
-#include "base/feature_list.h"
 #include "base/logging.h"
 #include "chrome/browser/policy/cloud/policy_invalidation_util.h"
-#include "chrome/common/chrome_features.h"
 #include "components/invalidation/public/invalidation.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/invalidation_util.h"

chrome/browser/policy/cloud/remote_commands_invalidator_unittest.cc

@@ -6,9 +6,7 @@
 
 #include "base/macros.h"
 #include "base/run_loop.h"
-#include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
-#include "chrome/common/chrome_features.h"
 #include "components/invalidation/impl/deprecated_invalidator_registrar.h"
 #include "components/invalidation/impl/fake_invalidation_service.h"
 #include "components/invalidation/impl/mock_ack_handler.h"
@@ -35,15 +33,9 @@ class MockRemoteCommandInvalidator : public RemoteCommandsInvalidator {
   MOCK_METHOD0(OnStop, void());
   MOCK_METHOD0(DoRemoteCommandsFetch, void());
 
-  void SetInvalidationObjectID(const invalidation::ObjectId& object_id,
-                               bool is_fcm_enabled) {
+  void SetInvalidationObjectID(const invalidation::ObjectId& object_id) {
     em::PolicyData policy_data;
-    if (is_fcm_enabled) {
-      policy_data.set_command_invalidation_topic(object_id.name());
-    } else {
-      policy_data.set_command_invalidation_source(object_id.source());
-      policy_data.set_command_invalidation_name(object_id.name());
-    }
+    policy_data.set_command_invalidation_topic(object_id.name());
     ReloadPolicyData(&policy_data);
   }
 
@@ -56,22 +48,11 @@ class MockRemoteCommandInvalidator : public RemoteCommandsInvalidator {
   DISALLOW_COPY_AND_ASSIGN(MockRemoteCommandInvalidator);
 };
 
-class RemoteCommandsInvalidatorTest : public testing::TestWithParam<bool> {
+class RemoteCommandsInvalidatorTest : public testing::Test {
  public:
-  RemoteCommandsInvalidatorTest() : is_fcm_enabled_(GetParam()) {
-    feature_list_.InitWithFeatureState(features::kPolicyFcmInvalidations,
-                                       is_fcm_enabled_);
-
-    if (is_fcm_enabled_) {
-      kTestingObjectId1 =
-          invalidation::ObjectId(syncer::kDeprecatedSourceForFCM, "abcdef");
-      kTestingObjectId2 =
-          invalidation::ObjectId(syncer::kDeprecatedSourceForFCM, "defabc");
-      return;
-    }
-    kTestingObjectId1 = invalidation::ObjectId(123456, "abcdef");
-    kTestingObjectId2 = invalidation::ObjectId(654321, "defabc");
-  }
+  RemoteCommandsInvalidatorTest()
+      : kTestingObjectId1(syncer::kDeprecatedSourceForFCM, "abcdef"),
+        kTestingObjectId2(syncer::kDeprecatedSourceForFCM, "defabc") {}
 
   void EnableInvalidationService() {
     invalidation_service_.SetInvalidatorState(syncer::INVALIDATIONS_ENABLED);
@@ -155,12 +136,8 @@ class RemoteCommandsInvalidatorTest : public testing::TestWithParam<bool> {
   invalidation::ObjectId kTestingObjectId1;
   invalidation::ObjectId kTestingObjectId2;
 
-  const bool is_fcm_enabled_;
-
   base::test::SingleThreadTaskEnvironment task_environment_;
 
-  base::test::ScopedFeatureList feature_list_;
-
   invalidation::FakeInvalidationService invalidation_service_;
   StrictMock<MockRemoteCommandInvalidator> invalidator_;
 
@@ -169,14 +146,14 @@ class RemoteCommandsInvalidatorTest : public testing::TestWithParam<bool> {
 };
 
 // Verifies that only the fired invalidations will be received.
-TEST_P(RemoteCommandsInvalidatorTest, FiredInvalidation) {
+TEST_F(RemoteCommandsInvalidatorTest, FiredInvalidation) {
   InitializeAndStart();
 
   // Invalidator won't work at this point.
   EXPECT_FALSE(invalidator_.invalidations_enabled());
 
   // Load the policy data, it should work now.
-  invalidator_.SetInvalidationObjectID(kTestingObjectId1, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId1);
   EXPECT_TRUE(invalidator_.invalidations_enabled());
 
   base::RunLoop().RunUntilIdle();
@@ -207,7 +184,7 @@ TEST_P(RemoteCommandsInvalidatorTest, FiredInvalidation) {
 }
 
 // Verifies that no invalidation will be received when invalidator is shutdown.
-TEST_P(RemoteCommandsInvalidatorTest, ShutDown) {
+TEST_F(RemoteCommandsInvalidatorTest, ShutDown) {
   EXPECT_FALSE(invalidator_.invalidations_enabled());
   FireInvalidation(kTestingObjectId1);
 
@@ -216,7 +193,7 @@ TEST_P(RemoteCommandsInvalidatorTest, ShutDown) {
 }
 
 // Verifies that no invalidation will be received when invalidator is stopped.
-TEST_P(RemoteCommandsInvalidatorTest, Stopped) {
+TEST_F(RemoteCommandsInvalidatorTest, Stopped) {
   EXPECT_CALL(invalidator_, OnInitialize()).Times(1);
   invalidator_.Initialize(&invalidation_service_);
   VerifyExpectations();
@@ -232,13 +209,13 @@ TEST_P(RemoteCommandsInvalidatorTest, Stopped) {
 }
 
 // Verifies that stated/stopped state changes work as expected.
-TEST_P(RemoteCommandsInvalidatorTest, StartedStateChange) {
+TEST_F(RemoteCommandsInvalidatorTest, StartedStateChange) {
   InitializeAndStart();
 
   // Invalidator requires object id to work.
   VerifyInvalidationDisabled(kTestingObjectId1);
   EXPECT_FALSE(invalidator_.invalidations_enabled());
-  invalidator_.SetInvalidationObjectID(kTestingObjectId1, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId1);
   VerifyInvalidationEnabled(kTestingObjectId1);
 
   // Stop and restart invalidator.
@@ -254,24 +231,24 @@ TEST_P(RemoteCommandsInvalidatorTest, StartedStateChange) {
   VerifyExpectations();
 
   // Invalidator requires object id to work.
-  invalidator_.SetInvalidationObjectID(kTestingObjectId1, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId1);
   VerifyInvalidationEnabled(kTestingObjectId1);
 
   StopAndShutdown();
 }
 
 // Verifies that registered state changes work as expected.
-TEST_P(RemoteCommandsInvalidatorTest, RegistedStateChange) {
+TEST_F(RemoteCommandsInvalidatorTest, RegistedStateChange) {
   InitializeAndStart();
 
-  invalidator_.SetInvalidationObjectID(kTestingObjectId1, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId1);
   VerifyInvalidationEnabled(kTestingObjectId1);
 
-  invalidator_.SetInvalidationObjectID(kTestingObjectId2, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId2);
   VerifyInvalidationEnabled(kTestingObjectId2);
   VerifyInvalidationDisabled(kTestingObjectId1);
 
-  invalidator_.SetInvalidationObjectID(kTestingObjectId1, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId1);
   VerifyInvalidationEnabled(kTestingObjectId1);
   VerifyInvalidationDisabled(kTestingObjectId2);
 
@@ -280,7 +257,7 @@ TEST_P(RemoteCommandsInvalidatorTest, RegistedStateChange) {
   VerifyInvalidationDisabled(kTestingObjectId2);
   EXPECT_FALSE(invalidator_.invalidations_enabled());
 
-  invalidator_.SetInvalidationObjectID(kTestingObjectId2, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId2);
   VerifyInvalidationEnabled(kTestingObjectId2);
   VerifyInvalidationDisabled(kTestingObjectId1);
 
@@ -288,10 +265,10 @@ TEST_P(RemoteCommandsInvalidatorTest, RegistedStateChange) {
 }
 
 // Verifies that invalidation service enabled state changes work as expected.
-TEST_P(RemoteCommandsInvalidatorTest, InvalidationServiceEnabledStateChanged) {
+TEST_F(RemoteCommandsInvalidatorTest, InvalidationServiceEnabledStateChanged) {
   InitializeAndStart();
 
-  invalidator_.SetInvalidationObjectID(kTestingObjectId1, is_fcm_enabled_);
+  invalidator_.SetInvalidationObjectID(kTestingObjectId1);
   VerifyInvalidationEnabled(kTestingObjectId1);
 
   DisableInvalidationService();
@@ -312,8 +289,4 @@ TEST_P(RemoteCommandsInvalidatorTest, InvalidationServiceEnabledStateChanged) {
   StopAndShutdown();
 }
 
-INSTANTIATE_TEST_SUITE_P(ToggleIsFcmEnabled,
-                         RemoteCommandsInvalidatorTest,
-                         testing::Bool() /* is_fcm_enabled */);
-
 }  // namespace policy

chrome/browser/policy/cloud/user_cloud_policy_invalidator.cc

@@ -7,14 +7,12 @@
 #include <memory>
 
 #include "base/bind.h"
-#include "base/feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/deprecated_profile_invalidation_provider_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
-#include "chrome/common/chrome_features.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_manager.h"
@@ -24,12 +22,8 @@ namespace {
 
 invalidation::ProfileInvalidationProvider* GetInvalidationProvider(
     Profile* profile) {
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    return invalidation::ProfileInvalidationProviderFactory::GetForProfile(
-        profile);
-  }
-  return invalidation::DeprecatedProfileInvalidationProviderFactory::
-      GetForProfile(profile);
+  return invalidation::ProfileInvalidationProviderFactory::GetForProfile(
+      profile);
 }
 
 }  // namespace
@@ -86,12 +80,8 @@ void UserCloudPolicyInvalidator::Observe(
       GetInvalidationProvider(profile_);
   if (!invalidation_provider)
     return;
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    Initialize(invalidation_provider->GetInvalidationServiceForCustomSender(
-        policy::kPolicyFCMInvalidationSenderID));
-  } else {
-    Initialize(invalidation_provider->GetInvalidationService());
-  }
+  Initialize(invalidation_provider->GetInvalidationServiceForCustomSender(
+      policy::kPolicyFCMInvalidationSenderID));
 }
 
 }  // namespace policy

chrome/browser/policy/cloud/user_cloud_policy_invalidator_factory.cc

@@ -4,13 +4,10 @@
 
 #include "chrome/browser/policy/cloud/user_cloud_policy_invalidator_factory.h"
 
-#include "base/feature_list.h"
 #include "build/build_config.h"
-#include "chrome/browser/invalidation/deprecated_profile_invalidation_provider_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/policy/cloud/user_cloud_policy_invalidator.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/common/chrome_features.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
@@ -30,12 +27,7 @@ UserCloudPolicyInvalidatorFactory::UserCloudPolicyInvalidatorFactory()
     : BrowserContextKeyedServiceFactory(
           "UserCloudPolicyInvalidator",
           BrowserContextDependencyManager::GetInstance()) {
-  if (base::FeatureList::IsEnabled(features::kPolicyFcmInvalidations)) {
-    DependsOn(invalidation::ProfileInvalidationProviderFactory::GetInstance());
-    return;
-  }
-  DependsOn(invalidation::DeprecatedProfileInvalidationProviderFactory::
-                GetInstance());
+  DependsOn(invalidation::ProfileInvalidationProviderFactory::GetInstance());
 }
 
 UserCloudPolicyInvalidatorFactory::~UserCloudPolicyInvalidatorFactory() {}

chrome/common/chrome_features.cc

@@ -317,11 +317,6 @@ const base::Feature kDownloadsLocationChange{"DownloadsLocationChange",
                                              base::FEATURE_ENABLED_BY_DEFAULT};
 #endif
 
-// If enabled, policies will use FCM (Firebase Cloud Messaging) for its
-// invalidations.
-const base::Feature kPolicyFcmInvalidations{"PolicyFCMInvalidations",
-                                            base::FEATURE_ENABLED_BY_DEFAULT};
-
 // Disables ambient authentication in incognito mode.
 const base::Feature kEnableAmbientAuthenticationInIncognito{
     "EnableAmbientAuthenticationInIncognito",

chrome/common/chrome_features.h

@@ -180,9 +180,6 @@ COMPONENT_EXPORT(CHROME_FEATURES)
 extern const base::Feature kDownloadsLocationChange;
 #endif
 
-COMPONENT_EXPORT(CHROME_FEATURES)
-extern const base::Feature kPolicyFcmInvalidations;
-
 COMPONENT_EXPORT(CHROME_FEATURES)
 extern const base::Feature kEnableAmbientAuthenticationInGuestSession;
 

components/policy/core/common/cloud/enterprise_metrics.cc

@@ -9,14 +9,10 @@ namespace policy {
 const char kMetricUserPolicyRefresh[] = "Enterprise.PolicyRefresh2";
 const char kMetricUserPolicyRefreshFcm[] =
     "Enterprise.FCMInvalidationService.PolicyRefresh2";
-const char kMetricUserPolicyRefreshTicl[] =
-    "Enterprise.TiclInvalidationService.PolicyRefresh2";
 
 const char kMetricUserPolicyInvalidations[] = "Enterprise.PolicyInvalidations";
 const char kMetricUserPolicyInvalidationsFcm[] =
     "Enterprise.FCMInvalidationService.PolicyInvalidations";
-const char kMetricUserPolicyInvalidationsTicl[] =
-    "Enterprise.TiclInvalidationService.PolicyInvalidations";
 
 const char kMetricUserPolicyChromeOSSessionAbort[] =
     "Enterprise.UserPolicyChromeOS.SessionAbort";
@@ -24,21 +20,15 @@ const char kMetricUserPolicyChromeOSSessionAbort[] =
 const char kMetricDevicePolicyRefresh[] = "Enterprise.DevicePolicyRefresh2";
 const char kMetricDevicePolicyRefreshFcm[] =
     "Enterprise.FCMInvalidationService.DevicePolicyRefresh2";
-const char kMetricDevicePolicyRefreshTicl[] =
-    "Enterprise.TiclInvalidationService.DevicePolicyRefresh2";
 
 const char kMetricDevicePolicyInvalidations[] =
     "Enterprise.DevicePolicyInvalidations";
 const char kMetricDevicePolicyInvalidationsFcm[] =
     "Enterprise.FCMInvalidationService.DevicePolicyInvalidations";
-const char kMetricDevicePolicyInvalidationsTicl[] =
-    "Enterprise.TiclInvalidationService.DevicePolicyInvalidations";
 
 const char kMetricPolicyInvalidationRegistration[] =
     "Enterprise.PolicyInvalidationsRegistrationResult";
 const char kMetricPolicyInvalidationRegistrationFcm[] =
     "Enterprise.FCMInvalidationService.PolicyInvalidationsRegistrationResult";
-const char kMetricPolicyInvalidationRegistrationTicl[] =
-    "Enterprise.TiclInvalidationService.PolicyInvalidationsRegistrationResult";
 
 }  // namespace policy

components/policy/core/common/cloud/enterprise_metrics.h

@@ -213,20 +213,15 @@ enum class MetricUserPolicyChromeOSSessionAbortType {
 // the same UMA histogram name.
 POLICY_EXPORT extern const char kMetricUserPolicyRefresh[];
 POLICY_EXPORT extern const char kMetricUserPolicyRefreshFcm[];
-POLICY_EXPORT extern const char kMetricUserPolicyRefreshTicl[];
 POLICY_EXPORT extern const char kMetricUserPolicyInvalidations[];
 POLICY_EXPORT extern const char kMetricUserPolicyInvalidationsFcm[];
-POLICY_EXPORT extern const char kMetricUserPolicyInvalidationsTicl[];
 POLICY_EXPORT extern const char kMetricUserPolicyChromeOSSessionAbort[];
 POLICY_EXPORT extern const char kMetricDevicePolicyRefresh[];
 POLICY_EXPORT extern const char kMetricDevicePolicyRefreshFcm[];
-POLICY_EXPORT extern const char kMetricDevicePolicyRefreshTicl[];
 POLICY_EXPORT extern const char kMetricDevicePolicyInvalidations[];
 POLICY_EXPORT extern const char kMetricDevicePolicyInvalidationsFcm[];
-POLICY_EXPORT extern const char kMetricDevicePolicyInvalidationsTicl[];
 POLICY_EXPORT extern const char kMetricPolicyInvalidationRegistration[];
 POLICY_EXPORT extern const char kMetricPolicyInvalidationRegistrationFcm[];
-POLICY_EXPORT extern const char kMetricPolicyInvalidationRegistrationTicl[];
 
 }  // namespace policy
 

components/policy/proto/device_management_backend.proto

@@ -413,7 +413,7 @@ message CustomerLogo {
 // This message is included in serialized form in PolicyFetchResponse below. It
 // may also be signed, with the signature being created for the serialized form.
 message PolicyData {
-  reserved 10;
+  reserved 10, 13, 14, 18, 19;
 
   // See PolicyFetchRequest.policy_type.
   optional string policy_type = 1;
@@ -484,16 +484,6 @@ message PolicyData {
   // This is only sent as part of device policy fetch.
   optional string service_account_identity = 12;
 
-  // The object source which hosts policy objects within the invalidation
-  // service. This value is combined with invalidation_name to form the object
-  // id used to register for invalidations to this policy.
-  optional int32 invalidation_source = 13;
-
-  // The name which uniquely identifies this policy within the invalidation
-  // service object source. This value is combined with invalidation_source to
-  // form the object id used to register for invalidations to this policy.
-  optional bytes invalidation_name = 14;
-
   // Server-provided identifier of the fetched policy. This is to be used
   // by the client when requesting Policy Posture assertion through an API
   // call or SAML flow. For details, see http://go/chrome-nac-server-design.
@@ -518,18 +508,6 @@ message PolicyData {
   // Indicates the state that the device should be in.
   optional DeviceState device_state = 17;
 
-  // The object source which hosts command queue objects within the
-  // invalidation service. This value is combined with
-  // command_invalidation_name to form the object ID used to
-  // register for invalidations to the command queue.
-  optional int32 command_invalidation_source = 18;
-
-  // The name which uniquely identifies this device’s queue within
-  // the invalidation service object source. This value is combined
-  // with command_invalidation_source to form the object ID used to
-  // register for invalidations to the command queue.
-  optional bytes command_invalidation_name = 19;
-
   // The free-text location info the admin enters to associate the device
   // with a location.
   optional string annotated_location = 20;

components/policy/test_support/policy_testserver.py

@@ -48,8 +48,6 @@ Example:
   ],
   "current_key_index": 0,
   "robot_api_auth_code": "",
-  "invalidation_source": 1025,
-  "invalidation_name": "UENUPOL",
    "token_enrollment": {
       "token": "abcd-ef01-123123123",
       "username": "admin@example.com"
@@ -1159,14 +1157,6 @@ class PolicyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     policy_data.service_account_identity = policy.get(
         'service_account_identity',
         'policy_testserver.py-service_account_identity@gmail.com')
-    invalidation_source = policy.get('invalidation_source')
-    if invalidation_source is not None:
-      policy_data.invalidation_source = invalidation_source
-    # Since invalidation_name is type bytes in the proto, the Unicode name
-    # provided needs to be encoded as ASCII to set the correct byte pattern.
-    invalidation_name = policy.get('invalidation_name')
-    if invalidation_name is not None:
-      policy_data.invalidation_name = invalidation_name.encode('ascii')
 
     policy_invalidation_topic = policy.get('policy_invalidation_topic')
     if policy_invalidation_topic is not None: