Allow SharingMessageHandler to be dynamically registered

Change-Id: I133d3fd7ceef23ce4fa4dd3dc5230761f067f440
Bug: 1043130
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2007694Reviewed-by: Richard Knoll <knollr@chromium.org>
Reviewed-by: Peter Beverloo <peter@chromium.org>
Commit-Queue: Alex Chau <alexchau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#732900}

chrome/browser/sharing/mock_sharing_service.cc

@@ -22,6 +22,7 @@ MockSharingService::MockSharingService()
               /*vapid_key_manager=*/nullptr),
           /*message_sender=*/nullptr,
           /*device_source=*/nullptr,
+          /*handler_registry=*/nullptr,
           std::make_unique<SharingFCMHandler>(/*gcm_driver=*/nullptr,
                                               /*sharing_fcm_sender=*/nullptr,
                                               /*sync_preference=*/nullptr,

chrome/browser/sharing/mock_sharing_service.h

@@ -5,6 +5,8 @@
 #ifndef CHROME_BROWSER_SHARING_MOCK_SHARING_SERVICE_H_
 #define CHROME_BROWSER_SHARING_MOCK_SHARING_SERVICE_H_
 
+#include "chrome/browser/sharing/proto/sharing_message.pb.h"
+#include "chrome/browser/sharing/sharing_message_handler.h"
 #include "chrome/browser/sharing/sharing_message_sender.h"
 #include "chrome/browser/sharing/sharing_service.h"
 
@@ -30,6 +32,15 @@ class MockSharingService : public SharingService {
       GetDeviceByGuid,
       std::unique_ptr<syncer::DeviceInfo>(const std::string& guid));
 
+  MOCK_METHOD2(
+      RegisterSharingHandler,
+      void(std::unique_ptr<SharingMessageHandler> handler,
+           chrome_browser_sharing::SharingMessage::PayloadCase payload_case));
+
+  MOCK_METHOD1(
+      UnregisterSharingHandler,
+      void(chrome_browser_sharing::SharingMessage::PayloadCase payload_case));
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSharingService);
 };

chrome/browser/sharing/sharing_fcm_handler.cc

@@ -48,15 +48,14 @@ std::string GetStrippedMessageId(const std::string& message_id) {
 
 }  // namespace
 
-SharingFCMHandler::SharingFCMHandler(
-    gcm::GCMDriver* gcm_driver,
-    SharingFCMSender* sharing_fcm_sender,
-    SharingSyncPreference* sync_preference,
-    std::unique_ptr<SharingHandlerRegistry> handler_registry)
+SharingFCMHandler::SharingFCMHandler(gcm::GCMDriver* gcm_driver,
+                                     SharingFCMSender* sharing_fcm_sender,
+                                     SharingSyncPreference* sync_preference,
+                                     SharingHandlerRegistry* handler_registry)
     : gcm_driver_(gcm_driver),
       sharing_fcm_sender_(sharing_fcm_sender),
       sync_preference_(sync_preference),
-      handler_registry_(std::move(handler_registry)) {}
+      handler_registry_(handler_registry) {}
 
 SharingFCMHandler::~SharingFCMHandler() {
   StopListening();

chrome/browser/sharing/sharing_fcm_handler.h

@@ -35,7 +35,7 @@ class SharingFCMHandler : public gcm::GCMAppHandler {
   SharingFCMHandler(gcm::GCMDriver* gcm_driver,
                     SharingFCMSender* sharing_fcm_sender,
                     SharingSyncPreference* sync_preference,
-                    std::unique_ptr<SharingHandlerRegistry> handler_registry);
+                    SharingHandlerRegistry* handler_registry);
   ~SharingFCMHandler() override;
 
   // Registers itself as app handler for sharing messages.
@@ -85,7 +85,7 @@ class SharingFCMHandler : public gcm::GCMAppHandler {
   gcm::GCMDriver* const gcm_driver_;
   SharingFCMSender* sharing_fcm_sender_;
   SharingSyncPreference* sync_preference_;
-  std::unique_ptr<SharingHandlerRegistry> handler_registry_;
+  SharingHandlerRegistry* handler_registry_;
 
   bool is_listening_ = false;
 

chrome/browser/sharing/sharing_fcm_handler_unittest.cc

@@ -8,6 +8,7 @@
 
 #include "chrome/browser/sharing/features.h"
 #include "chrome/browser/sharing/sharing_constants.h"
+#include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_handler_registry.h"
 #include "chrome/browser/sharing/sharing_message_handler.h"
@@ -52,6 +53,19 @@ class FakeSharingHandlerRegistry : public SharingHandlerRegistry {
     handler_map_[payload_case] = handler;
   }
 
+  void RegisterSharingHandler(
+      std::unique_ptr<SharingMessageHandler> handler,
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case)
+      override {
+    NOTIMPLEMENTED();
+  }
+
+  void UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case)
+      override {
+    NOTIMPLEMENTED();
+  }
+
  private:
   std::map<SharingMessage::PayloadCase, SharingMessageHandler*> handler_map_;
 };
@@ -88,11 +102,9 @@ class SharingFCMHandlerTest : public testing::Test {
   SharingFCMHandlerTest() {
     sync_prefs_ = std::make_unique<SharingSyncPreference>(
         &prefs_, &fake_device_info_sync_service_);
-    auto handler_registry = std::make_unique<FakeSharingHandlerRegistry>();
-    handler_registry_ = handler_registry.get();
     sharing_fcm_handler_ = std::make_unique<SharingFCMHandler>(
         &fake_gcm_driver_, &mock_sharing_fcm_sender_, sync_prefs_.get(),
-        std::move(handler_registry));
+        &handler_registry_);
     fake_device_info_ = std::make_unique<syncer::DeviceInfo>(
         kSenderGuid, kSenderName, "chrome_version", "user_agent",
         sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id",
@@ -117,7 +129,7 @@ class SharingFCMHandlerTest : public testing::Test {
     return incoming_message;
   }
 
-  FakeSharingHandlerRegistry* handler_registry_ = nullptr;
+  FakeSharingHandlerRegistry handler_registry_;
 
   testing::NiceMock<MockSharingMessageHandler> mock_sharing_message_handler_;
   testing::NiceMock<MockSharingFCMSender> mock_sharing_fcm_sender_;
@@ -160,8 +172,8 @@ TEST_F(SharingFCMHandlerTest, AckMessageHandler) {
               OnMessage(ProtoEquals(sharing_message), _));
   EXPECT_CALL(mock_sharing_fcm_sender_, SendMessageToTargetInfo(_, _, _, _))
       .Times(0);
-  handler_registry_->SetSharingHandler(SharingMessage::kAckMessage,
-                                       &mock_sharing_message_handler_);
+  handler_registry_.SetSharingHandler(SharingMessage::kAckMessage,
+                                      &mock_sharing_message_handler_);
   sharing_fcm_handler_->OnMessage(kTestAppId, incoming_message);
 }
 
@@ -201,8 +213,8 @@ TEST_F(SharingFCMHandlerTest, PingMessageHandler) {
           DeviceMatcher(),
           Eq(base::TimeDelta::FromSeconds(kSharingAckMessageTTLSeconds.Get())),
           ProtoEquals(sharing_ack_message), _));
-  handler_registry_->SetSharingHandler(SharingMessage::kPingMessage,
-                                       &mock_sharing_message_handler_);
+  handler_registry_.SetSharingHandler(SharingMessage::kPingMessage,
+                                      &mock_sharing_message_handler_);
   sharing_fcm_handler_->OnMessage(kTestAppId, incoming_message);
 
   // Tests OnMessage flow in SharingFCMHandler after registered handler is
@@ -210,7 +222,7 @@ TEST_F(SharingFCMHandlerTest, PingMessageHandler) {
   EXPECT_CALL(mock_sharing_message_handler_, OnMessage(_, _)).Times(0);
   EXPECT_CALL(mock_sharing_fcm_sender_, SendMessageToTargetInfo(_, _, _, _))
       .Times(0);
-  handler_registry_->SetSharingHandler(SharingMessage::kPingMessage, nullptr);
+  handler_registry_.SetSharingHandler(SharingMessage::kPingMessage, nullptr);
   sharing_fcm_handler_->OnMessage(kTestAppId, incoming_message);
 }
 
@@ -245,8 +257,8 @@ TEST_F(SharingFCMHandlerTest, PingMessageHandlerWithResponse) {
           DeviceMatcher(),
           Eq(base::TimeDelta::FromSeconds(kSharingAckMessageTTLSeconds.Get())),
           ProtoEquals(sharing_ack_message), _));
-  handler_registry_->SetSharingHandler(SharingMessage::kPingMessage,
-                                       &mock_sharing_message_handler_);
+  handler_registry_.SetSharingHandler(SharingMessage::kPingMessage,
+                                      &mock_sharing_message_handler_);
   sharing_fcm_handler_->OnMessage(kTestAppId, incoming_message);
 }
 
@@ -280,8 +292,8 @@ TEST_F(SharingFCMHandlerTest, PingMessageHandlerSecondaryUser) {
           DeviceMatcher(),
           Eq(base::TimeDelta::FromSeconds(kSharingAckMessageTTLSeconds.Get())),
           ProtoEquals(sharing_ack_message), _));
-  handler_registry_->SetSharingHandler(SharingMessage::kPingMessage,
-                                       &mock_sharing_message_handler_);
+  handler_registry_.SetSharingHandler(SharingMessage::kPingMessage,
+                                      &mock_sharing_message_handler_);
   sharing_fcm_handler_->OnMessage(kTestAppId, incoming_message);
 }
 
@@ -316,7 +328,7 @@ TEST_F(SharingFCMHandlerTest, PingMessageHandlerWithFCMChannelConfiguration) {
           DeviceMatcher(),
           Eq(base::TimeDelta::FromSeconds(kSharingAckMessageTTLSeconds.Get())),
           ProtoEquals(sharing_ack_message), _));
-  handler_registry_->SetSharingHandler(SharingMessage::kPingMessage,
-                                       &mock_sharing_message_handler_);
+  handler_registry_.SetSharingHandler(SharingMessage::kPingMessage,
+                                      &mock_sharing_message_handler_);
   sharing_fcm_handler_->OnMessage(kTestAppId, incoming_message);
 }

chrome/browser/sharing/sharing_handler_registry.h

@@ -17,6 +17,15 @@ class SharingHandlerRegistry {
   // Gets SharingMessageHandler registered for |payload_case|.
   virtual SharingMessageHandler* GetSharingHandler(
       chrome_browser_sharing::SharingMessage::PayloadCase payload_case) = 0;
+
+  // Register SharingMessageHandler for |payload_case|.
+  virtual void RegisterSharingHandler(
+      std::unique_ptr<SharingMessageHandler> handler,
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case) = 0;
+
+  // Unregister SharingMessageHandler for |payload_case|.
+  virtual void UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case) = 0;
 };
 
 #endif  // CHROME_BROWSER_SHARING_SHARING_HANDLER_REGISTRY_H_

chrome/browser/sharing/sharing_handler_registry_impl.cc

@@ -86,7 +86,14 @@ SharingHandlerRegistryImpl::~SharingHandlerRegistryImpl() = default;
 SharingMessageHandler* SharingHandlerRegistryImpl::GetSharingHandler(
     chrome_browser_sharing::SharingMessage::PayloadCase payload_case) {
   auto it = handler_map_.find(payload_case);
-  return it != handler_map_.end() ? it->second : nullptr;
+  if (it != handler_map_.end())
+    return it->second;
+
+  auto extra_it = extra_handler_map_.find(payload_case);
+  if (extra_it != extra_handler_map_.end())
+    return extra_it->second.get();
+
+  return nullptr;
 }
 
 void SharingHandlerRegistryImpl::AddSharingHandler(
@@ -105,3 +112,20 @@ void SharingHandlerRegistryImpl::AddSharingHandler(
 
   handlers_.push_back(std::move(handler));
 }
+
+void SharingHandlerRegistryImpl::RegisterSharingHandler(
+    std::unique_ptr<SharingMessageHandler> handler,
+    chrome_browser_sharing::SharingMessage::PayloadCase payload_case) {
+  DCHECK(handler) << "Received request to add null handler";
+  DCHECK(!GetSharingHandler(payload_case));
+  DCHECK(payload_case !=
+         chrome_browser_sharing::SharingMessage::PAYLOAD_NOT_SET)
+      << "Incorrect payload type specified for handler";
+
+  extra_handler_map_[payload_case] = std::move(handler);
+}
+
+void SharingHandlerRegistryImpl::UnregisterSharingHandler(
+    chrome_browser_sharing::SharingMessage::PayloadCase payload_case) {
+  extra_handler_map_.erase(payload_case);
+}

chrome/browser/sharing/sharing_handler_registry_impl.h

@@ -37,17 +37,33 @@ class SharingHandlerRegistryImpl : public SharingHandlerRegistry {
       chrome_browser_sharing::SharingMessage::PayloadCase payload_case)
       override;
 
+  // Register SharingMessageHandler for |payload_case|.
+  void RegisterSharingHandler(
+      std::unique_ptr<SharingMessageHandler> handler,
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case)
+      override;
+
+  // Unregister SharingMessageHandler for |payload_case|.
+  void UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case)
+      override;
+
  private:
-  // Registers |handler| for handling |payload_cases| SharingMessages.
+  // Registers |handler| for handling |payload_cases| SharingMessages. No
+  // handlers should have been registered with |payload_cases|.
   void AddSharingHandler(
       std::unique_ptr<SharingMessageHandler> handler,
       std::set<chrome_browser_sharing::SharingMessage::PayloadCase>
           payload_cases);
 
+ private:
   std::vector<std::unique_ptr<SharingMessageHandler>> handlers_;
   std::map<chrome_browser_sharing::SharingMessage::PayloadCase,
            SharingMessageHandler*>
       handler_map_;
+  std::map<chrome_browser_sharing::SharingMessage::PayloadCase,
+           std::unique_ptr<SharingMessageHandler>>
+      extra_handler_map_;
 };
 
 #endif  // CHROME_BROWSER_SHARING_SHARING_HANDLER_REGISTRY_IMPL_H_

chrome/browser/sharing/sharing_handler_registry_impl_unittest.cc

@@ -8,10 +8,20 @@
 #include <memory>
 
 #include "chrome/browser/sharing/sharing_device_registration.h"
+#include "chrome/browser/sharing/sharing_message_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+class FakeMessageHandler : public SharingMessageHandler {
+ public:
+  FakeMessageHandler() = default;
+  ~FakeMessageHandler() override = default;
+
+  void OnMessage(chrome_browser_sharing::SharingMessage message,
+                 SharingMessageHandler::DoneCallback done_callback) override {}
+};
+
 class FakeSharingDeviceRegistration : public SharingDeviceRegistration {
  public:
   FakeSharingDeviceRegistration()
@@ -53,6 +63,12 @@ TEST_F(SharingHandlerRegistryImplTest, SharedClipboard_IsAdded) {
   auto handler_registry = CreateHandlerRegistry();
   EXPECT_TRUE(handler_registry->GetSharingHandler(
       chrome_browser_sharing::SharingMessage::kSharedClipboardMessage));
+
+  // Default handlers cannot be removed.
+  handler_registry->UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage);
+  EXPECT_TRUE(handler_registry->GetSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage));
 }
 
 TEST_F(SharingHandlerRegistryImplTest, SharedClipboard_NotAdded) {
@@ -61,3 +77,21 @@ TEST_F(SharingHandlerRegistryImplTest, SharedClipboard_NotAdded) {
   EXPECT_FALSE(handler_registry->GetSharingHandler(
       chrome_browser_sharing::SharingMessage::kSharedClipboardMessage));
 }
+
+TEST_F(SharingHandlerRegistryImplTest, SharedClipboard_AddRemoveManually) {
+  sharing_device_registration_.SetIsSharedClipboardSupported(false);
+  auto handler_registry = CreateHandlerRegistry();
+  EXPECT_FALSE(handler_registry->GetSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage));
+
+  handler_registry->RegisterSharingHandler(
+      std::make_unique<FakeMessageHandler>(),
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage);
+  EXPECT_TRUE(handler_registry->GetSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage));
+
+  handler_registry->UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage);
+  EXPECT_FALSE(handler_registry->GetSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage));
+}

chrome/browser/sharing/sharing_service.cc

@@ -14,6 +14,8 @@
 #include "chrome/browser/sharing/sharing_device_registration_result.h"
 #include "chrome/browser/sharing/sharing_device_source.h"
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
+#include "chrome/browser/sharing/sharing_handler_registry.h"
+#include "chrome/browser/sharing/sharing_message_handler.h"
 #include "chrome/browser/sharing/sharing_metrics.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
 #include "chrome/browser/sharing/sharing_utils.h"
@@ -28,6 +30,7 @@ SharingService::SharingService(
     std::unique_ptr<SharingDeviceRegistration> sharing_device_registration,
     std::unique_ptr<SharingMessageSender> message_sender,
     std::unique_ptr<SharingDeviceSource> device_source,
+    std::unique_ptr<SharingHandlerRegistry> handler_registry,
     std::unique_ptr<SharingFCMHandler> fcm_handler,
     syncer::SyncService* sync_service)
     : sync_prefs_(std::move(sync_prefs)),
@@ -35,6 +38,7 @@ SharingService::SharingService(
       sharing_device_registration_(std::move(sharing_device_registration)),
       message_sender_(std::move(message_sender)),
       device_source_(std::move(device_source)),
+      handler_registry_(std::move(handler_registry)),
       fcm_handler_(std::move(fcm_handler)),
       sync_service_(sync_service),
       backoff_entry_(&kRetryBackoffPolicy),
@@ -81,6 +85,17 @@ void SharingService::SendMessageToDevice(
       SharingMessageSender::DelegateType::kFCM, std::move(callback));
 }
 
+void SharingService::RegisterSharingHandler(
+    std::unique_ptr<SharingMessageHandler> handler,
+    chrome_browser_sharing::SharingMessage::PayloadCase payload_case) {
+  handler_registry_->RegisterSharingHandler(std::move(handler), payload_case);
+}
+
+void SharingService::UnregisterSharingHandler(
+    chrome_browser_sharing::SharingMessage::PayloadCase payload_case) {
+  handler_registry_->UnregisterSharingHandler(payload_case);
+}
+
 SharingDeviceSource* SharingService::GetDeviceSource() const {
   return device_source_.get();
 }

chrome/browser/sharing/sharing_service.h

@@ -33,6 +33,8 @@ class SyncService;
 }  // namespace syncer
 
 class SharingFCMHandler;
+class SharingHandlerRegistry;
+class SharingMessageHandler;
 class SharingSyncPreference;
 class VapidKeyManager;
 class SharingDeviceSource;
@@ -61,6 +63,7 @@ class SharingService : public KeyedService, public syncer::SyncServiceObserver {
       std::unique_ptr<SharingDeviceRegistration> sharing_device_registration,
       std::unique_ptr<SharingMessageSender> message_sender,
       std::unique_ptr<SharingDeviceSource> device_source,
+      std::unique_ptr<SharingHandlerRegistry> handler_registry,
       std::unique_ptr<SharingFCMHandler> fcm_handler,
       syncer::SyncService* sync_service);
   SharingService(const SharingService&) = delete;
@@ -89,6 +92,15 @@ class SharingService : public KeyedService, public syncer::SyncServiceObserver {
       chrome_browser_sharing::SharingMessage message,
       SharingMessageSender::ResponseCallback callback);
 
+  // Register SharingMessageHandler for |payload_cases|.
+  void RegisterSharingHandler(
+      std::unique_ptr<SharingMessageHandler> handler,
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case);
+
+  // Unregister SharingMessageHandler for |payload_case|.
+  void UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::PayloadCase payload_case);
+
   // Used to register devices with required capabilities in tests.
   void RegisterDeviceInTesting(
       std::set<sync_pb::SharingSpecificFields_EnabledFeatures> enabled_features,
@@ -129,6 +141,7 @@ class SharingService : public KeyedService, public syncer::SyncServiceObserver {
   std::unique_ptr<SharingDeviceRegistration> sharing_device_registration_;
   std::unique_ptr<SharingMessageSender> message_sender_;
   std::unique_ptr<SharingDeviceSource> device_source_;
+  std::unique_ptr<SharingHandlerRegistry> handler_registry_;
   std::unique_ptr<SharingFCMHandler> fcm_handler_;
 
   syncer::SyncService* sync_service_;

chrome/browser/sharing/sharing_service_factory.cc

@@ -132,13 +132,13 @@ KeyedService* SharingServiceFactory::BuildServiceInstanceFor(
       profile, sharing_device_registration.get(), sharing_message_sender.get(),
       device_source.get(), sms_fetcher);
   auto fcm_handler = std::make_unique<SharingFCMHandler>(
-      gcm_driver, fcm_sender_ptr, sync_prefs.get(),
-      std::move(handler_registry));
+      gcm_driver, fcm_sender_ptr, sync_prefs.get(), handler_registry.get());
 
   return new SharingService(
       std::move(sync_prefs), std::move(vapid_key_manager),
       std::move(sharing_device_registration), std::move(sharing_message_sender),
-      std::move(device_source), std::move(fcm_handler), sync_service);
+      std::move(device_source), std::move(handler_registry),
+      std::move(fcm_handler), sync_service);
 }
 
 content::BrowserContext* SharingServiceFactory::GetBrowserContextToUse(

chrome/browser/sharing/sharing_service_unittest.cc

@@ -22,6 +22,7 @@
 #include "chrome/browser/sharing/sharing_fcm_handler.h"
 #include "chrome/browser/sharing/sharing_fcm_sender.h"
 #include "chrome/browser/sharing/sharing_handler_registry.h"
+#include "chrome/browser/sharing/sharing_message_handler.h"
 #include "chrome/browser/sharing/sharing_sync_preference.h"
 #include "chrome/browser/sharing/vapid_key_manager.h"
 #include "components/gcm_driver/crypto/gcm_encryption_provider.h"
@@ -56,6 +57,24 @@ class MockInstanceIDDriver : public instance_id::InstanceIDDriver {
   DISALLOW_COPY_AND_ASSIGN(MockInstanceIDDriver);
 };
 
+class MockSharingHandlerRegistry : public SharingHandlerRegistry {
+ public:
+  MockSharingHandlerRegistry() = default;
+  ~MockSharingHandlerRegistry() override = default;
+
+  MOCK_METHOD1(
+      GetSharingHandler,
+      SharingMessageHandler*(
+          chrome_browser_sharing::SharingMessage::PayloadCase payload_case));
+  MOCK_METHOD2(
+      RegisterSharingHandler,
+      void(std::unique_ptr<SharingMessageHandler> handler,
+           chrome_browser_sharing::SharingMessage::PayloadCase payload_case));
+  MOCK_METHOD1(
+      UnregisterSharingHandler,
+      void(chrome_browser_sharing::SharingMessage::PayloadCase payload_case));
+};
+
 class MockSharingFCMHandler : public SharingFCMHandler {
   using SharingMessage = chrome_browser_sharing::SharingMessage;
 
@@ -153,6 +172,7 @@ class SharingServiceTest : public testing::Test {
         /* pref_service= */ nullptr, sync_prefs_, &mock_instance_id_driver_,
         vapid_key_manager_,
         fake_device_info_sync_service.GetLocalDeviceInfoProvider());
+    handler_registry_ = new testing::NiceMock<MockSharingHandlerRegistry>();
     fcm_handler_ = new testing::NiceMock<MockSharingFCMHandler>();
     device_source_ = new testing::NiceMock<MockSharingDeviceSource>();
     sharing_message_sender_ = new testing::NiceMock<MockSharingMessageSender>();
@@ -200,8 +220,8 @@ class SharingServiceTest : public testing::Test {
           base::WrapUnique(sync_prefs_), base::WrapUnique(vapid_key_manager_),
           base::WrapUnique(sharing_device_registration_),
           base::WrapUnique(sharing_message_sender_),
-          base::WrapUnique(device_source_), base::WrapUnique(fcm_handler_),
-          &test_sync_service_);
+          base::WrapUnique(device_source_), base::WrapUnique(handler_registry_),
+          base::WrapUnique(fcm_handler_), &test_sync_service_);
     }
     task_environment_.RunUntilIdle();
     return sharing_service_.get();
@@ -216,6 +236,7 @@ class SharingServiceTest : public testing::Test {
   sync_preferences::TestingPrefServiceSyncable prefs_;
 
   testing::NiceMock<MockInstanceIDDriver> mock_instance_id_driver_;
+  testing::NiceMock<MockSharingHandlerRegistry>* handler_registry_;
   testing::NiceMock<MockSharingFCMHandler>* fcm_handler_;
   testing::NiceMock<MockSharingDeviceSource>* device_source_;
 
@@ -590,3 +611,18 @@ TEST_F(SharingServiceTest, GetDeviceByGuid) {
       GetSharingService()->GetDeviceByGuid(guid);
   EXPECT_EQ("Dell Computer sno one", device_info->client_name());
 }
+
+TEST_F(SharingServiceTest, AddSharingHandler) {
+  EXPECT_CALL(*handler_registry_,
+              RegisterSharingHandler(testing::_, testing::_))
+      .Times(1);
+  GetSharingService()->RegisterSharingHandler(
+      nullptr, chrome_browser_sharing::SharingMessage::kSharedClipboardMessage);
+}
+
+TEST_F(SharingServiceTest, RemoveSharingHandler) {
+  EXPECT_CALL(*handler_registry_, UnregisterSharingHandler(testing::_))
+      .Times(1);
+  GetSharingService()->UnregisterSharingHandler(
+      chrome_browser_sharing::SharingMessage::kSharedClipboardMessage);
+}