extension_sync_bundle.cc revision 7d4cd473f85ac64c3747c96c277f9e506a0d2246 
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_service.h"
9#include "chrome/browser/extensions/extension_sorting.h"
10#include "chrome/common/extensions/extension.h"
11#include "chrome/common/extensions/extension_set.h"
12#include "chrome/common/extensions/sync_helper.h"
13#include "sync/api/sync_change_processor.h"
14#include "sync/api/sync_error_factory.h"
15
16namespace extensions {
17
18ExtensionSyncBundle::ExtensionSyncBundle(ExtensionService* extension_service)
19    : extension_service_(extension_service) {}
20
21ExtensionSyncBundle::~ExtensionSyncBundle() {}
22
23void 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_service_->ProcessExtensionSyncData(extension_sync_data);
36  }
37}
38
39void ExtensionSyncBundle::Reset() {
40  sync_processor_.reset();
41  sync_error_factory_.reset();
42  synced_extensions_.clear();
43  pending_sync_data_.clear();
44}
45
46syncer::SyncChange ExtensionSyncBundle::CreateSyncChangeToDelete(
47    const Extension* extension) const {
48  extensions::ExtensionSyncData sync_data =
49      extension_service_->GetExtensionSyncData(*extension);
50  return sync_data.GetSyncChange(syncer::SyncChange::ACTION_DELETE);
51}
52
53void 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
60syncer::SyncChange ExtensionSyncBundle::CreateSyncChange(
61    const syncer::SyncData& sync_data) {
62  if (HasExtensionId(sync_data.GetTag())) {
63    return syncer::SyncChange(FROM_HERE,
64                              syncer::SyncChange::ACTION_UPDATE,
65                              sync_data);
66  } else {
67    AddExtension(sync_data.GetTag());
68    return syncer::SyncChange(FROM_HERE,
69                              syncer::SyncChange::ACTION_ADD,
70                              sync_data);
71  }
72}
73
74syncer::SyncDataList ExtensionSyncBundle::GetAllSyncData() const {
75  std::vector<ExtensionSyncData> extension_sync_data =
76      extension_service_->GetExtensionSyncDataList();
77  syncer::SyncDataList result(extension_sync_data.size());
78  for (int i = 0; i < static_cast<int>(extension_sync_data.size()); ++i) {
79    result[i] = extension_sync_data[i].GetSyncData();
80  }
81  return result;
82}
83
84void ExtensionSyncBundle::SyncChangeIfNeeded(const Extension& extension) {
85  ExtensionSyncData extension_sync_data =
86      extension_service_->GetExtensionSyncData(extension);
87
88  syncer::SyncChangeList sync_change_list(1, extension_sync_data.GetSyncChange(
89      HasExtensionId(extension.id()) ?
90      syncer::SyncChange::ACTION_UPDATE : syncer::SyncChange::ACTION_ADD));
91  sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
92  MarkPendingExtensionSynced(extension.id());
93}
94
95void ExtensionSyncBundle::ProcessSyncChange(
96    ExtensionSyncData extension_sync_data) {
97  if (extension_sync_data.uninstalled())
98    RemoveExtension(extension_sync_data.id());
99  else
100    AddExtension(extension_sync_data.id());
101  extension_service_->ProcessExtensionSyncData(extension_sync_data);
102}
103
104void ExtensionSyncBundle::ProcessSyncChangeList(
105    syncer::SyncChangeList sync_change_list) {
106  sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
107}
108
109bool ExtensionSyncBundle::HasExtensionId(
110    const std::string& id) const {
111  return synced_extensions_.find(id) != synced_extensions_.end();
112}
113
114bool ExtensionSyncBundle::HasPendingExtensionId(
115    const std::string& id) const {
116  return pending_sync_data_.find(id) != pending_sync_data_.end();
117}
118
119void ExtensionSyncBundle::AddPendingExtension(
120    const std::string& id,
121    const ExtensionSyncData& extension_sync_data) {
122  pending_sync_data_[id] = extension_sync_data;
123}
124
125bool ExtensionSyncBundle::HandlesExtension(const Extension& extension) const {
126  return sync_processor_ != NULL &&
127      sync_helper::IsSyncableExtension(&extension);
128}
129
130std::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
142void 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 (HandlesExtension(extension) &&
152        !HasPendingExtensionId(extension.id())) {
153      sync_data_list->push_back(
154          extension_service_->GetExtensionSyncData(extension));
155    }
156  }
157}
158
159void ExtensionSyncBundle::AddExtension(const std::string& id) {
160  synced_extensions_.insert(id);
161}
162
163void ExtensionSyncBundle::RemoveExtension(const std::string& id) {
164  synced_extensions_.erase(id);
165}
166
167void ExtensionSyncBundle::MarkPendingExtensionSynced(const std::string& id) {
168  pending_sync_data_.erase(id);
169  synced_extensions_.insert(id);
170}
171
172}  // namespace extensions
173