shared_tab_group_data_sync_bridge.cc

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/saved_tab_groups/shared_tab_group_data_sync_bridge.h"

#include <map>
#include <set>

#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/notimplemented.h"
#include "base/strings/utf_string_conversions.h"
#include "base/uuid.h"
#include "components/prefs/pref_service.h"
#include "components/saved_tab_groups/proto/shared_tab_group_data.pb.h"
#include "components/saved_tab_groups/saved_tab_group.h"
#include "components/saved_tab_groups/saved_tab_group_model.h"
#include "components/saved_tab_groups/saved_tab_group_tab.h"
#include "components/sync/base/client_tag_hash.h"
#include "components/sync/base/data_type.h"
#include "components/sync/base/deletion_origin.h"
#include "components/sync/base/unique_position.h"
#include "components/sync/model/data_type_local_change_processor.h"
#include "components/sync/model/in_memory_metadata_change_list.h"
#include "components/sync/model/metadata_batch.h"
#include "components/sync/model/metadata_change_list.h"
#include "components/sync/model/mutable_data_batch.h"
#include "components/sync/protocol/entity_data.h"
#include "components/sync/protocol/entity_specifics.pb.h"
#include "components/sync/protocol/shared_tab_group_data_specifics.pb.h"
#include "components/sync/protocol/unique_position.pb.h"

namespace tab_groups {

namespace {

tab_groups::TabGroupColorId SyncColorToTabGroupColor(
    const sync_pb::SharedTabGroup::Color color) { … }

sync_pb::SharedTabGroup_Color TabGroupColorToSyncColor(
    const tab_groups::TabGroupColorId color) { … }

base::Time TimeFromWindowsEpochMicros(int64_t time_windows_epoch_micros) { … }

sync_pb::SharedTabGroupDataSpecifics SharedTabGroupToSpecifics(
    const SavedTabGroup& group) { … }

SavedTabGroup SpecificsToSharedTabGroup(
    const sync_pb::SharedTabGroupDataSpecifics& specifics,
    const std::string& collaboration_id) { … }

SavedTabGroupTab SpecificsToSharedTabGroupTab(
    const sync_pb::SharedTabGroupDataSpecifics& specifics,
    size_t position) { … }

sync_pb::SharedTabGroupDataSpecifics SharedTabGroupTabToSpecifics(
    const SavedTabGroupTab& tab,
    sync_pb::UniquePosition unique_position) { … }

std::unique_ptr<syncer::EntityData> CreateEntityData(
    sync_pb::SharedTabGroupDataSpecifics specifics,
    const std::string& collaboration_id) { … }

void AddEntryToBatch(syncer::MutableDataBatch* batch,
                     sync_pb::SharedTabGroupDataSpecifics specifics,
                     const std::string& collaboration_id) { … }

std::string ExtractCollaborationId(
    const syncer::EntityMetadataMap& sync_metadata,
    const std::string& storage_key) { … }

// Parses stored entries and populates the result to the `on_load_callback`.
std::vector<sync_pb::SharedTabGroupDataSpecifics> LoadStoredEntries(
    const std::vector<proto::SharedTabGroupData>& stored_entries,
    SavedTabGroupModel* model,
    const syncer::EntityMetadataMap& sync_metadata,
    SharedTabGroupDataSyncBridge::SharedTabGroupLoadCallback on_load_callback) { … }

void StoreSpecifics(syncer::DataTypeStore::WriteBatch* write_batch,
                    sync_pb::SharedTabGroupDataSpecifics specifics) { … }

std::string StorageKeyForTab(const SavedTabGroupTab& tab) { … }

syncer::ClientTagHash ClientTagHashForTab(const SavedTabGroupTab& tab) { … }

std::string StorageKeyForTabInGroup(const SavedTabGroup& group,
                                    size_t tab_index) { … }

// Returns the preferred index for the existing tab. The adjustment is required
// in case the tab is moved to a larger index because tab positions get shifted
// be one.
// For example, if the tab is moved from a position 1 (`current_index`) before
// another tab at index 5 (`position_insert_before`), the new position for the
// tab being moved is 4.
size_t AdjustPreferredTabIndex(size_t position_insert_before,
                               size_t current_index) { … }

}  // namespace

SharedTabGroupDataSyncBridge::SharedTabGroupDataSyncBridge(
    SavedTabGroupModel* model,
    syncer::OnceDataTypeStoreFactory create_store_callback,
    std::unique_ptr<syncer::DataTypeLocalChangeProcessor> change_processor,
    PrefService* pref_service,
    SharedTabGroupLoadCallback on_load_callback)
    : … { … }

SharedTabGroupDataSyncBridge::~SharedTabGroupDataSyncBridge() { … }

std::unique_ptr<syncer::MetadataChangeList>
SharedTabGroupDataSyncBridge::CreateMetadataChangeList() { … }

std::optional<syncer::ModelError>
SharedTabGroupDataSyncBridge::MergeFullSyncData(
    std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
    syncer::EntityChangeList entity_data) { … }

std::optional<syncer::ModelError>
SharedTabGroupDataSyncBridge::ApplyIncrementalSyncChanges(
    std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
    syncer::EntityChangeList entity_changes) { … }

std::unique_ptr<syncer::DataBatch>
SharedTabGroupDataSyncBridge::GetDataForCommit(StorageKeyList storage_keys) { … }

std::unique_ptr<syncer::DataBatch>
SharedTabGroupDataSyncBridge::GetAllDataForDebugging() { … }

std::string SharedTabGroupDataSyncBridge::GetClientTag(
    const syncer::EntityData& entity_data) { … }

std::string SharedTabGroupDataSyncBridge::GetStorageKey(
    const syncer::EntityData& entity_data) { … }

bool SharedTabGroupDataSyncBridge::SupportsGetClientTag() const { … }

bool SharedTabGroupDataSyncBridge::SupportsGetStorageKey() const { … }

bool SharedTabGroupDataSyncBridge::SupportsIncrementalUpdates() const { … }

bool SharedTabGroupDataSyncBridge::SupportsUniquePositions() const { … }

sync_pb::UniquePosition SharedTabGroupDataSyncBridge::GetUniquePosition(
    const sync_pb::EntitySpecifics& specifics) const { … }

void SharedTabGroupDataSyncBridge::ApplyDisableSyncChanges(
    std::unique_ptr<syncer::MetadataChangeList> delete_metadata_change_list) { … }

sync_pb::EntitySpecifics
SharedTabGroupDataSyncBridge::TrimAllSupportedFieldsFromRemoteSpecifics(
    const sync_pb::EntitySpecifics& entity_specifics) const { … }

bool SharedTabGroupDataSyncBridge::IsEntityDataValid(
    const syncer::EntityData& entity_data) const { … }

void SharedTabGroupDataSyncBridge::SavedTabGroupAddedLocally(
    const base::Uuid& guid) { … }

void SharedTabGroupDataSyncBridge::SavedTabGroupUpdatedLocally(
    const base::Uuid& group_guid,
    const std::optional<base::Uuid>& tab_guid) { … }

void SharedTabGroupDataSyncBridge::SavedTabGroupRemovedLocally(
    const SavedTabGroup& removed_group) { … }

void SharedTabGroupDataSyncBridge::OnStoreCreated(
    SharedTabGroupLoadCallback on_load_callback,
    const std::optional<syncer::ModelError>& error,
    std::unique_ptr<syncer::DataTypeStore> store) { … }

void SharedTabGroupDataSyncBridge::OnReadAllDataAndMetadata(
    SharedTabGroupLoadCallback on_load_callback,
    const std::optional<syncer::ModelError>& error,
    std::unique_ptr<syncer::DataTypeStore::RecordList> entries,
    std::unique_ptr<syncer::MetadataBatch> metadata_batch) { … }

void SharedTabGroupDataSyncBridge::OnDatabaseSave(
    const std::optional<syncer::ModelError>& error) { … }

void SharedTabGroupDataSyncBridge::AddGroupToLocalStorage(
    const sync_pb::SharedTabGroupDataSpecifics& specifics,
    const std::string& collaboration_id,
    syncer::MetadataChangeList* metadata_change_list,
    syncer::DataTypeStore::WriteBatch* write_batch) { … }

void SharedTabGroupDataSyncBridge::AddTabToLocalStorage(
    const sync_pb::SharedTabGroupDataSpecifics& specifics,
    syncer::MetadataChangeList* metadata_change_list,
    syncer::DataTypeStore::WriteBatch* write_batch) { … }

void SharedTabGroupDataSyncBridge::DeleteDataFromLocalStorage(
    const std::string& storage_key,
    syncer::DataTypeStore::WriteBatch* write_batch) { … }

void SharedTabGroupDataSyncBridge::SendToSync(
    sync_pb::SharedTabGroupDataSpecifics specific,
    const std::string& collaboration_id,
    syncer::MetadataChangeList* metadata_change_list) { … }

void SharedTabGroupDataSyncBridge::UpsertEntitySpecifics(
    const sync_pb::SharedTabGroupDataSpecifics& specifics,
    const std::string& collaboration_id,
    syncer::DataTypeStore::WriteBatch* write_batch) { … }

void SharedTabGroupDataSyncBridge::ProcessTabLocalChange(
    const SavedTabGroup& group,
    const base::Uuid& tab_id,
    syncer::DataTypeStore::WriteBatch* write_batch) { … }

void SharedTabGroupDataSyncBridge::RemoveEntitySpecifics(
    const base::Uuid& guid,
    syncer::DataTypeStore::WriteBatch* write_batch) { … }

sync_pb::UniquePosition SharedTabGroupDataSyncBridge::CalculateUniquePosition(
    const SavedTabGroup& group,
    size_t tab_index) const { … }

size_t SharedTabGroupDataSyncBridge::PositionToInsertRemoteTab(
    const sync_pb::UniquePosition& remote_unique_position,
    const SavedTabGroup& group) const { … }

}  // namespace tab_groups
chromium/components/saved_tab_groups/shared_tab_group_data_sync_bridge.cc
