OLD | NEW |
| (Empty) |
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 // SyncSessionContext encapsulates the contextual information and engine | |
6 // components specific to a SyncSession. A context is accessible via | |
7 // a SyncSession so that session SyncerCommands and parts of the engine have | |
8 // a convenient way to access other parts. In this way it can be thought of as | |
9 // the surrounding environment for the SyncSession. The components of this | |
10 // environment are either valid or not valid for the entire context lifetime, | |
11 // or they are valid for explicitly scoped periods of time by using Scoped | |
12 // installation utilities found below. This means that the context assumes no | |
13 // ownership whatsoever of any object that was not created by the context | |
14 // itself. | |
15 // | |
16 // It can only be used from the SyncerThread. | |
17 | |
18 #ifndef CHROME_BROWSER_SYNC_SESSIONS_SYNC_SESSION_CONTEXT_H_ | |
19 #define CHROME_BROWSER_SYNC_SESSIONS_SYNC_SESSION_CONTEXT_H_ | |
20 #pragma once | |
21 | |
22 #include <map> | |
23 #include <string> | |
24 | |
25 #include "base/gtest_prod_util.h" | |
26 #include "base/memory/scoped_ptr.h" | |
27 #include "base/time.h" | |
28 #include "chrome/browser/sync/engine/model_safe_worker.h" | |
29 #include "chrome/browser/sync/engine/syncer_types.h" | |
30 #include "chrome/browser/sync/sessions/debug_info_getter.h" | |
31 | |
32 namespace syncable { | |
33 class Directory; | |
34 } | |
35 | |
36 namespace browser_sync { | |
37 | |
38 class ConflictResolver; | |
39 class ExtensionsActivityMonitor; | |
40 class ModelSafeWorkerRegistrar; | |
41 class ServerConnectionManager; | |
42 | |
43 // Default number of items a client can commit in a single message. | |
44 static const int kDefaultMaxCommitBatchSize = 25; | |
45 | |
46 namespace sessions { | |
47 class ScopedSessionContextConflictResolver; | |
48 struct SyncSessionSnapshot; | |
49 class TestScopedSessionEventListener; | |
50 | |
51 class SyncSessionContext { | |
52 public: | |
53 SyncSessionContext(ServerConnectionManager* connection_manager, | |
54 syncable::Directory* directory, | |
55 ModelSafeWorkerRegistrar* model_safe_worker_registrar, | |
56 ExtensionsActivityMonitor* extensions_activity_monitor, | |
57 const std::vector<SyncEngineEventListener*>& listeners, | |
58 DebugInfoGetter* debug_info_getter); | |
59 | |
60 // Empty constructor for unit tests. | |
61 SyncSessionContext(); | |
62 virtual ~SyncSessionContext(); | |
63 | |
64 ConflictResolver* resolver() { return resolver_; } | |
65 ServerConnectionManager* connection_manager() { | |
66 return connection_manager_; | |
67 } | |
68 syncable::Directory* directory() { | |
69 return directory_; | |
70 } | |
71 | |
72 ModelSafeWorkerRegistrar* registrar() { | |
73 return registrar_; | |
74 } | |
75 ExtensionsActivityMonitor* extensions_monitor() { | |
76 return extensions_activity_monitor_; | |
77 } | |
78 | |
79 DebugInfoGetter* debug_info_getter() { | |
80 return debug_info_getter_; | |
81 } | |
82 | |
83 // Talk notification status. | |
84 void set_notifications_enabled(bool enabled) { | |
85 notifications_enabled_ = enabled; | |
86 } | |
87 bool notifications_enabled() { return notifications_enabled_; } | |
88 | |
89 // Account name, set once a directory has been opened. | |
90 void set_account_name(const std::string name) { | |
91 DCHECK(account_name_.empty()); | |
92 account_name_ = name; | |
93 } | |
94 const std::string& account_name() const { return account_name_; } | |
95 | |
96 void set_max_commit_batch_size(int batch_size) { | |
97 max_commit_batch_size_ = batch_size; | |
98 } | |
99 int32 max_commit_batch_size() const { return max_commit_batch_size_; } | |
100 | |
101 const ModelSafeRoutingInfo& previous_session_routing_info() const { | |
102 return previous_session_routing_info_; | |
103 } | |
104 | |
105 void set_previous_session_routing_info(const ModelSafeRoutingInfo& info) { | |
106 previous_session_routing_info_ = info; | |
107 } | |
108 | |
109 void NotifyListeners(const SyncEngineEvent& event) { | |
110 FOR_EACH_OBSERVER(SyncEngineEventListener, listeners_, | |
111 OnSyncEngineEvent(event)); | |
112 } | |
113 | |
114 // This is virtual for unit tests. | |
115 virtual void SetUnthrottleTime(syncable::ModelTypeSet types, | |
116 const base::TimeTicks& time); | |
117 | |
118 // This prunes the |unthrottle_time_| map based on the |time| passed in. This | |
119 // is called by syncer at the SYNCER_BEGIN stage. | |
120 void PruneUnthrottledTypes(const base::TimeTicks& time); | |
121 | |
122 // This returns the list of currently throttled types. Unless server returns | |
123 // new throttled types this will remain constant through out the sync cycle. | |
124 syncable::ModelTypeSet GetThrottledTypes() const; | |
125 | |
126 private: | |
127 typedef std::map<syncable::ModelType, base::TimeTicks> UnthrottleTimes; | |
128 | |
129 FRIEND_TEST_ALL_PREFIXES(SyncSessionContextTest, AddUnthrottleTimeTest); | |
130 FRIEND_TEST_ALL_PREFIXES(SyncSessionContextTest, | |
131 GetCurrentlyThrottledTypesTest); | |
132 | |
133 // Rather than force clients to set and null-out various context members, we | |
134 // extend our encapsulation boundary to scoped helpers that take care of this | |
135 // once they are allocated. See definitions of these below. | |
136 friend class ScopedSessionContextConflictResolver; | |
137 friend class TestScopedSessionEventListener; | |
138 | |
139 // This is installed by Syncer objects when needed and may be NULL. | |
140 ConflictResolver* resolver_; | |
141 | |
142 ObserverList<SyncEngineEventListener> listeners_; | |
143 | |
144 ServerConnectionManager* const connection_manager_; | |
145 syncable::Directory* const directory_; | |
146 | |
147 // A registrar of workers capable of processing work closures on a thread | |
148 // that is guaranteed to be safe for model modifications. | |
149 ModelSafeWorkerRegistrar* registrar_; | |
150 | |
151 // We use this to stuff extensions activity into CommitMessages so the server | |
152 // can correlate commit traffic with extension-related bookmark mutations. | |
153 ExtensionsActivityMonitor* extensions_activity_monitor_; | |
154 | |
155 // Kept up to date with talk events to determine whether notifications are | |
156 // enabled. True only if the notification channel is authorized and open. | |
157 bool notifications_enabled_; | |
158 | |
159 // The name of the account being synced. | |
160 std::string account_name_; | |
161 | |
162 // The server limits the number of items a client can commit in one batch. | |
163 int max_commit_batch_size_; | |
164 | |
165 // Some routing info history to help us clean up types that get disabled | |
166 // by the user. | |
167 ModelSafeRoutingInfo previous_session_routing_info_; | |
168 | |
169 // Cache of last session snapshot information. | |
170 scoped_ptr<sessions::SyncSessionSnapshot> previous_session_snapshot_; | |
171 | |
172 // We use this to get debug info to send to the server for debugging | |
173 // client behavior on server side. | |
174 DebugInfoGetter* const debug_info_getter_; | |
175 | |
176 // This is a map from throttled data types to the time at which they can be | |
177 // unthrottled. | |
178 UnthrottleTimes unthrottle_times_; | |
179 | |
180 DISALLOW_COPY_AND_ASSIGN(SyncSessionContext); | |
181 }; | |
182 | |
183 // Installs a ConflictResolver to a given session context for the lifetime of | |
184 // the ScopedSessionContextConflictResolver. There should never be more than | |
185 // one ConflictResolver in the system, so it is an error to use this if the | |
186 // context already has a resolver. | |
187 class ScopedSessionContextConflictResolver { | |
188 public: | |
189 // Note: |context| and |resolver| should outlive |this|. | |
190 ScopedSessionContextConflictResolver(SyncSessionContext* context, | |
191 ConflictResolver* resolver) | |
192 : context_(context), resolver_(resolver) { | |
193 DCHECK(NULL == context->resolver_); | |
194 context->resolver_ = resolver; | |
195 } | |
196 ~ScopedSessionContextConflictResolver() { | |
197 context_->resolver_ = NULL; | |
198 } | |
199 private: | |
200 SyncSessionContext* context_; | |
201 ConflictResolver* resolver_; | |
202 DISALLOW_COPY_AND_ASSIGN(ScopedSessionContextConflictResolver); | |
203 }; | |
204 | |
205 } // namespace sessions | |
206 } // namespace browser_sync | |
207 | |
208 #endif // CHROME_BROWSER_SYNC_SESSIONS_SYNC_SESSION_CONTEXT_H_ | |
OLD | NEW |