[MultideviceStubs] Add ShouldUseMultideviceStubs util function

Adds a util function to determine if Multidevice stubs should be used.
Will be used in future CLs that add in the stubs.

Bug: None
Change-Id: I67bd7695a5b71b749d6447116da5dba9cd565499
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2406594
Commit-Queue: Daniel Classon <dclasson@google.com>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#808584}

chrome/browser/chromeos/BUILD.gn

@@ -117,6 +117,7 @@ source_set("chromeos") {
     "//chromeos/components/media_app_ui",
     "//chromeos/components/mojo_bootstrap",
     "//chromeos/components/multidevice",
+    "//chromeos/components/multidevice:stub_multidevice_util",
     "//chromeos/components/multidevice/logging",
     "//chromeos/components/phonehub",
     "//chromeos/components/power",

chromeos/components/multidevice/BUILD.gn

@@ -42,6 +42,20 @@ static_library("multidevice") {
   ]
 }
 
+static_library("stub_multidevice_util") {
+  sources = [
+    "stub_multidevice_util.cc",
+    "stub_multidevice_util.h",
+  ]
+
+  deps = [
+    ":multidevice",
+    "//base",
+    "//chromeos/constants",
+    "//chromeos/services/device_sync/proto",
+  ]
+}
+
 static_library("test_support") {
   testonly = true
 

chromeos/components/multidevice/stub_multidevice_util.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 "chromeos/components/multidevice/stub_multidevice_util.h"
+
+#include <map>
+#include <vector>
+
+#include "base/base64.h"
+#include "base/base64url.h"
+#include "base/no_destructor.h"
+#include "base/system/sys_info.h"
+#include "base/time/time.h"
+#include "chromeos/components/multidevice/beacon_seed.h"
+#include "chromeos/constants/chromeos_features.h"
+
+namespace chromeos {
+
+namespace multidevice {
+
+namespace {
+
+// Attributes of the default stub device.
+const char kStubDeviceUserId[] = "example@gmail.com";
+const char kStubDevicePiiFreeName[] = "no-pii device";
+const char kStubDevicePSK[] = "remote device psk";
+const int64_t kStubDeviceLastUpdateTimeMillis = 0L;
+const char kBeaconSeedData[] = "beacon seed data";
+const int64_t kBeaconSeedStartTimeMillis = 100L;
+const int64_t kBeaconSeedEndTimeMillis = 200L;
+
+}  // namespace
+
+// Attributes of the default stub devices.
+const char kStubHostPhoneName[] = "Fake Phone";
+const char kStubClientComputerName[] = "Fake Computer";
+const char kStubHostPhoneInstanceId[] = "1234";
+const char kStubClientComputerInstanceId[] = "5678";
+const char kStubHostPhonePublicKey[] = "public key phone";
+const char kStubClientComputerPublicKey[] = "public key computer";
+const char kStubDeviceBluetoothPublicAddress[] = "01:23:45:67:89:AB";
+
+RemoteDevice CreateStubHostPhone() {
+  static const base::NoDestructor<RemoteDevice> host_phone([] {
+    // Stub host phone defaults to all host features enabled.
+    std::map<SoftwareFeature, SoftwareFeatureState> software_features;
+    software_features[SoftwareFeature::kBetterTogetherHost] =
+        SoftwareFeatureState::kEnabled;
+    software_features[SoftwareFeature::kSmartLockHost] =
+        SoftwareFeatureState::kEnabled;
+    software_features[SoftwareFeature::kInstantTetheringHost] =
+        SoftwareFeatureState::kEnabled;
+    software_features[SoftwareFeature::kMessagesForWebHost] =
+        SoftwareFeatureState::kEnabled;
+    software_features[SoftwareFeature::kPhoneHubHost] =
+        SoftwareFeatureState::kEnabled;
+    software_features[SoftwareFeature::kWifiSyncHost] =
+        SoftwareFeatureState::kEnabled;
+
+    std::vector<BeaconSeed> beacon_seeds = {multidevice::BeaconSeed(
+        kBeaconSeedData, base::Time::FromJavaTime(kBeaconSeedStartTimeMillis),
+        base::Time::FromJavaTime(kBeaconSeedEndTimeMillis))};
+
+    return RemoteDevice(kStubDeviceUserId, kStubHostPhoneInstanceId,
+                        kStubHostPhoneName, kStubDevicePiiFreeName,
+                        kStubHostPhonePublicKey, kStubDevicePSK,
+                        kStubDeviceLastUpdateTimeMillis, software_features,
+                        beacon_seeds, kStubDeviceBluetoothPublicAddress);
+  }());
+
+  return *host_phone;
+}
+
+RemoteDevice CreateStubClientComputer() {
+  static const base::NoDestructor<RemoteDevice> client_computer([] {
+    // Stub client computer relies on flags.
+    std::map<SoftwareFeature, SoftwareFeatureState> software_features;
+    software_features[SoftwareFeature::kBetterTogetherClient] =
+        SoftwareFeatureState::kSupported;
+    software_features[SoftwareFeature::kSmartLockClient] =
+        SoftwareFeatureState::kSupported;
+    software_features[SoftwareFeature::kMessagesForWebClient] =
+        SoftwareFeatureState::kSupported;
+
+    software_features[SoftwareFeature::kInstantTetheringClient] =
+        base::FeatureList::IsEnabled(chromeos::features::kInstantTethering)
+            ? SoftwareFeatureState::kSupported
+            : SoftwareFeatureState::kNotSupported;
+
+    software_features[SoftwareFeature::kPhoneHubClient] =
+        chromeos::features::IsPhoneHubEnabled()
+            ? SoftwareFeatureState::kSupported
+            : SoftwareFeatureState::kNotSupported;
+
+    software_features[SoftwareFeature::kWifiSyncClient] =
+        chromeos::features::IsWifiSyncAndroidEnabled()
+            ? SoftwareFeatureState::kSupported
+            : SoftwareFeatureState::kNotSupported;
+
+    std::vector<BeaconSeed> beacon_seeds = {multidevice::BeaconSeed(
+        kBeaconSeedData, base::Time::FromJavaTime(kBeaconSeedStartTimeMillis),
+        base::Time::FromJavaTime(kBeaconSeedEndTimeMillis))};
+
+    return RemoteDevice(kStubDeviceUserId, kStubClientComputerInstanceId,
+                        kStubClientComputerName, kStubDevicePiiFreeName,
+                        kStubClientComputerPublicKey, kStubDevicePSK,
+                        kStubDeviceLastUpdateTimeMillis, software_features,
+                        beacon_seeds, kStubDeviceBluetoothPublicAddress);
+  }());
+
+  return *client_computer;
+}
+
+bool ShouldUseMultideviceStubs() {
+  // Should use multidevice stubs if running on Linux CrOS build which doesn't
+  // support making authenticated network requests to the back-end.
+  return !base::SysInfo::IsRunningOnChromeOS();
+}
+
+}  // namespace multidevice
+
+}  // namespace chromeos

chromeos/components/multidevice/stub_multidevice_util.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 CHROMEOS_COMPONENTS_MULTIDEVICE_STUB_MULTIDEVICE_UTIL_H_
+#define CHROMEOS_COMPONENTS_MULTIDEVICE_STUB_MULTIDEVICE_UTIL_H_
+
+#include "chromeos/components/multidevice/remote_device.h"
+
+namespace chromeos {
+
+namespace multidevice {
+
+// Returns a fake host phone with all host features enabled. Can be used as a
+// stub remote device to fake out multidevice features.
+RemoteDevice CreateStubHostPhone();
+
+// Returns a fake client computer with the client features enabled according to
+// their corresponding flags. Can be used as a stub remote device to fake out
+// multidevice features.
+RemoteDevice CreateStubClientComputer();
+
+// Returns if we should use stubbed implementations of multidevice features,
+// i.e. when we are running a Linux CrOS build that doesn't support them.
+bool ShouldUseMultideviceStubs();
+
+}  // namespace multidevice
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_COMPONENTS_MULTIDEVICE_STUB_MULTIDEVICE_UTIL_H_