chrome/browser/extensions/sync/sync_bundle.cc

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

#include "chrome/browser/extensions/sync/sync_bundle.h"

#include <utility>
#include <vector>

#include "base/location.h"
#include "chrome/browser/extensions/extension_util.h"
#include "chrome/browser/extensions/sync/extension_sync_data.h"
#include "chrome/browser/extensions/sync/extension_sync_service.h"
#include "extensions/buildflags/buildflags.h"
#include "extensions/common/extension.h"

static_assert(BUILDFLAG(ENABLE_EXTENSIONS_CORE));

namespace extensions {

SyncBundle::SyncBundle() = default;
SyncBundle::~SyncBundle() = default;

void SyncBundle::StartSyncing(
    std::unique_ptr<syncer::SyncChangeProcessor> sync_processor) {
  sync_processor_ = std::move(sync_processor);
}

void SyncBundle::Reset() {
  sync_processor_.reset();
  synced_extensions_.clear();
  pending_sync_data_.clear();
}

bool SyncBundle::IsSyncing() const {
  return sync_processor_ != nullptr;
}

void SyncBundle::PushSyncDataMap(
    const std::map<ExtensionId, syncer::SyncData>& sync_data_per_extension) {
  syncer::SyncChangeList sync_change_list;
  for (const auto& extension_id_and_sync_data : sync_data_per_extension) {
    sync_change_list.push_back(CreateSyncChange(
        extension_id_and_sync_data.first, extension_id_and_sync_data.second));

    AddSyncedExtension(extension_id_and_sync_data.second);
  }

  PushSyncChanges(sync_change_list);
}

void SyncBundle::PushSyncDeletion(const ExtensionId& extension_id,
                                  const syncer::SyncData& sync_data) {
  if (!HasSyncedExtension(extension_id)) {
    return;
  }

  RemoveSyncedExtension(extension_id);
  PushSyncChanges(syncer::SyncChangeList(
      1, syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_DELETE,
                            sync_data)));
}

void SyncBundle::PushSyncAddOrUpdate(const ExtensionId& extension_id,
                                     const syncer::SyncData& sync_data) {
  PushSyncChanges(
      syncer::SyncChangeList(1, CreateSyncChange(extension_id, sync_data)));
  AddSyncedExtension(sync_data);
  // Now sync and local state agree. If we had a pending install from sync,
  // clear it now.
  pending_sync_data_.erase(extension_id);
}

void SyncBundle::ApplySyncData(const ExtensionSyncData& extension_sync_data) {
  if (extension_sync_data.uninstalled()) {
    RemoveSyncedExtension(extension_sync_data.id());
  } else {
    AddSyncedExtension(extension_sync_data);
  }
}

bool SyncBundle::HasPendingExtensionData(const ExtensionId& id) const {
  return pending_sync_data_.find(id) != pending_sync_data_.end();
}

void SyncBundle::AddPendingExtensionData(
    const ExtensionSyncData& extension_sync_data) {
  pending_sync_data_.insert(
      std::make_pair(extension_sync_data.id(), extension_sync_data));
}

std::vector<ExtensionSyncData> SyncBundle::GetPendingExtensionData() const {
  std::vector<ExtensionSyncData> pending_extensions;
  pending_extensions.reserve(pending_sync_data_.size());
  for (const auto& data : pending_sync_data_) {
    pending_extensions.push_back(data.second);
  }

  return pending_extensions;
}

std::vector<ExtensionSyncData> SyncBundle::GetSyncedExtensionData() const {
  std::vector<ExtensionSyncData> synced_extension_data;
  synced_extension_data.reserve(synced_extensions_.size());
  for (const auto& data : synced_extensions_) {
    synced_extension_data.push_back(data.second);
  }

  return synced_extension_data;
}

syncer::SyncChange SyncBundle::CreateSyncChange(
    const ExtensionId& extension_id,
    const syncer::SyncData& sync_data) const {
  return syncer::SyncChange(FROM_HERE,
                            HasSyncedExtension(extension_id)
                                ? syncer::SyncChange::ACTION_UPDATE
                                : syncer::SyncChange::ACTION_ADD,
                            sync_data);
}

void SyncBundle::PushSyncChanges(
    const syncer::SyncChangeList& sync_change_list) {
  sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
}

void SyncBundle::AddSyncedExtension(const syncer::SyncData& sync_data) {
  std::unique_ptr<ExtensionSyncData> extension_sync_data =
      ExtensionSyncData::CreateFromSyncData(sync_data);
  if (extension_sync_data) {
    AddSyncedExtension(std::move(*extension_sync_data));
  }
}

void SyncBundle::AddSyncedExtension(
    const ExtensionSyncData& extension_sync_data) {
  synced_extensions_.insert_or_assign(extension_sync_data.id(),
                                      extension_sync_data);
}

void SyncBundle::RemoveSyncedExtension(const ExtensionId& id) {
  synced_extensions_.erase(id);
}

bool SyncBundle::HasSyncedExtension(const ExtensionId& id) const {
  return synced_extensions_.find(id) != synced_extensions_.end();
}

}  // namespace extensions