[Sync:Sharing] Handle sync pause state.

Do not send messages to server while sync is in pause state.

Bug: 1045896
Change-Id: I3d4bcdcc9357836dc66ce30a107dab48b255960f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2020775Reviewed-by: Marc Treib <treib@chromium.org>
Reviewed-by: vitaliii <vitaliii@chromium.org>
Commit-Queue: Rushan Suleymanov <rushans@google.com>
Cr-Commit-Position: refs/heads/master@{#735415}

chrome/browser/BUILD.gn

@@ -1597,6 +1597,8 @@ jumbo_static_library("browser") {
     "sharing/sharing_message_bridge_impl.cc",
     "sharing/sharing_message_bridge_impl.h",
     "sharing/sharing_message_handler.h",
+    "sharing/sharing_message_model_type_controller.cc",
+    "sharing/sharing_message_model_type_controller.h",
     "sharing/sharing_message_sender.cc",
     "sharing/sharing_message_sender.h",
     "sharing/sharing_metrics.cc",

chrome/browser/sharing/sharing_message_model_type_controller.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 "chrome/browser/sharing/sharing_message_model_type_controller.h"
+
+#include <utility>
+
+#include "base/feature_list.h"
+#include "components/sync/driver/sync_auth_util.h"
+#include "components/sync/driver/sync_service.h"
+#include "google_apis/gaia/google_service_auth_error.h"
+
+SharingMessageModelTypeController::SharingMessageModelTypeController(
+    syncer::SyncService* sync_service,
+    std::unique_ptr<syncer::ModelTypeControllerDelegate>
+        delegate_for_full_sync_mode,
+    std::unique_ptr<syncer::ModelTypeControllerDelegate>
+        delegate_for_transport_mode)
+    : syncer::ModelTypeController(syncer::SHARING_MESSAGE,
+                                  std::move(delegate_for_full_sync_mode),
+                                  std::move(delegate_for_transport_mode)),
+      sync_service_(sync_service) {
+  // TODO(crbug.com/906995): Remove this observing mechanism once all sync
+  // datatypes are stopped by ProfileSyncService, when sync is paused.
+  sync_service_->AddObserver(this);
+}
+
+SharingMessageModelTypeController::~SharingMessageModelTypeController() {
+  sync_service_->RemoveObserver(this);
+}
+
+syncer::DataTypeController::PreconditionState
+SharingMessageModelTypeController::GetPreconditionState() const {
+  DCHECK(CalledOnValidThread());
+  return syncer::IsWebSignout(sync_service_->GetAuthError())
+             ? PreconditionState::kMustStopAndClearData
+             : PreconditionState::kPreconditionsMet;
+}
+
+void SharingMessageModelTypeController::OnStateChanged(
+    syncer::SyncService* sync) {
+  DCHECK(CalledOnValidThread());
+  // Most of these calls will be no-ops but SyncService handles that just fine.
+  sync_service_->DataTypePreconditionChanged(type());
+}

chrome/browser/sharing/sharing_message_model_type_controller.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 CHROME_BROWSER_SHARING_SHARING_MESSAGE_MODEL_TYPE_CONTROLLER_H_
+#define CHROME_BROWSER_SHARING_SHARING_MESSAGE_MODEL_TYPE_CONTROLLER_H_
+
+#include <memory>
+
+#include "components/sync/driver/model_type_controller.h"
+#include "components/sync/driver/sync_service_observer.h"
+
+namespace syncer {
+class SyncService;
+}  // namespace syncer
+
+// Controls syncing of SHARING_MESSAGE.
+class SharingMessageModelTypeController : public syncer::ModelTypeController,
+                                          public syncer::SyncServiceObserver {
+ public:
+  // The |delegate_for_full_sync_mode|, |delegate_for_transport_mode| and
+  // |sync_service| must not be null. Furthermore, |sync_service| must outlive
+  // this object.
+  SharingMessageModelTypeController(
+      syncer::SyncService* sync_service,
+      std::unique_ptr<syncer::ModelTypeControllerDelegate>
+          delegate_for_full_sync_mode,
+      std::unique_ptr<syncer::ModelTypeControllerDelegate>
+          delegate_for_transport_mode);
+  ~SharingMessageModelTypeController() override;
+  SharingMessageModelTypeController(const SharingMessageModelTypeController&) =
+      delete;
+  SharingMessageModelTypeController& operator=(
+      const SharingMessageModelTypeController&) = delete;
+
+  // DataTypeController overrides.
+  PreconditionState GetPreconditionState() const override;
+
+  // SyncServiceObserver implementation.
+  void OnStateChanged(syncer::SyncService* sync) override;
+
+ private:
+  syncer::SyncService* const sync_service_;
+};
+
+#endif  // CHROME_BROWSER_SHARING_SHARING_MESSAGE_MODEL_TYPE_CONTROLLER_H_

chrome/browser/sync/chrome_sync_client.cc

@@ -29,6 +29,7 @@
 #include "chrome/browser/security_events/security_event_recorder_factory.h"
 #include "chrome/browser/sharing/sharing_message_bridge.h"
 #include "chrome/browser/sharing/sharing_message_bridge_factory.h"
+#include "chrome/browser/sharing/sharing_message_model_type_controller.h"
 #include "chrome/browser/sync/bookmark_sync_service_factory.h"
 #include "chrome/browser/sync/device_info_sync_service_factory.h"
 #include "chrome/browser/sync/model_type_store_service_factory.h"
@@ -337,6 +338,22 @@ ChromeSyncClient::CreateDataTypeControllers(syncer::SyncService* sync_service) {
             delegate)));
   }
 
+  if (!disabled_types.Has(syncer::SHARING_MESSAGE)) {
+    // Forward both full-sync and transport-only modes to the same delegate,
+    // since behavior for SHARING_MESSAGE does not differ. They both do not
+    // store data on persistent storage.
+    syncer::ModelTypeControllerDelegate* delegate =
+        GetControllerDelegateForModelType(syncer::SHARING_MESSAGE).get();
+    controllers.push_back(std::make_unique<SharingMessageModelTypeController>(
+        sync_service,
+        /*delegate_for_full_sync_mode=*/
+        std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
+            delegate),
+        /*delegate_for_transport_mode=*/
+        std::make_unique<syncer::ForwardingModelTypeControllerDelegate>(
+            delegate)));
+  }
+
 #if BUILDFLAG(ENABLE_SUPERVISED_USERS)
   controllers.push_back(std::make_unique<SupervisedUserSyncModelTypeController>(
       syncer::SUPERVISED_USER_SETTINGS, profile_, dump_stack, this));

components/browser_sync/profile_sync_components_factory_impl.cc

@@ -354,18 +354,6 @@ ProfileSyncComponentsFactoryImpl::CreateCommonDataTypeControllers(
                     .get())));
   }
 
-#if !defined(OS_IOS)
-  if (!disabled_types.Has(syncer::SHARING_MESSAGE)) {
-    // Forward both full-sync and transport-only modes to the same delegate,
-    // since behavior for SHARING_MESSAGE does not differ. They both do not
-    // store data on persistent storage.
-    controllers.push_back(std::make_unique<ModelTypeController>(
-        syncer::SHARING_MESSAGE,
-        CreateForwardingControllerDelegate(syncer::SHARING_MESSAGE),
-        CreateForwardingControllerDelegate(syncer::SHARING_MESSAGE)));
-  }
-#endif  // !defined(OS_IOS)
-
   // Forward both full-sync and transport-only modes to the same delegate,
   // since behavior for USER_CONSENTS does not differ (they are always
   // persisted).