blob: 2274c5d25f4688fc3b7865d3387832416601340d (
plain)
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
|
// Copyright 2014 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.
#ifndef SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_H_
#define SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_H_
#include "base/memory/weak_ptr.h"
#include "base/stl_util.h"
#include "base/threading/non_thread_safe.h"
#include "sync/base/sync_export.h"
#include "sync/engine/non_blocking_sync_common.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/protocol/sync.pb.h"
namespace syncer {
class SyncCoreProxy;
class ModelThreadSyncEntity;
class NonBlockingTypeProcessorCoreInterface;
// A sync component embedded on the synced type's thread that helps to handle
// communication between sync and model type threads.
class SYNC_EXPORT_PRIVATE NonBlockingTypeProcessor : base::NonThreadSafe {
public:
NonBlockingTypeProcessor(ModelType type);
virtual ~NonBlockingTypeProcessor();
// Returns true if this object believes that sync is preferred for this type.
//
// By "preferred", we mean that a policy decision has been made that this
// type should be synced. Most of the time this is controlled by a user
// clicking a checkbox on the settings page.
//
// The canonical preferred state is based on SyncPrefs on the UI thread. At
// best, this value is stale and may lag behind the one set on the UI thread.
// Before this type has registered with the UI thread, it's mostly just an
// informed guess.
bool IsPreferred() const;
// Returns true if the handshake with sync thread is complete.
bool IsConnected() const;
// Returns the model type handled by this processor.
ModelType GetModelType() const;
// Starts the handshake with the sync thread.
void Enable(scoped_ptr<SyncCoreProxy> core_proxy);
// Severs all ties to the sync thread and may delete local sync state.
// Another call to Enable() can be used to re-establish this connection.
void Disable();
// Severs all ties to the sync thread.
// Another call to Enable() can be used to re-establish this connection.
void Disconnect();
// Callback used to process the handshake response.
void OnConnect(
scoped_ptr<NonBlockingTypeProcessorCoreInterface> core_interface);
// Requests that an item be stored in sync.
void Put(const std::string& client_tag,
const sync_pb::EntitySpecifics& specifics);
// Deletes an item from sync.
void Delete(const std::string& client_tag);
// Informs this object that some of its commit requests have been
// successfully serviced.
void OnCommitCompletion(const DataTypeState& type_state,
const CommitResponseDataList& response_list);
// Informs this object that there are some incoming updates is should
// handle.
void OnUpdateReceived(const DataTypeState& type_state,
const UpdateResponseDataList& response_list);
// Returns the long-lived WeakPtr that is intended to be registered with the
// ProfileSyncService.
base::WeakPtr<NonBlockingTypeProcessor> AsWeakPtrForUI();
private:
typedef std::map<std::string, ModelThreadSyncEntity*> EntityMap;
// Sends all commit requests that are due to be sent to the sync thread.
void FlushPendingCommitRequests();
ModelType type_;
DataTypeState data_type_state_;
// Whether or not sync is preferred for this type. This is a cached copy of
// the canonical copy information on the UI thread.
bool is_preferred_;
// Whether or not this object has completed its initial handshake with the
// SyncCoreProxy.
bool is_connected_;
// Our link to data type management on the sync thread.
// Used for enabling and disabling sync for this type.
//
// Beware of NULL pointers: This object is uninitialized when we are not
// connected to sync.
scoped_ptr<SyncCoreProxy> sync_core_proxy_;
// Reference to the NonBlockingTypeProcessorCore.
//
// The interface hides the posting of tasks across threads as well as the
// NonBlockingTypeProcessorCore's implementation. Both of these features are
// useful in tests.
scoped_ptr<NonBlockingTypeProcessorCoreInterface> core_interface_;
// The set of sync entities known to this object.
EntityMap entities_;
STLValueDeleter<EntityMap> entities_deleter_;
// We use two different WeakPtrFactories because we want the pointers they
// issue to have different lifetimes. When asked to disconnect from the sync
// thread, we want to make sure that no tasks generated as part of the
// now-obsolete connection to affect us. But we also want the WeakPtr we
// sent to the UI thread to remain valid.
base::WeakPtrFactory<NonBlockingTypeProcessor> weak_ptr_factory_for_ui_;
base::WeakPtrFactory<NonBlockingTypeProcessor> weak_ptr_factory_for_sync_;
};
} // namespace syncer
#endif // SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_H_
|
