Add a RemoteCommandsFactory for CBCM remote commands

Bug: 1112795
Change-Id: I5b30f12e33573c9109d5ff2ea030f3651b74b134
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2336280Reviewed-by: Owen Min <zmin@chromium.org>
Commit-Queue: anthonyvd <anthonyvd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#794636}

chrome/browser/BUILD.gn

@@ -4578,6 +4578,8 @@ static_library("browser") {
       "notifications/screen_lock_notification_blocker.cc",
       "notifications/screen_lock_notification_blocker.h",
       "platform_util.cc",
+      "policy/cbcm_remote_commands_factory.cc",
+      "policy/cbcm_remote_commands_factory.h",
       "policy/chrome_browser_cloud_management_controller_desktop.cc",
       "policy/chrome_browser_cloud_management_controller_desktop.h",
       "policy/chrome_browser_cloud_management_register_watcher.cc",

chrome/browser/policy/cbcm_remote_commands_factory.cc

+// Copyright 2020 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/policy/cbcm_remote_commands_factory.h"
+
+#include "base/notreached.h"
+#include "components/policy/core/common/remote_commands/remote_command_job.h"
+
+namespace policy {
+
+CBCMRemoteCommandsFactory::CBCMRemoteCommandsFactory() {}
+
+CBCMRemoteCommandsFactory::~CBCMRemoteCommandsFactory() {}
+
+std::unique_ptr<RemoteCommandJob> CBCMRemoteCommandsFactory::BuildJobForType(
+    enterprise_management::RemoteCommand_Type type,
+    RemoteCommandsService* service) {
+  NOTREACHED();
+  return nullptr;
+}
+
+}  // namespace policy

chrome/browser/policy/cbcm_remote_commands_factory.h

+// Copyright 2020 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.
+
+#ifndef CHROME_BROWSER_POLICY_CBCM_REMOTE_COMMANDS_FACTORY_H_
+#define CHROME_BROWSER_POLICY_CBCM_REMOTE_COMMANDS_FACTORY_H_
+
+#include "components/policy/core/common/remote_commands/remote_commands_factory.h"
+
+namespace policy {
+
+class CBCMRemoteCommandsFactory : public RemoteCommandsFactory {
+ public:
+  CBCMRemoteCommandsFactory();
+  ~CBCMRemoteCommandsFactory() override;
+
+  // RemoteCommandsFactory:
+  std::unique_ptr<RemoteCommandJob> BuildJobForType(
+      enterprise_management::RemoteCommand_Type type,
+      RemoteCommandsService* service) override;
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_CBCM_REMOTE_COMMANDS_FACTORY_H_

chrome/browser/policy/chrome_browser_cloud_management_controller_desktop.cc

@@ -14,9 +14,11 @@
 #include "chrome/browser/device_identity/device_oauth2_token_service_factory.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/net/system_network_context_manager.h"
+#include "chrome/browser/policy/cbcm_remote_commands_factory.h"
 #include "chrome/browser/policy/chrome_browser_cloud_management_register_watcher.h"
 #include "chrome/browser/policy/chrome_browser_policy_connector.h"
 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
+#include "chrome/browser/policy/cloud/remote_commands_invalidator_impl.h"
 #include "chrome/browser/policy/device_account_initializer.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_paths.h"
@@ -376,6 +378,23 @@ void ChromeBrowserCloudManagementControllerDesktop::StartInvalidations() {
       base::ThreadTaskRunnerHandle::Get(), base::DefaultClock::GetInstance(),
       0 /* highest_handled_invalidation_version */);
   policy_invalidator_->Initialize(invalidation_service_.get());
+
+  if (base::FeatureList::IsEnabled(policy::features::kCBCMRemoteCommands)) {
+    g_browser_process->browser_policy_connector()
+        ->machine_level_user_cloud_policy_manager()
+        ->core()
+        ->StartRemoteCommandsService(
+            std::make_unique<CBCMRemoteCommandsFactory>(),
+            PolicyInvalidationScope::kCBCM);
+
+    commands_invalidator_ = std::make_unique<RemoteCommandsInvalidatorImpl>(
+        g_browser_process->browser_policy_connector()
+            ->machine_level_user_cloud_policy_manager()
+            ->core(),
+        base::DefaultClock::GetInstance(), PolicyInvalidationScope::kCBCM);
+    commands_invalidator_->Initialize(invalidation_service_.get());
+    commands_invalidator_->Start();
+  }
 }
 
 void ChromeBrowserCloudManagementControllerDesktop::AccountInitCallback(

chrome/browser/policy/chrome_browser_cloud_management_controller_desktop.h

@@ -27,6 +27,7 @@ namespace policy {
 class ChromeBrowserCloudManagementRegisterWatcher;
 class CloudPolicyInvalidator;
 class MachineLevelDeviceAccountInitializerHelper;
+class RemoteCommandsInvalidator;
 
 // Desktop implementation of the platform-specific operations of CBCMController.
 class ChromeBrowserCloudManagementControllerDesktop
@@ -90,6 +91,9 @@ class ChromeBrowserCloudManagementControllerDesktop
   std::unique_ptr<instance_id::InstanceIDDriver> device_instance_id_driver_;
   std::unique_ptr<invalidation::FCMInvalidationService> invalidation_service_;
   std::unique_ptr<CloudPolicyInvalidator> policy_invalidator_;
+
+  // This invalidator is responsible for receiving remote commands invalidations
+  std::unique_ptr<RemoteCommandsInvalidator> commands_invalidator_;
 };
 
 }  // namespace policy

components/policy/core/common/features.cc

@@ -14,6 +14,9 @@ const base::Feature kPolicyAtomicGroup{"PolicyAtomicGroup",
 const base::Feature kCBCMPolicyInvalidations{"CBCMPolicyInvalidations",
                                              base::FEATURE_DISABLED_BY_DEFAULT};
 
+const base::Feature kCBCMRemoteCommands{"CBCMRemoteCommands",
+                                        base::FEATURE_DISABLED_BY_DEFAULT};
+
 #if defined(OS_APPLE)
 const base::Feature kIgnoreSensitivePoliciesOnUnmanagedMac{
     "IgnoreSensitivePoliciesOnUnmanagedMac", base::FEATURE_ENABLED_BY_DEFAULT};

components/policy/core/common/features.h

@@ -26,6 +26,11 @@ POLICY_EXPORT extern const base::Feature kIgnoreSensitivePoliciesOnUnmanagedMac;
 // enabled.
 POLICY_EXPORT extern const base::Feature kCBCMPolicyInvalidations;
 
+// Feature that controls if remote commands are enabled in CBCM. If enabled,
+// the browser will register for remote commands FCM invalidations, and fetch
+// remote commands when fetching policies.
+POLICY_EXPORT extern const base::Feature kCBCMRemoteCommands;
+
 }  // namespace features
 }  // namespace policy