components/sync/model_impl/syncable_service_based_bridge.h

// 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.

#ifndef COMPONENTS_SYNC_MODEL_IMPL_SYNCABLE_SERVICE_BASED_BRIDGE_H_
#define COMPONENTS_SYNC_MODEL_IMPL_SYNCABLE_SERVICE_BASED_BRIDGE_H_

#include <map>
#include <memory>
#include <string>

#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/sequence_checker.h"
#include "components/sync/model/model_error.h"
#include "components/sync/model/model_type_store.h"
#include "components/sync/model/model_type_sync_bridge.h"
#include "components/sync/model/sync_change_processor.h"

namespace sync_pb {
class EntitySpecifics;
class PersistedEntityData;
}  // namespace sync_pb

namespace syncer {

class MetadataBatch;
class ModelTypeChangeProcessor;
class SyncableService;

// Implementation of ModelTypeSyncBridge that allows integrating legacy
// datatypes that implement SyncableService. Internally, it uses a database to
// persist and mimic the legacy directory's behavior, but as opposed to the
// legacy directory, it's not exposed anywhere outside this bridge, and is
// considered an implementation detail.
class SyncableServiceBasedBridge : public ModelTypeSyncBridge {
 public:
  using InMemoryStore = std::map<std::string, sync_pb::PersistedEntityData>;

  // Used for passwords only.
  // TODO(crbug.com/856941): Remove when PASSWORDS are migrated to USS, which
  // will likely make this API unnecessary.
  class ModelCryptographer
      : public base::RefCountedThreadSafe<ModelCryptographer> {
   public:
    ModelCryptographer();

    virtual base::Optional<ModelError> Decrypt(
        sync_pb::EntitySpecifics* specifics) = 0;
    virtual base::Optional<ModelError> Encrypt(
        sync_pb::EntitySpecifics* specifics) = 0;

   protected:
    virtual ~ModelCryptographer();

   private:
    friend class base::RefCountedThreadSafe<ModelCryptographer>;

    DISALLOW_COPY_AND_ASSIGN(ModelCryptographer);
  };

  // Pointers must not be null and |syncable_service| must outlive this object.
  SyncableServiceBasedBridge(
      ModelType type,
      OnceModelTypeStoreFactory store_factory,
      std::unique_ptr<ModelTypeChangeProcessor> change_processor,
      SyncableService* syncable_service,
      scoped_refptr<ModelCryptographer> cryptographer = nullptr);
  ~SyncableServiceBasedBridge() override;

  // ModelTypeSyncBridge implementation.
  void OnSyncStarting(const DataTypeActivationRequest& request) override;
  std::unique_ptr<MetadataChangeList> CreateMetadataChangeList() override;
  base::Optional<ModelError> MergeSyncData(
      std::unique_ptr<MetadataChangeList> metadata_change_list,
      EntityChangeList entity_change_list) override;
  base::Optional<ModelError> ApplySyncChanges(
      std::unique_ptr<MetadataChangeList> metadata_change_list,
      EntityChangeList entity_change_list) override;
  void GetData(StorageKeyList storage_keys, DataCallback callback) override;
  void GetAllDataForDebugging(DataCallback callback) override;
  std::string GetClientTag(const EntityData& entity_data) override;
  std::string GetStorageKey(const EntityData& entity_data) override;
  bool SupportsGetClientTag() const override;
  bool SupportsGetStorageKey() const override;
  ConflictResolution ResolveConflict(
      const EntityData& local_data,
      const EntityData& remote_data) const override;
  StopSyncResponse ApplyStopSyncChanges(
      std::unique_ptr<MetadataChangeList> delete_metadata_change_list) override;
  size_t EstimateSyncOverheadMemoryUsage() const override;
  base::Optional<ModelError> ApplySyncChangesWithNewEncryptionRequirements(
      std::unique_ptr<MetadataChangeList> metadata_change_list,
      EntityChangeList entity_changes) override;

  // For testing.
  static std::unique_ptr<SyncChangeProcessor>
  CreateLocalChangeProcessorForTesting(ModelType type,
                                       ModelTypeStore* store,
                                       InMemoryStore* in_memory_store,
                                       ModelTypeChangeProcessor* other);

 private:
  void OnStoreCreated(const base::Optional<ModelError>& error,
                      std::unique_ptr<ModelTypeStore> store);
  void OnReadAllDataForInit(std::unique_ptr<InMemoryStore> in_memory_store,
                            const base::Optional<ModelError>& error);
  void OnReadAllMetadataForInit(const base::Optional<ModelError>& error,
                                std::unique_ptr<MetadataBatch> metadata_batch);
  base::Optional<ModelError> MaybeStartSyncableService() WARN_UNUSED_RESULT;
  base::Optional<ModelError> StoreAndConvertRemoteChanges(
      std::unique_ptr<ModelTypeStore::WriteBatch> batch,
      EntityChangeList input_entity_change_list,
      SyncChangeList* output_sync_change_list) WARN_UNUSED_RESULT;
  void ReportErrorIfSet(const base::Optional<ModelError>& error);
  base::Optional<ModelError> ReencryptEverything(
      ModelTypeStore::WriteBatch* batch);
  base::Optional<ModelError> ApplySyncChangesWithBatch(
      std::unique_ptr<MetadataChangeList> metadata_change_list,
      EntityChangeList entity_change_list,
      std::unique_ptr<ModelTypeStore::WriteBatch> batch);
  void RecordAssociationTime(base::TimeDelta time) const;

  const ModelType type_;
  SyncableService* const syncable_service_;
  const scoped_refptr<ModelCryptographer> cryptographer_;
  OnceModelTypeStoreFactory store_factory_;

  std::unique_ptr<ModelTypeStore> store_;
  bool syncable_service_started_;

  // In-memory copy of |store_|, needed for remote deletions, because we need to
  // provide specifics of the deleted entity to the SyncableService.
  InMemoryStore in_memory_store_;

  SEQUENCE_CHECKER(sequence_checker_);

  base::WeakPtrFactory<SyncableServiceBasedBridge> weak_ptr_factory_;

  DISALLOW_COPY_AND_ASSIGN(SyncableServiceBasedBridge);
};

}  // namespace syncer

#endif  // COMPONENTS_SYNC_MODEL_IMPL_SYNCABLE_SERVICE_BASED_BRIDGE_H_