Add CrosStateSender

Responsible for sending the the cros state to the user's phone.

Bug: 1106937
Test: chromeos_components_unittests
Change-Id: Ibe730b1796dd6d100db27def461821da8f9bbcde
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2443758
Commit-Queue: Jimmy Gong <jimmyxgong@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#813931}

chromeos/components/phonehub/BUILD.gn

@@ -22,6 +22,8 @@ static_library("phonehub") {
     "connection_scheduler.h",
     "connection_scheduler_impl.cc",
     "connection_scheduler_impl.h",
+    "cros_state_sender.cc",
+    "cros_state_sender.h",
     "do_not_disturb_controller.cc",
     "do_not_disturb_controller.h",
     "do_not_disturb_controller_impl.cc",
@@ -157,6 +159,7 @@ source_set("unit_tests") {
     "browser_tabs_model_unittest.cc",
     "connection_manager_impl_unittest.cc",
     "connection_scheduler_impl_unittest.cc",
+    "cros_state_sender_unittest.cc",
     "do_not_disturb_controller_impl_unittest.cc",
     "feature_status_provider_impl_unittest.cc",
     "find_my_device_controller_impl_unittest.cc",

chromeos/components/phonehub/cros_state_sender.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/phonehub/cros_state_sender.h"
+
+#include "chromeos/components/phonehub/message_sender.h"
+#include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
+
+namespace chromeos {
+namespace phonehub {
+
+using multidevice_setup::mojom::Feature;
+using multidevice_setup::mojom::FeatureState;
+
+CrosStateSender::CrosStateSender(
+    MessageSender* message_sender,
+    ConnectionManager* connection_manager,
+    multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client)
+    : message_sender_(message_sender),
+      connection_manager_(connection_manager),
+      multidevice_setup_client_(multidevice_setup_client) {
+  DCHECK(message_sender_);
+  DCHECK(connection_manager_);
+  DCHECK(multidevice_setup_client_);
+
+  connection_manager_->AddObserver(this);
+  multidevice_setup_client_->AddObserver(this);
+}
+
+CrosStateSender::~CrosStateSender() {
+  connection_manager_->RemoveObserver(this);
+  multidevice_setup_client_->RemoveObserver(this);
+}
+
+void CrosStateSender::AttemptUpdateCrosState() const {
+  // Wait for connection to be established.
+  if (connection_manager_->GetStatus() !=
+      ConnectionManager::Status::kConnected) {
+    return;
+  }
+
+  bool are_notifications_enabled =
+      multidevice_setup_client_->GetFeatureState(
+          Feature::kPhoneHubNotifications) == FeatureState::kEnabledByUser;
+  message_sender_->SendCrosState(are_notifications_enabled);
+}
+
+void CrosStateSender::OnConnectionStatusChanged() {
+  AttemptUpdateCrosState();
+}
+
+void CrosStateSender::OnFeatureStatesChanged(
+    const multidevice_setup::MultiDeviceSetupClient::FeatureStatesMap&
+        feature_states_map) {
+  AttemptUpdateCrosState();
+}
+
+}  // namespace phonehub
+}  // namespace chromeos

chromeos/components/phonehub/cros_state_sender.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_PHONEHUB_CROS_STATE_SENDER_H_
+#define CHROMEOS_COMPONENTS_PHONEHUB_CROS_STATE_SENDER_H_
+
+#include "chromeos/components/phonehub/connection_manager.h"
+#include "chromeos/services/multidevice_setup/public/cpp/multidevice_setup_client.h"
+
+namespace chromeos {
+namespace phonehub {
+
+class MessageSender;
+
+// Responsible for sending the Chrome OS's device state to the user's
+// phone.
+class CrosStateSender
+    : public ConnectionManager::Observer,
+      public multidevice_setup::MultiDeviceSetupClient::Observer {
+ public:
+  CrosStateSender(
+      MessageSender* message_sender,
+      ConnectionManager* connection_manager,
+      multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client);
+  ~CrosStateSender() override;
+
+ private:
+  void AttemptUpdateCrosState() const;
+
+  // ConnectionManager::Observer:
+  void OnConnectionStatusChanged() override;
+
+  // MultiDeviceSetupClient::Observer:
+  void OnFeatureStatesChanged(
+      const multidevice_setup::MultiDeviceSetupClient::FeatureStatesMap&
+          feature_states_map) override;
+
+  MessageSender* message_sender_;
+  ConnectionManager* connection_manager_;
+  multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client_;
+};
+
+}  // namespace phonehub
+}  // namespace chromeos
+
+#endif  // CHROMEOS_COMPONENTS_PHONEHUB_CROS_STATE_SENDER_H_

chromeos/components/phonehub/cros_state_sender_unittest.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/phonehub/cros_state_sender.h"
+
+#include <memory>
+
+#include "chromeos/components/phonehub/fake_connection_manager.h"
+#include "chromeos/components/phonehub/fake_message_sender.h"
+#include "chromeos/services/multidevice_setup/public/cpp/fake_multidevice_setup_client.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace phonehub {
+
+using multidevice_setup::mojom::Feature;
+using multidevice_setup::mojom::FeatureState;
+
+class CrosStateSenderTest : public testing::Test {
+ protected:
+  CrosStateSenderTest() = default;
+  ~CrosStateSenderTest() override = default;
+
+  CrosStateSenderTest(const CrosStateSender&) = delete;
+  CrosStateSenderTest& operator=(const CrosStateSender&) = delete;
+
+  // testing::Test:
+  void SetUp() override {
+    fake_message_sender_ = std::make_unique<FakeMessageSender>();
+    fake_connection_manager_ = std::make_unique<FakeConnectionManager>();
+    fake_multidevice_setup_client_ =
+        std::make_unique<multidevice_setup::FakeMultiDeviceSetupClient>();
+    cros_state_sender_ = std::make_unique<CrosStateSender>(
+        fake_message_sender_.get(), fake_connection_manager_.get(),
+        fake_multidevice_setup_client_.get());
+  }
+
+  std::unique_ptr<FakeMessageSender> fake_message_sender_;
+  std::unique_ptr<FakeConnectionManager> fake_connection_manager_;
+  std::unique_ptr<multidevice_setup::FakeMultiDeviceSetupClient>
+      fake_multidevice_setup_client_;
+
+ private:
+  std::unique_ptr<CrosStateSender> cros_state_sender_;
+};
+
+TEST_F(CrosStateSenderTest, UpdatesOnConnected) {
+  // Set notification feature to be enabled.
+  fake_multidevice_setup_client_->SetFeatureState(
+      Feature::kPhoneHubNotifications, FeatureState::kEnabledByUser);
+  // Expect no new messages since connection has not been established.
+  EXPECT_EQ(0u, fake_message_sender_->GetCrosStateCallCount());
+
+  // Update connection state to connecting.
+  fake_connection_manager_->SetStatus(ConnectionManager::Status::kConnecting);
+  // Connecting state does not trigger a request message.
+  EXPECT_EQ(0u, fake_message_sender_->GetCrosStateCallCount());
+
+  // Simulate connected state. Expect a new message to be sent.
+  fake_connection_manager_->SetStatus(ConnectionManager::Status::kConnected);
+  EXPECT_TRUE(fake_message_sender_->GetRecentCrosState());
+  EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
+
+  // Simulate disconnected state, this should not trigger a new request.
+  fake_connection_manager_->SetStatus(ConnectionManager::Status::kDisconnected);
+  EXPECT_TRUE(fake_message_sender_->GetRecentCrosState());
+  EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
+}
+
+TEST_F(CrosStateSenderTest, NotificationFeatureStateChanged) {
+  // Set connection state to be connected.
+  fake_connection_manager_->SetStatus(ConnectionManager::Status::kConnected);
+  // Expect new messages to be sent when connection state is connected.
+  EXPECT_FALSE(fake_message_sender_->GetRecentCrosState());
+  EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
+
+  // Simulate enabling notification feature state and expect cros state to be
+  // enabled.
+  fake_multidevice_setup_client_->SetFeatureState(
+      Feature::kPhoneHubNotifications, FeatureState::kEnabledByUser);
+  EXPECT_TRUE(fake_message_sender_->GetRecentCrosState());
+  EXPECT_EQ(2u, fake_message_sender_->GetCrosStateCallCount());
+
+  // Update a different feature state and expect that it did not affect the
+  // cros state.
+  fake_multidevice_setup_client_->SetFeatureState(
+      Feature::kSmartLock, FeatureState::kDisabledByUser);
+  EXPECT_TRUE(fake_message_sender_->GetRecentCrosState());
+  EXPECT_EQ(3u, fake_message_sender_->GetCrosStateCallCount());
+
+  // Simulate disabling notification feature state and expect cros state to be
+  // disabled.
+  fake_multidevice_setup_client_->SetFeatureState(
+      Feature::kPhoneHubNotifications, FeatureState::kDisabledByUser);
+  EXPECT_FALSE(fake_message_sender_->GetRecentCrosState());
+  EXPECT_EQ(4u, fake_message_sender_->GetCrosStateCallCount());
+}
+
+}  // namespace phonehub
+}  // namespace chromeos

chromeos/components/phonehub/phone_hub_manager_impl.cc

@@ -9,6 +9,7 @@
 #include "chromeos/components/phonehub/browser_tabs_model_provider.h"
 #include "chromeos/components/phonehub/connection_manager_impl.h"
 #include "chromeos/components/phonehub/connection_scheduler_impl.h"
+#include "chromeos/components/phonehub/cros_state_sender.h"
 #include "chromeos/components/phonehub/do_not_disturb_controller_impl.h"
 #include "chromeos/components/phonehub/feature_status_provider_impl.h"
 #include "chromeos/components/phonehub/find_my_device_controller_impl.h"
@@ -44,6 +45,10 @@ PhoneHubManagerImpl::PhoneHubManagerImpl(
           std::make_unique<MessageReceiverImpl>(connection_manager_.get())),
       message_sender_(
           std::make_unique<MessageSenderImpl>(connection_manager_.get())),
+      cros_state_sender_(
+          std::make_unique<CrosStateSender>(message_sender_.get(),
+                                            connection_manager_.get(),
+                                            multidevice_setup_client)),
       do_not_disturb_controller_(
           std::make_unique<DoNotDisturbControllerImpl>(message_sender_.get())),
       connection_scheduler_(std::make_unique<ConnectionSchedulerImpl>(
@@ -129,6 +134,7 @@ void PhoneHubManagerImpl::Shutdown() {
   find_my_device_controller_.reset();
   connection_scheduler_.reset();
   do_not_disturb_controller_.reset();
+  cros_state_sender_.reset();
   message_sender_.reset();
   message_receiver_.reset();
   feature_status_provider_.reset();

chromeos/components/phonehub/phone_hub_manager_impl.h

@@ -32,6 +32,7 @@ namespace phonehub {
 class BrowserTabsModelController;
 class BrowserTabsModelProvider;
 class ConnectionManager;
+class CrosStateSender;
 class MessageSender;
 class MessageReceiver;
 class MutablePhoneModel;
@@ -69,6 +70,7 @@ class PhoneHubManagerImpl : public PhoneHubManager, public KeyedService {
   std::unique_ptr<FeatureStatusProvider> feature_status_provider_;
   std::unique_ptr<MessageReceiver> message_receiver_;
   std::unique_ptr<MessageSender> message_sender_;
+  std::unique_ptr<CrosStateSender> cros_state_sender_;
   std::unique_ptr<DoNotDisturbController> do_not_disturb_controller_;
   std::unique_ptr<ConnectionScheduler> connection_scheduler_;
   std::unique_ptr<FindMyDeviceController> find_my_device_controller_;