1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// Copyright 2013 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.
#include "sync/engine/sync_directory_update_handler.h"
#include "sync/engine/conflict_resolver.h"
#include "sync/engine/process_updates_util.h"
#include "sync/engine/update_applicator.h"
#include "sync/sessions/status_controller.h"
#include "sync/syncable/directory.h"
#include "sync/syncable/syncable_model_neutral_write_transaction.h"
#include "sync/syncable/syncable_write_transaction.h"
namespace syncer {
using syncable::SYNCER;
SyncDirectoryUpdateHandler::SyncDirectoryUpdateHandler(
syncable::Directory* dir,
ModelType type,
scoped_refptr<ModelSafeWorker> worker)
: dir_(dir),
type_(type),
worker_(worker) {}
SyncDirectoryUpdateHandler::~SyncDirectoryUpdateHandler() {}
void SyncDirectoryUpdateHandler::GetDownloadProgress(
sync_pb::DataTypeProgressMarker* progress_marker) const {
dir_->GetDownloadProgress(type_, progress_marker);
}
void SyncDirectoryUpdateHandler::ProcessGetUpdatesResponse(
const sync_pb::DataTypeProgressMarker& progress_marker,
const SyncEntityList& applicable_updates,
sessions::StatusController* status) {
syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
UpdateSyncEntities(&trans, applicable_updates, status);
UpdateProgressMarker(progress_marker);
}
void SyncDirectoryUpdateHandler::ApplyUpdates(
sessions::StatusController* status) {
if (IsControlType(type_)) {
return; // We don't process control types here.
}
if (!dir_->TypeHasUnappliedUpdates(type_)) {
return; // No work to do. Skip this type.
}
WorkCallback c = base::Bind(
&SyncDirectoryUpdateHandler::ApplyUpdatesImpl,
// We wait until the callback is executed. We can safely use Unretained.
base::Unretained(this),
base::Unretained(status));
worker_->DoWorkAndWaitUntilDone(c);
}
SyncerError SyncDirectoryUpdateHandler::ApplyUpdatesImpl(
sessions::StatusController* status) {
syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
std::vector<int64> handles;
dir_->GetUnappliedUpdateMetaHandles(
&trans,
FullModelTypeSet(type_),
&handles);
// First set of update application passes.
UpdateApplicator applicator(dir_->GetCryptographer(&trans));
applicator.AttemptApplications(&trans, handles);
status->increment_num_updates_applied_by(applicator.updates_applied());
status->increment_num_hierarchy_conflicts_by(
applicator.hierarchy_conflicts());
status->increment_num_encryption_conflicts_by(
applicator.encryption_conflicts());
if (applicator.simple_conflict_ids().size() != 0) {
// Resolve the simple conflicts we just detected.
ConflictResolver resolver;
resolver.ResolveConflicts(&trans,
dir_->GetCryptographer(&trans),
applicator.simple_conflict_ids(),
status);
// Conflict resolution sometimes results in more updates to apply.
handles.clear();
dir_->GetUnappliedUpdateMetaHandles(
&trans,
FullModelTypeSet(type_),
&handles);
UpdateApplicator conflict_applicator(dir_->GetCryptographer(&trans));
conflict_applicator.AttemptApplications(&trans, handles);
// We count the number of updates from both applicator passes.
status->increment_num_updates_applied_by(
conflict_applicator.updates_applied());
// Encryption conflicts should remain unchanged by the resolution of simple
// conflicts. Those can only be solved by updating our nigori key bag.
DCHECK_EQ(conflict_applicator.encryption_conflicts(),
applicator.encryption_conflicts());
// Hierarchy conflicts should also remain unchanged, for reasons that are
// more subtle. Hierarchy conflicts exist when the application of a pending
// update from the server would make the local folder hierarchy
// inconsistent. The resolution of simple conflicts could never affect the
// hierarchy conflicting item directly, because hierarchy conflicts are not
// processed by the conflict resolver. It could, in theory, modify the
// local hierarchy on which hierarchy conflict detection depends. However,
// the conflict resolution algorithm currently in use does not allow this.
DCHECK_EQ(conflict_applicator.hierarchy_conflicts(),
applicator.hierarchy_conflicts());
// There should be no simple conflicts remaining. We know this because the
// resolver should have resolved all the conflicts we detected last time
// and, by the two previous assertions, that no conflicts have been
// downgraded from encryption or hierarchy down to simple.
DCHECK(conflict_applicator.simple_conflict_ids().empty());
}
return SYNCER_OK;
}
void SyncDirectoryUpdateHandler::UpdateSyncEntities(
syncable::ModelNeutralWriteTransaction* trans,
const SyncEntityList& applicable_updates,
sessions::StatusController* status) {
ProcessDownloadedUpdates(dir_, trans, type_, applicable_updates, status);
}
void SyncDirectoryUpdateHandler::UpdateProgressMarker(
const sync_pb::DataTypeProgressMarker& progress_marker) {
int field_number = progress_marker.data_type_id();
ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
if (!IsRealDataType(model_type) || type_ != model_type) {
NOTREACHED()
<< "Update handler of type " << ModelTypeToString(type_)
<< " asked to process progress marker with invalid type "
<< field_number;
}
dir_->SetDownloadProgress(type_, progress_marker);
}
} // namespace syncer
|
