chrome/browser/extensions/extension_sync_bundle.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/extension_sync_bundle.h"
   6
   7 #include "base/location.h"
   8 #include "chrome/browser/extensions/extension_sync_service.h"
   9 #include "chrome/common/extensions/sync_helper.h"
  10 #include "extensions/common/extension.h"
  11 #include "extensions/common/extension_set.h"
  12 #include "sync/api/sync_change_processor.h"
  13 #include "sync/api/sync_error_factory.h"
  14
  15 namespace extensions {
  16
  17 ExtensionSyncBundle::ExtensionSyncBundle(
  18     ExtensionSyncService* extension_sync_service)
  19     : extension_sync_service_(extension_sync_service) {}
  20
  21 ExtensionSyncBundle::~ExtensionSyncBundle() {}
  22
  23 void ExtensionSyncBundle::SetupSync(
  24     syncer::SyncChangeProcessor* sync_processor,
  25     syncer::SyncErrorFactory* sync_error_factory,
  26     const syncer::SyncDataList& initial_sync_data) {
  27   sync_processor_.reset(sync_processor);
  28   sync_error_factory_.reset(sync_error_factory);
  29
  30   for (syncer::SyncDataList::const_iterator i = initial_sync_data.begin();
  31        i != initial_sync_data.end();
  32        ++i) {
  33     ExtensionSyncData extension_sync_data(*i);
  34     AddExtension(extension_sync_data.id());
  35     extension_sync_service_->ProcessExtensionSyncData(extension_sync_data);
  36   }
  37 }
  38
  39 void ExtensionSyncBundle::Reset() {
  40   sync_processor_.reset();
  41   sync_error_factory_.reset();
  42   synced_extensions_.clear();
  43   pending_sync_data_.clear();
  44 }
  45
  46 syncer::SyncChange ExtensionSyncBundle::CreateSyncChangeToDelete(
  47     const Extension* extension) const {
  48   extensions::ExtensionSyncData sync_data =
  49       extension_sync_service_->GetExtensionSyncData(*extension);
  50   return sync_data.GetSyncChange(syncer::SyncChange::ACTION_DELETE);
  51 }
  52
  53 void ExtensionSyncBundle::ProcessDeletion(
  54     std::string extension_id, const syncer::SyncChange& sync_change) {
  55   RemoveExtension(extension_id);
  56   sync_processor_->ProcessSyncChanges(FROM_HERE,
  57                                       syncer::SyncChangeList(1, sync_change));
  58 }
  59
  60 syncer::SyncChange ExtensionSyncBundle::CreateSyncChange(
  61     const syncer::SyncData& sync_data) {
  62   const syncer::SyncDataLocal sync_data_local(sync_data);
  63   if (HasExtensionId(sync_data_local.GetTag())) {
  64     return syncer::SyncChange(FROM_HERE,
  65                               syncer::SyncChange::ACTION_UPDATE,
  66                               sync_data);
  67   } else {
  68     AddExtension(sync_data_local.GetTag());
  69     return syncer::SyncChange(FROM_HERE,
  70                               syncer::SyncChange::ACTION_ADD,
  71                               sync_data);
  72   }
  73 }
  74
  75 syncer::SyncDataList ExtensionSyncBundle::GetAllSyncData() const {
  76   std::vector<ExtensionSyncData> extension_sync_data =
  77       extension_sync_service_->GetExtensionSyncDataList();
  78   syncer::SyncDataList result(extension_sync_data.size());
  79   for (int i = 0; i < static_cast<int>(extension_sync_data.size()); ++i) {
  80     result[i] = extension_sync_data[i].GetSyncData();
  81   }
  82   return result;
  83 }
  84
  85 void ExtensionSyncBundle::ProcessSyncChange(
  86     ExtensionSyncData extension_sync_data) {
  87   if (extension_sync_data.uninstalled())
  88     RemoveExtension(extension_sync_data.id());
  89   else
  90     AddExtension(extension_sync_data.id());
  91   extension_sync_service_->ProcessExtensionSyncData(extension_sync_data);
  92 }
  93
  94 void ExtensionSyncBundle::ProcessSyncChangeList(
  95     syncer::SyncChangeList sync_change_list) {
  96   sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
  97 }
  98
  99 bool ExtensionSyncBundle::HasExtensionId(
 100     const std::string& id) const {
 101   return synced_extensions_.find(id) != synced_extensions_.end();
 102 }
 103
 104 bool ExtensionSyncBundle::HasPendingExtensionId(
 105     const std::string& id) const {
 106   return pending_sync_data_.find(id) != pending_sync_data_.end();
 107 }
 108
 109 void ExtensionSyncBundle::AddPendingExtension(
 110     const std::string& id,
 111     const ExtensionSyncData& extension_sync_data) {
 112   pending_sync_data_[id] = extension_sync_data;
 113 }
 114
 115 bool ExtensionSyncBundle::IsSyncing() const {
 116   return sync_processor_ != NULL;
 117 }
 118
 119 void ExtensionSyncBundle::SyncChangeIfNeeded(const Extension& extension) {
 120   ExtensionSyncData extension_sync_data =
 121       extension_sync_service_->GetExtensionSyncData(extension);
 122
 123   syncer::SyncChangeList sync_change_list(1, extension_sync_data.GetSyncChange(
 124       HasExtensionId(extension.id()) ?
 125       syncer::SyncChange::ACTION_UPDATE : syncer::SyncChange::ACTION_ADD));
 126   sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
 127   MarkPendingExtensionSynced(extension.id());
 128 }
 129
 130 std::vector<ExtensionSyncData> ExtensionSyncBundle::GetPendingData() const {
 131   std::vector<ExtensionSyncData> pending_extensions;
 132   for (std::map<std::string, ExtensionSyncData>::const_iterator
 133            i = pending_sync_data_.begin();
 134        i != pending_sync_data_.end();
 135        ++i) {
 136     pending_extensions.push_back(i->second);
 137   }
 138
 139   return pending_extensions;
 140 }
 141
 142 void ExtensionSyncBundle::GetExtensionSyncDataListHelper(
 143     const ExtensionSet& extensions,
 144     std::vector<ExtensionSyncData>* sync_data_list) const {
 145   for (ExtensionSet::const_iterator it = extensions.begin();
 146        it != extensions.end(); ++it) {
 147     const Extension& extension = *it->get();
 148     // If we have pending extension data for this extension, then this
 149     // version is out of date.  We'll sync back the version we got from
 150     // sync.
 151     if (IsSyncing() && sync_helper::IsSyncableExtension(&extension) &&
 152         !HasPendingExtensionId(extension.id())) {
 153       sync_data_list->push_back(
 154           extension_sync_service_->GetExtensionSyncData(extension));
 155     }
 156   }
 157 }
 158
 159 void ExtensionSyncBundle::AddExtension(const std::string& id) {
 160   synced_extensions_.insert(id);
 161 }
 162
 163 void ExtensionSyncBundle::RemoveExtension(const std::string& id) {
 164   synced_extensions_.erase(id);
 165 }
 166
 167 void ExtensionSyncBundle::MarkPendingExtensionSynced(const std::string& id) {
 168   pending_sync_data_.erase(id);
 169   synced_extensions_.insert(id);
 170 }
 171
 172 }  // namespace extensions