[CrOS MultiDevice] Don't start multi-device services if prohibited.

This eliminates segfaults when the device administrator has prohibited
all multi-device features and fixes some tests which break when the
multi-device flags are enabled by default.

Bug: 884066
Change-Id: I6ac54f2e5c065d8368af6c51eb1a61cfb6b5abd7
Reviewed-on: https://chromium-review.googlesource.com/c/1275307
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Jeremy Klein <jlklein@chromium.org>
Reviewed-by: James Hawkins <jhawkins@chromium.org>
Cr-Commit-Position: refs/heads/master@{#598862}

chrome/browser/chromeos/android_sms/android_sms_service_factory.cc

@@ -6,12 +6,24 @@
 #include "chrome/browser/chromeos/multidevice_setup/multidevice_setup_client_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/chromeos_features.h"
+#include "chromeos/services/multidevice_setup/public/cpp/prefs.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 
 namespace chromeos {
 
 namespace android_sms {
 
+namespace {
+
+bool IsFeatureAllowed(content::BrowserContext* context) {
+  return multidevice_setup::IsFeatureAllowed(
+      multidevice_setup::mojom::Feature::kMessages,
+      Profile::FromBrowserContext(context)->GetPrefs());
+}
+
+}  // namespace
+
 // static
 AndroidSmsServiceFactory* AndroidSmsServiceFactory::GetInstance() {
   static base::NoDestructor<AndroidSmsServiceFactory> factory_instance;
@@ -38,7 +50,8 @@ AndroidSmsServiceFactory::~AndroidSmsServiceFactory() = default;
 
 KeyedService* AndroidSmsServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
-  if (!base::FeatureList::IsEnabled(
+  if (!IsFeatureAllowed(context) ||
+      !base::FeatureList::IsEnabled(
           chromeos::features::kAndroidMessagesIntegration) ||
       !base::FeatureList::IsEnabled(
           chromeos::features::kEnableUnifiedMultiDeviceSetup) ||

chrome/browser/chromeos/login/easy_unlock/easy_unlock_service_factory.cc

@@ -21,6 +21,8 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/browser_resources.h"
+#include "chromeos/services/multidevice_setup/public/cpp/prefs.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "extensions/browser/extension_system.h"
@@ -48,6 +50,12 @@ base::FilePath GetEasyUnlockAppPath() {
   return base::FilePath();
 }
 
+bool IsFeatureAllowed(content::BrowserContext* context) {
+  return multidevice_setup::IsFeatureAllowed(
+      multidevice_setup::mojom::Feature::kSmartLock,
+      Profile::FromBrowserContext(context)->GetPrefs());
+}
+
 }  // namespace
 
 // static
@@ -82,10 +90,14 @@ KeyedService* EasyUnlockServiceFactory::BuildServiceInstanceFor(
   EasyUnlockService* service = NULL;
   int manifest_id = 0;
 
+  if (!IsFeatureAllowed(context))
+    return nullptr;
+
   if (ProfileHelper::IsLockScreenAppProfile(
           Profile::FromBrowserContext(context))) {
     return nullptr;
   }
+
   if (ProfileHelper::IsSigninProfile(Profile::FromBrowserContext(context))) {
     if (!context->IsOffTheRecord())
       return NULL;

chrome/browser/chromeos/multidevice_setup/multidevice_setup_client_factory.cc

@@ -10,6 +10,8 @@
 #include "chromeos/chromeos_features.h"
 #include "chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client.h"
 #include "chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client_impl.h"
+#include "chromeos/services/multidevice_setup/public/cpp/prefs.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/prefs/pref_service.h"
@@ -19,6 +21,15 @@ namespace chromeos {
 
 namespace multidevice_setup {
 
+namespace {
+
+bool IsAllowedByPolicy(content::BrowserContext* context) {
+  return multidevice_setup::AreAnyMultiDeviceFeaturesAllowed(
+      Profile::FromBrowserContext(context)->GetPrefs());
+}
+
+}  // namespace
+
 // Class that wraps MultiDeviceSetupClient in a KeyedService.
 class MultiDeviceSetupClientHolder : public KeyedService {
  public:
@@ -63,7 +74,8 @@ MultiDeviceSetupClientFactory* MultiDeviceSetupClientFactory::GetInstance() {
 
 KeyedService* MultiDeviceSetupClientFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
-  if (base::FeatureList::IsEnabled(
+  if (IsAllowedByPolicy(context) &&
+      base::FeatureList::IsEnabled(
           chromeos::features::kEnableUnifiedMultiDeviceSetup) &&
       base::FeatureList::IsEnabled(chromeos::features::kMultiDeviceApi)) {
     return new MultiDeviceSetupClientHolder(context);

chrome/browser/chromeos/tether/tether_service_factory.cc

@@ -18,10 +18,22 @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
+#include "chromeos/services/multidevice_setup/public/cpp/prefs.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/session_manager/core/session_manager.h"
 
+namespace {
+
+bool IsFeatureAllowed(content::BrowserContext* context) {
+  return chromeos::multidevice_setup::IsFeatureAllowed(
+      chromeos::multidevice_setup::mojom::Feature::kInstantTethering,
+      Profile::FromBrowserContext(context)->GetPrefs());
+}
+
+}  // namespace
+
 // static
 TetherServiceFactory* TetherServiceFactory::GetInstance() {
   return base::Singleton<TetherServiceFactory>::get();
@@ -51,6 +63,9 @@ KeyedService* TetherServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   DCHECK(chromeos::NetworkHandler::IsInitialized());
 
+  if (!IsFeatureAllowed(context))
+    return nullptr;
+
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(chromeos::switches::kTetherStub)) {
     FakeTetherService* fake_tether_service = new FakeTetherService(

chrome/browser/ui/webui/settings/chromeos/multidevice_handler.cc

@@ -93,11 +93,13 @@ void MultideviceHandler::RegisterMessages() {
 }
 
 void MultideviceHandler::OnJavascriptAllowed() {
-  multidevice_setup_observer_.Add(multidevice_setup_client_);
+  if (multidevice_setup_client_)
+    multidevice_setup_observer_.Add(multidevice_setup_client_);
 }
 
 void MultideviceHandler::OnJavascriptDisallowed() {
-  multidevice_setup_observer_.Remove(multidevice_setup_client_);
+  if (multidevice_setup_client_)
+    multidevice_setup_observer_.Remove(multidevice_setup_client_);
 
   // Ensure that pending callbacks do not complete and cause JS to be evaluated.
   callback_weak_ptr_factory_.InvalidateWeakPtrs();
@@ -237,9 +239,9 @@ MultideviceHandler::GeneratePageContentDataDictionary() {
   auto page_content_dictionary = std::make_unique<base::DictionaryValue>();
 
   multidevice_setup::MultiDeviceSetupClient::HostStatusWithDevice
-      host_status_with_device = multidevice_setup_client_->GetHostStatus();
+      host_status_with_device = GetHostStatusWithDevice();
   multidevice_setup::MultiDeviceSetupClient::FeatureStatesMap feature_states =
-      multidevice_setup_client_->GetFeatureStates();
+      GetFeatureStatesMap();
 
   page_content_dictionary->SetInteger(
       kPageContentDataModeKey,
@@ -295,6 +297,24 @@ bool MultideviceHandler::IsAuthTokenValid(const std::string& auth_token) {
          auth_token == quick_unlock_storage->GetAuthToken();
 }
 
+multidevice_setup::MultiDeviceSetupClient::HostStatusWithDevice
+MultideviceHandler::GetHostStatusWithDevice() {
+  if (multidevice_setup_client_)
+    return multidevice_setup_client_->GetHostStatus();
+
+  return multidevice_setup::MultiDeviceSetupClient::
+      GenerateDefaultHostStatusWithDevice();
+}
+
+multidevice_setup::MultiDeviceSetupClient::FeatureStatesMap
+MultideviceHandler::GetFeatureStatesMap() {
+  if (multidevice_setup_client_)
+    return multidevice_setup_client_->GetFeatureStates();
+
+  return multidevice_setup::MultiDeviceSetupClient::
+      GenerateDefaultFeatureStatesMap();
+}
+
 }  // namespace settings
 
 }  // namespace chromeos

chrome/browser/ui/webui/settings/chromeos/multidevice_handler.h

@@ -91,6 +91,11 @@ class MultideviceHandler
   // null).
   std::unique_ptr<base::DictionaryValue> GeneratePageContentDataDictionary();
 
+  multidevice_setup::MultiDeviceSetupClient::HostStatusWithDevice
+  GetHostStatusWithDevice();
+  multidevice_setup::MultiDeviceSetupClient::FeatureStatesMap
+  GetFeatureStatesMap();
+
   multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client_;
   std::unique_ptr<multidevice_setup::AndroidSmsAppHelperDelegate>
       android_sms_app_helper_;

chromeos/services/multidevice_setup/multidevice_setup_initializer.cc

@@ -86,6 +86,10 @@ MultiDeviceSetupInitializer::MultiDeviceSetupInitializer(
       android_sms_pairing_state_tracker_(
           std::move(android_sms_pairing_state_tracker)),
       gcm_device_info_provider_(gcm_device_info_provider) {
+  // If |device_sync_client_| is null, this interface cannot perform its tasks.
+  if (!device_sync_client_)
+    return;
+
   if (device_sync_client_->is_ready()) {
     InitializeImplementation();
     return;

chromeos/services/multidevice_setup/public/cpp/BUILD.gn

@@ -59,6 +59,7 @@ source_set("prefs") {
 
   deps = [
     "//base",
+    "//chromeos/services/multidevice_setup/public/mojom",
     "//components/prefs:prefs",
   ]
 }

chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client.cc

@@ -18,14 +18,13 @@ MultiDeviceSetupClient::GenerateDefaultHostStatusWithDevice() {
 // static
 MultiDeviceSetupClient::FeatureStatesMap
 MultiDeviceSetupClient::GenerateDefaultFeatureStatesMap() {
-  return FeatureStatesMap{{mojom::Feature::kBetterTogetherSuite,
-                           mojom::FeatureState::kUnavailableNoVerifiedHost},
-                          {mojom::Feature::kInstantTethering,
-                           mojom::FeatureState::kUnavailableNoVerifiedHost},
-                          {mojom::Feature::kMessages,
-                           mojom::FeatureState::kUnavailableNoVerifiedHost},
-                          {mojom::Feature::kSmartLock,
-                           mojom::FeatureState::kUnavailableNoVerifiedHost}};
+  return FeatureStatesMap{
+      {mojom::Feature::kBetterTogetherSuite,
+       mojom::FeatureState::kProhibitedByPolicy},
+      {mojom::Feature::kInstantTethering,
+       mojom::FeatureState::kProhibitedByPolicy},
+      {mojom::Feature::kMessages, mojom::FeatureState::kProhibitedByPolicy},
+      {mojom::Feature::kSmartLock, mojom::FeatureState::kProhibitedByPolicy}};
 }
 
 MultiDeviceSetupClient::MultiDeviceSetupClient() = default;

chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client.h

@@ -47,6 +47,9 @@ class MultiDeviceSetupClient {
   using GetEligibleHostDevicesCallback =
       base::OnceCallback<void(const cryptauth::RemoteDeviceRefList&)>;
 
+  static HostStatusWithDevice GenerateDefaultHostStatusWithDevice();
+  static FeatureStatesMap GenerateDefaultFeatureStatesMap();
+
   MultiDeviceSetupClient();
   virtual ~MultiDeviceSetupClient();
 
@@ -75,9 +78,6 @@ class MultiDeviceSetupClient {
       mojom::MultiDeviceSetup::TriggerEventForDebuggingCallback callback) = 0;
 
  protected:
-  static HostStatusWithDevice GenerateDefaultHostStatusWithDevice();
-  static FeatureStatesMap GenerateDefaultFeatureStatesMap();
-
   void NotifyHostStatusChanged(
       const HostStatusWithDevice& host_status_with_device);
   void NotifyFeatureStateChanged(const FeatureStatesMap& feature_states_map);

chromeos/services/multidevice_setup/public/cpp/prefs.cc

@@ -47,6 +47,22 @@ bool AreAnyMultiDeviceFeaturesAllowed(PrefService* pref_service) {
          pref_service->GetBoolean(kSmartLockAllowedPrefName);
 }
 
+bool IsFeatureAllowed(mojom::Feature feature, PrefService* pref_service) {
+  switch (feature) {
+    case mojom::Feature::kBetterTogetherSuite:
+      return AreAnyMultiDeviceFeaturesAllowed(pref_service);
+    case mojom::Feature::kInstantTethering:
+      return pref_service->GetBoolean(kInstantTetheringAllowedPrefName);
+    case mojom::Feature::kMessages:
+      return pref_service->GetBoolean(kMessagesAllowedPrefName);
+    case mojom::Feature::kSmartLock:
+      return pref_service->GetBoolean(kSmartLockAllowedPrefName);
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
 }  // namespace multidevice_setup
 
 }  // namespace chromeos

chromeos/services/multidevice_setup/public/cpp/prefs.h

@@ -5,6 +5,8 @@
 #ifndef CHROMEOS_SERVICES_MULTIDEVICE_SETUP_PUBLIC_CPP_PREFS_H_
 #define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_PUBLIC_CPP_PREFS_H_
 
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+
 class PrefRegistrySimple;
 class PrefService;
 
@@ -35,6 +37,7 @@ extern const char kSmartLockEnabledDeprecatedPrefName[];
 
 void RegisterFeaturePrefs(PrefRegistrySimple* registry);
 bool AreAnyMultiDeviceFeaturesAllowed(PrefService* pref_service);
+bool IsFeatureAllowed(mojom::Feature feature, PrefService* pref_service);
 
 }  // namespace multidevice_setup