[CrOS MultiDevice] Integrate MultiDeviceSetup service with settings.

This CL passes a MultiDeviceSetupClient to MultideviceHandler and
utilizes it to pass data about the current multi-device host to the
settings page.

Additionally, this CL adds functionality to the TestWebUI class which
allows it to store and respond to registered callbacks in WebUI.

A follow-up CL will add functionality which provides the status of the
various multi-device features (e.g. Instant Tethering) to the settings
page as well.

Bug: 824568
Change-Id: I5665e225122e7a2875150f61cef77aaf770298d9
Reviewed-on: https://chromium-review.googlesource.com/1157268Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Tommy Li <tommycli@chromium.org>
Cr-Commit-Position: refs/heads/master@{#580013}

chrome/browser/chromeos/BUILD.gn

@@ -2243,6 +2243,7 @@ source_set("unit_tests") {
     "../ui/webui/settings/chromeos/device_keyboard_handler_unittest.cc",
     "../ui/webui/settings/chromeos/easy_unlock_settings_handler_unittest.cc",
     "../ui/webui/settings/chromeos/internet_handler_unittest.cc",
+    "../ui/webui/settings/chromeos/multidevice_handler_unittest.cc",
     "//components/drive/about_resource_loader_unittest.cc",
     "//components/drive/change_list_loader_unittest.cc",
     "//components/drive/change_list_processor_unittest.cc",

chrome/browser/resources/settings/multidevice_page/multidevice_browser_proxy.js

@@ -7,7 +7,7 @@ cr.define('settings', function() {
   class MultiDeviceBrowserProxy {
     showMultiDeviceSetupDialog() {}
 
-    /** @return Promise<!MultiDevicePageContentData> */
+    /** @return {!Promise<!MultiDevicePageContentData>} */
     getPageContentData() {}
   }
 
@@ -22,15 +22,7 @@ cr.define('settings', function() {
 
     /** @override */
     getPageContentData() {
-      // TODO(jordynass): change method content to
-      //    return cr.sendWithPromise('getPageContentData');
-      // once handler is built.
-      return Promise.resolve({
-        mode: settings.MultiDeviceSettingsMode.HOST_SET_VERIFIED,
-        hostDevice: {
-          name: 'Pixel XL',
-        },
-      });
+      return cr.sendWithPromise('getPageContentData');
     }
   }
 

chrome/browser/resources/settings/multidevice_page/multidevice_constants.js

@@ -82,7 +82,7 @@ let RemoteDevice;
  *
  * @typedef {{
  *   mode: !settings.MultiDeviceSettingsMode,
- *   hostDevice: (?RemoteDevice|undefined)
+ *   hostDevice: (RemoteDevice|undefined)
  * }}
  */
 let MultiDevicePageContentData;

chrome/browser/ui/BUILD.gn

@@ -2176,6 +2176,7 @@ jumbo_split_static_library("ui") {
       "//chromeos/resources:resources_grit",
       "//chromeos/services/assistant/public/mojom",
       "//chromeos/services/assistant/public/proto:proto",
+      "//chromeos/services/multidevice_setup/public/cpp",
       "//chromeos/services/multidevice_setup/public/mojom",
       "//components/arc",
       "//components/captive_portal",

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

@@ -14,17 +14,75 @@ namespace chromeos {
 
 namespace settings {
 
-MultideviceHandler::MultideviceHandler() = default;
-MultideviceHandler::~MultideviceHandler() = default;
+namespace {
 
-void MultideviceHandler::OnJavascriptAllowed() {}
-void MultideviceHandler::OnJavascriptDisallowed() {}
+const char kPageContentDataModeKey[] = "mode";
+const char kPageContentDataHostDeviceKey[] = "hostDevice";
+
+const char kRemoteDeviceNameKey[] = "name";
+const char kRemoteDeviceSoftwareFeaturesKey[] = "softwareFeatures";
+
+std::unique_ptr<base::DictionaryValue> GeneratePageContentDataDictionary(
+    multidevice_setup::mojom::HostStatus host_status,
+    const base::Optional<cryptauth::RemoteDeviceRef>& host_device) {
+  auto page_content_dictionary = std::make_unique<base::DictionaryValue>();
+  page_content_dictionary->SetInteger(kPageContentDataModeKey,
+                                      static_cast<int32_t>(host_status));
+
+  if (host_device) {
+    auto device_dictionary = std::make_unique<base::DictionaryValue>();
+    device_dictionary->SetString(kRemoteDeviceNameKey, host_device->name());
+
+    // TODO(khorimoto): Send actual feature dictionary. Currently, an empty
+    // dictionary is passed.
+    device_dictionary->SetDictionary(kRemoteDeviceSoftwareFeaturesKey,
+                                     std::make_unique<base::DictionaryValue>());
+
+    page_content_dictionary->SetDictionary(kPageContentDataHostDeviceKey,
+                                           std::move(device_dictionary));
+  }
+
+  return page_content_dictionary;
+}
+
+}  // namespace
+
+MultideviceHandler::MultideviceHandler(
+    multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client)
+    : multidevice_setup_client_(multidevice_setup_client),
+      multidevice_setup_observer_(this),
+      callback_weak_ptr_factory_(this) {}
+
+MultideviceHandler::~MultideviceHandler() {}
 
 void MultideviceHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "showMultiDeviceSetupDialog",
       base::BindRepeating(&MultideviceHandler::HandleShowMultiDeviceSetupDialog,
                           base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getPageContentData",
+      base::BindRepeating(&MultideviceHandler::HandleGetPageContent,
+                          base::Unretained(this)));
+}
+
+void MultideviceHandler::OnJavascriptAllowed() {
+  multidevice_setup_observer_.Add(multidevice_setup_client_);
+}
+
+void MultideviceHandler::OnJavascriptDisallowed() {
+  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();
+}
+
+void MultideviceHandler::OnHostStatusChanged(
+    multidevice_setup::mojom::HostStatus host_status,
+    const base::Optional<cryptauth::RemoteDeviceRef>& host_device) {
+  FireWebUIListener(
+      "settings.updateMultidevicePageContentData",
+      *GeneratePageContentDataDictionary(host_status, host_device));
 }
 
 void MultideviceHandler::HandleShowMultiDeviceSetupDialog(
@@ -33,6 +91,29 @@ void MultideviceHandler::HandleShowMultiDeviceSetupDialog(
   multidevice_setup::MultiDeviceSetupDialog::Show();
 }
 
+void MultideviceHandler::HandleGetPageContent(const base::ListValue* args) {
+  // This callback is expected to be the first one executed when the page is
+  // loaded, so it should be the one to allow JS calls.
+  AllowJavascript();
+
+  std::string callback_id;
+  bool result = args->GetString(0, &callback_id);
+  DCHECK(result);
+
+  multidevice_setup_client_->GetHostStatus(
+      base::BindOnce(&MultideviceHandler::OnHostStatusFetched,
+                     callback_weak_ptr_factory_.GetWeakPtr(), callback_id));
+}
+
+void MultideviceHandler::OnHostStatusFetched(
+    const std::string& js_callback_id,
+    multidevice_setup::mojom::HostStatus host_status,
+    const base::Optional<cryptauth::RemoteDeviceRef>& host_device) {
+  ResolveJavascriptCallback(
+      base::Value(js_callback_id),
+      *GeneratePageContentDataDictionary(host_status, host_device));
+}
+
 }  // namespace settings
 
 }  // namespace chromeos

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

@@ -6,27 +6,56 @@
 #define CHROME_BROWSER_UI_WEBUI_SETTINGS_CHROMEOS_MULTIDEVICE_HANDLER_H_
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/scoped_observer.h"
 #include "chrome/browser/ui/webui/settings/settings_page_ui_handler.h"
+#include "chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+#include "components/cryptauth/remote_device_ref.h"
 
 namespace chromeos {
 
 namespace settings {
 
 // Chrome "Multidevice" (a.k.a. "Connected Devices") settings page UI handler.
-class MultideviceHandler : public ::settings::SettingsPageUIHandler {
+class MultideviceHandler
+    : public ::settings::SettingsPageUIHandler,
+      public multidevice_setup::MultiDeviceSetupClient::Observer {
  public:
-  MultideviceHandler();
+  explicit MultideviceHandler(
+      multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client);
   ~MultideviceHandler() override;
 
+ protected:
   // content::WebUIMessageHandler:
   void RegisterMessages() override;
 
+ private:
   // ::settings::SettingsPageUIHandler:
   void OnJavascriptAllowed() override;
   void OnJavascriptDisallowed() override;
 
- private:
+  // multidevice_setup::MultiDeviceSetupClient::Observer:
+  void OnHostStatusChanged(
+      multidevice_setup::mojom::HostStatus host_status,
+      const base::Optional<cryptauth::RemoteDeviceRef>& host_device) override;
+
   void HandleShowMultiDeviceSetupDialog(const base::ListValue* args);
+  void HandleGetPageContent(const base::ListValue* args);
+
+  void OnHostStatusFetched(
+      const std::string& js_callback_id,
+      multidevice_setup::mojom::HostStatus host_status,
+      const base::Optional<cryptauth::RemoteDeviceRef>& host_device);
+
+  multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client_;
+
+  ScopedObserver<multidevice_setup::MultiDeviceSetupClient,
+                 multidevice_setup::MultiDeviceSetupClient::Observer>
+      multidevice_setup_observer_;
+
+  // Used to cancel callbacks when JavaScript becomes disallowed.
+  base::WeakPtrFactory<MultideviceHandler> callback_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MultideviceHandler);
 };

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

+// Copyright 2018 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/ui/webui/settings/chromeos/multidevice_handler.h"
+
+#include <memory>
+
+#include "base/macros.h"
+#include "chromeos/services/multidevice_setup/public/cpp/fake_multidevice_setup_client.h"
+#include "components/cryptauth/remote_device_test_util.h"
+#include "content/public/test/test_web_ui.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace settings {
+
+namespace {
+
+class TestMultideviceHandler : public MultideviceHandler {
+ public:
+  TestMultideviceHandler(
+      multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client)
+      : MultideviceHandler(multidevice_setup_client) {}
+  ~TestMultideviceHandler() override = default;
+
+  // Make public for testing.
+  using MultideviceHandler::AllowJavascript;
+  using MultideviceHandler::RegisterMessages;
+  using MultideviceHandler::set_web_ui;
+};
+
+void VerifyPageContentDict(
+    const base::Value* value,
+    multidevice_setup::mojom::HostStatus expected_host_status,
+    const base::Optional<cryptauth::RemoteDeviceRef>& expected_host_device) {
+  const base::DictionaryValue* page_content_dict;
+  EXPECT_TRUE(value->GetAsDictionary(&page_content_dict));
+
+  int mode;
+  EXPECT_TRUE(page_content_dict->GetInteger("mode", &mode));
+  EXPECT_EQ(static_cast<int>(expected_host_status), mode);
+
+  if (expected_host_device) {
+    const base::DictionaryValue* remote_device_dict;
+    EXPECT_TRUE(
+        page_content_dict->GetDictionary("hostDevice", &remote_device_dict));
+
+    std::string name;
+    EXPECT_TRUE(remote_device_dict->GetString("name", &name));
+    EXPECT_EQ(expected_host_device->name(), name);
+  } else {
+    EXPECT_FALSE(page_content_dict->GetDictionary("hostDevice", nullptr));
+  }
+}
+
+}  // namespace
+
+class MultideviceHandlerTest : public testing::Test {
+ protected:
+  MultideviceHandlerTest()
+      : test_device_(cryptauth::CreateRemoteDeviceRefForTest()) {}
+  ~MultideviceHandlerTest() override = default;
+
+  // testing::Test:
+  void SetUp() override {
+    test_web_ui_ = std::make_unique<content::TestWebUI>();
+
+    fake_multidevice_setup_client_ =
+        std::make_unique<multidevice_setup::FakeMultiDeviceSetupClient>();
+
+    handler_ = std::make_unique<TestMultideviceHandler>(
+        fake_multidevice_setup_client_.get());
+    handler_->set_web_ui(test_web_ui_.get());
+    handler_->RegisterMessages();
+    handler_->AllowJavascript();
+  }
+
+  void CallGetPageContentData(
+      multidevice_setup::mojom::HostStatus expected_host_status,
+      const base::Optional<cryptauth::RemoteDeviceRef>& expected_host_device) {
+    size_t call_data_count_before_call = test_web_ui()->call_data().size();
+
+    base::ListValue args;
+    args.AppendString("handlerFunctionName");
+    test_web_ui()->HandleReceivedMessage("getPageContentData", &args);
+
+    // The callback did not complete yet, so no call should have been made.
+    EXPECT_EQ(call_data_count_before_call, test_web_ui()->call_data().size());
+
+    // Invoke the callback; this should trigger the event to be sent to JS.
+    fake_multidevice_setup_client()->InvokePendingGetHostStatusCallback(
+        expected_host_status, expected_host_device);
+    EXPECT_EQ(call_data_count_before_call + 1u,
+              test_web_ui()->call_data().size());
+
+    const content::TestWebUI::CallData& call_data =
+        CallDataAtIndex(call_data_count_before_call);
+    EXPECT_EQ("cr.webUIResponse", call_data.function_name());
+    EXPECT_EQ("handlerFunctionName", call_data.arg1()->GetString());
+    EXPECT_TRUE(call_data.arg2()->GetBool());
+    VerifyPageContentDict(call_data.arg3(), expected_host_status,
+                          expected_host_device);
+  }
+
+  void SimulateHostStatusUpdate(
+      multidevice_setup::mojom::HostStatus host_status,
+      const base::Optional<cryptauth::RemoteDeviceRef>& host_device) {
+    size_t call_data_count_before_call = test_web_ui()->call_data().size();
+
+    fake_multidevice_setup_client_->NotifyHostStatusChanged(host_status,
+                                                            host_device);
+    EXPECT_EQ(call_data_count_before_call + 1u,
+              test_web_ui()->call_data().size());
+
+    const content::TestWebUI::CallData& call_data =
+        CallDataAtIndex(call_data_count_before_call);
+    EXPECT_EQ("cr.webUIListenerCallback", call_data.function_name());
+    EXPECT_EQ("settings.updateMultidevicePageContentData",
+              call_data.arg1()->GetString());
+    VerifyPageContentDict(call_data.arg2(), host_status, host_device);
+  }
+
+  const content::TestWebUI::CallData& CallDataAtIndex(size_t index) {
+    return *test_web_ui_->call_data()[index];
+  }
+
+  content::TestWebUI* test_web_ui() { return test_web_ui_.get(); }
+
+  multidevice_setup::FakeMultiDeviceSetupClient*
+  fake_multidevice_setup_client() {
+    return fake_multidevice_setup_client_.get();
+  }
+
+  const cryptauth::RemoteDeviceRef test_device_;
+
+ private:
+  std::unique_ptr<content::TestWebUI> test_web_ui_;
+  std::unique_ptr<multidevice_setup::FakeMultiDeviceSetupClient>
+      fake_multidevice_setup_client_;
+  std::unique_ptr<TestMultideviceHandler> handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(MultideviceHandlerTest);
+};
+
+TEST_F(MultideviceHandlerTest, PageContentData) {
+  CallGetPageContentData(multidevice_setup::mojom::HostStatus::kNoEligibleHosts,
+                         base::nullopt /* host_device */);
+  CallGetPageContentData(
+      multidevice_setup::mojom::HostStatus::kEligibleHostExistsButNoHostSet,
+      base::nullopt /* host_device */);
+  CallGetPageContentData(multidevice_setup::mojom::HostStatus::
+                             kHostSetLocallyButWaitingForBackendConfirmation,
+                         test_device_);
+  CallGetPageContentData(
+      multidevice_setup::mojom::HostStatus::kHostSetButNotYetVerified,
+      test_device_);
+  CallGetPageContentData(multidevice_setup::mojom::HostStatus::kHostVerified,
+                         test_device_);
+}
+
+TEST_F(MultideviceHandlerTest, HostStatusUpdates) {
+  SimulateHostStatusUpdate(
+      multidevice_setup::mojom::HostStatus::kNoEligibleHosts,
+      base::nullopt /* host_device */);
+  SimulateHostStatusUpdate(
+      multidevice_setup::mojom::HostStatus::kEligibleHostExistsButNoHostSet,
+      base::nullopt /* host_device */);
+  SimulateHostStatusUpdate(multidevice_setup::mojom::HostStatus::
+                               kHostSetLocallyButWaitingForBackendConfirmation,
+                           test_device_);
+  SimulateHostStatusUpdate(
+      multidevice_setup::mojom::HostStatus::kHostSetButNotYetVerified,
+      test_device_);
+  SimulateHostStatusUpdate(multidevice_setup::mojom::HostStatus::kHostVerified,
+                           test_device_);
+}
+
+}  // namespace settings
+
+}  // namespace chromeos

chrome/browser/ui/webui/settings/md_settings_ui.cc

@@ -75,6 +75,7 @@
 #include "chrome/browser/chromeos/arc/arc_util.h"
 #include "chrome/browser/chromeos/crostini/crostini_util.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_utils.h"
+#include "chrome/browser/chromeos/multidevice_setup/multidevice_setup_client_factory.h"
 #include "chrome/browser/signin/account_tracker_service_factory.h"
 #include "chrome/browser/ui/webui/settings/chromeos/accessibility_handler.h"
 #include "chrome/browser/ui/webui/settings/chromeos/account_manager_handler.h"
@@ -97,6 +98,7 @@
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/account_manager/account_manager.h"
 #include "chromeos/account_manager/account_manager_factory.h"
+#include "chromeos/chromeos_features.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/arc/arc_util.h"
 #include "ui/base/ui_base_features.h"
@@ -214,8 +216,16 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
   }
   AddSettingsPageUIHandler(
       std::make_unique<chromeos::settings::KeyboardHandler>());
-  AddSettingsPageUIHandler(
-      std::make_unique<chromeos::settings::MultideviceHandler>());
+  if (base::FeatureList::IsEnabled(
+          chromeos::features::kEnableUnifiedMultiDeviceSetup) &&
+      base::FeatureList::IsEnabled(
+          chromeos::features::kEnableUnifiedMultiDeviceSettings) &&
+      base::FeatureList::IsEnabled(chromeos::features::kMultiDeviceApi)) {
+    AddSettingsPageUIHandler(
+        std::make_unique<chromeos::settings::MultideviceHandler>(
+            chromeos::multidevice_setup::MultiDeviceSetupClientFactory::
+                GetForProfile(profile)));
+  }
   AddSettingsPageUIHandler(
       std::make_unique<chromeos::settings::PointerHandler>());
   AddSettingsPageUIHandler(

content/public/test/test_web_ui.cc

@@ -8,6 +8,7 @@
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_piece.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/web_ui_message_handler.h"
 
@@ -24,6 +25,21 @@ void TestWebUI::ClearTrackedCalls() {
   call_data_.clear();
 }
 
+void TestWebUI::HandleReceivedMessage(const std::string& handler_name,
+                                      const base::ListValue* args) {
+  const auto callbacks_map_it = message_callbacks_.find(handler_name);
+
+  if (callbacks_map_it == message_callbacks_.end())
+    return;
+
+  // Create a copy of the callbacks before running them. Without this, it could
+  // be possible for the callback's handler to register a new message handler
+  // during iteration of the vector, resulting in undefined behavior.
+  std::vector<MessageCallback> callbacks_to_run = callbacks_map_it->second;
+  for (auto& callback : callbacks_to_run)
+    callback.Run(args);
+}
+
 WebContents* TestWebUI::GetWebContents() const {
   return web_contents_;
 }
@@ -57,6 +73,11 @@ void TestWebUI::AddMessageHandler(
   handlers_.push_back(std::move(handler));
 }
 
+void TestWebUI::RegisterMessageCallback(base::StringPiece message,
+                                        const MessageCallback& callback) {
+  message_callbacks_[message.as_string()].push_back(callback);
+}
+
 bool TestWebUI::CanCallJavascript() {
   return true;
 }

content/public/test/test_web_ui.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#include "base/containers/flat_map.h"
 #include "base/values.h"
 #include "content/public/browser/web_ui.h"
 
@@ -21,6 +22,8 @@ class TestWebUI : public WebUI {
   ~TestWebUI() override;
 
   void ClearTrackedCalls();
+  void HandleReceivedMessage(const std::string& handler_name,
+                             const base::ListValue* args);
   void set_web_contents(WebContents* web_contents) {
     web_contents_ = web_contents;
   }
@@ -36,7 +39,7 @@ class TestWebUI : public WebUI {
   void SetBindings(int bindings) override;
   void AddMessageHandler(std::unique_ptr<WebUIMessageHandler> handler) override;
   void RegisterMessageCallback(base::StringPiece message,
-                               const MessageCallback& callback) override {}
+                               const MessageCallback& callback) override;
   void ProcessWebUIMessage(const GURL& source_url,
                            const std::string& message,
                            const base::ListValue& args) override {}
@@ -91,6 +94,7 @@ class TestWebUI : public WebUI {
   }
 
  private:
+  base::flat_map<std::string, std::vector<MessageCallback>> message_callbacks_;
   std::vector<std::unique_ptr<CallData>> call_data_;
   std::vector<std::unique_ptr<WebUIMessageHandler>> handlers_;
   int bindings_ = 0;