1// Copyright 2014 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#ifndef SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_H_
6#define SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_H_
7
8#include "base/memory/weak_ptr.h"
9#include "base/stl_util.h"
10#include "base/threading/non_thread_safe.h"
11#include "sync/base/sync_export.h"
12#include "sync/engine/non_blocking_sync_common.h"
13#include "sync/internal_api/public/base/model_type.h"
14#include "sync/protocol/sync.pb.h"
15
16namespace syncer {
17
18class SyncCoreProxy;
19class ModelThreadSyncEntity;
20class NonBlockingTypeProcessorCoreInterface;
21
22// A sync component embedded on the synced type's thread that helps to handle
23// communication between sync and model type threads.
24class SYNC_EXPORT_PRIVATE NonBlockingTypeProcessor : base::NonThreadSafe {
25 public:
26  NonBlockingTypeProcessor(ModelType type);
27  virtual ~NonBlockingTypeProcessor();
28
29  // Returns true if this object believes that sync is preferred for this type.
30  //
31  // By "preferred", we mean that a policy decision has been made that this
32  // type should be synced.  Most of the time this is controlled by a user
33  // clicking a checkbox on the settings page.
34  //
35  // The canonical preferred state is based on SyncPrefs on the UI thread.  At
36  // best, this value is stale and may lag behind the one set on the UI thread.
37  // Before this type has registered with the UI thread, it's mostly just an
38  // informed guess.
39  bool IsPreferred() const;
40
41  // Returns true if the handshake with sync thread is complete.
42  bool IsConnected() const;
43
44  // Returns the model type handled by this processor.
45  ModelType GetModelType() const;
46
47  // Starts the handshake with the sync thread.
48  void Enable(scoped_ptr<SyncCoreProxy> core_proxy);
49
50  // Severs all ties to the sync thread and may delete local sync state.
51  // Another call to Enable() can be used to re-establish this connection.
52  void Disable();
53
54  // Severs all ties to the sync thread.
55  // Another call to Enable() can be used to re-establish this connection.
56  void Disconnect();
57
58  // Callback used to process the handshake response.
59  void OnConnect(
60      scoped_ptr<NonBlockingTypeProcessorCoreInterface> core_interface);
61
62  // Requests that an item be stored in sync.
63  void Put(const std::string& client_tag,
64           const sync_pb::EntitySpecifics& specifics);
65
66  // Deletes an item from sync.
67  void Delete(const std::string& client_tag);
68
69  // Informs this object that some of its commit requests have been
70  // successfully serviced.
71  void OnCommitCompletion(const DataTypeState& type_state,
72                          const CommitResponseDataList& response_list);
73
74  // Informs this object that there are some incoming updates is should
75  // handle.
76  void OnUpdateReceived(const DataTypeState& type_state,
77                        const UpdateResponseDataList& response_list);
78
79  // Returns the long-lived WeakPtr that is intended to be registered with the
80  // ProfileSyncService.
81  base::WeakPtr<NonBlockingTypeProcessor> AsWeakPtrForUI();
82
83 private:
84  typedef std::map<std::string, ModelThreadSyncEntity*> EntityMap;
85
86  // Sends all commit requests that are due to be sent to the sync thread.
87  void FlushPendingCommitRequests();
88
89  ModelType type_;
90  DataTypeState data_type_state_;
91
92  // Whether or not sync is preferred for this type.  This is a cached copy of
93  // the canonical copy information on the UI thread.
94  bool is_preferred_;
95
96  // Whether or not this object has completed its initial handshake with the
97  // SyncCoreProxy.
98  bool is_connected_;
99
100  // Our link to data type management on the sync thread.
101  // Used for enabling and disabling sync for this type.
102  //
103  // Beware of NULL pointers: This object is uninitialized when we are not
104  // connected to sync.
105  scoped_ptr<SyncCoreProxy> sync_core_proxy_;
106
107  // Reference to the NonBlockingTypeProcessorCore.
108  //
109  // The interface hides the posting of tasks across threads as well as the
110  // NonBlockingTypeProcessorCore's implementation.  Both of these features are
111  // useful in tests.
112  scoped_ptr<NonBlockingTypeProcessorCoreInterface> core_interface_;
113
114  // The set of sync entities known to this object.
115  EntityMap entities_;
116  STLValueDeleter<EntityMap> entities_deleter_;
117
118  // We use two different WeakPtrFactories because we want the pointers they
119  // issue to have different lifetimes.  When asked to disconnect from the sync
120  // thread, we want to make sure that no tasks generated as part of the
121  // now-obsolete connection to affect us.  But we also want the WeakPtr we
122  // sent to the UI thread to remain valid.
123  base::WeakPtrFactory<NonBlockingTypeProcessor> weak_ptr_factory_for_ui_;
124  base::WeakPtrFactory<NonBlockingTypeProcessor> weak_ptr_factory_for_sync_;
125};
126
127}  // namespace syncer
128
129#endif  // SYNC_ENGINE_NON_BLOCKING_TYPE_PROCESSOR_H_
130