blob: b237f54cc687db2e6bce2aa18ebe6a594016d478 (
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
130
131
132
133
134
|
// Copyright (c) 2012 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 CHROME_BROWSER_SYNC_GLUE_UI_DATA_TYPE_CONTROLLER_H__
#define CHROME_BROWSER_SYNC_GLUE_UI_DATA_TYPE_CONTROLLER_H__
#pragma once
#include <string>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/sync/glue/data_type_controller.h"
#include "chrome/browser/sync/glue/shared_change_processor.h"
class Profile;
class ProfileSyncService;
class ProfileSyncComponentsFactory;
namespace base {
class TimeDelta;
}
namespace syncer {
class SyncableService;
class SyncError;
}
namespace browser_sync {
// Implementation for datatypes that reside on the (UI thread). This is the same
// thread we perform initialization on, so we don't have to worry about thread
// safety. The main start/stop funtionality is implemented by default.
// Note: RefCountedThreadSafe by way of DataTypeController.
class UIDataTypeController : public DataTypeController {
public:
UIDataTypeController(
syncer::ModelType type,
ProfileSyncComponentsFactory* profile_sync_factory,
Profile* profile,
ProfileSyncService* sync_service);
// DataTypeController interface.
virtual void LoadModels(
const ModelLoadCallback& model_load_callback) OVERRIDE;
virtual void StartAssociating(const StartCallback& start_callback) OVERRIDE;
virtual void Stop() OVERRIDE;
virtual syncer::ModelType type() const OVERRIDE;
virtual syncer::ModelSafeGroup model_safe_group() const OVERRIDE;
virtual std::string name() const OVERRIDE;
virtual State state() const OVERRIDE;
// DataTypeErrorHandler interface.
virtual void OnSingleDatatypeUnrecoverableError(
const tracked_objects::Location& from_here,
const std::string& message) OVERRIDE;
protected:
// For testing only.
UIDataTypeController();
// DataTypeController is RefCounted.
virtual ~UIDataTypeController();
// Start any dependent services that need to be running before we can
// associate models. The default implementation is a no-op.
// Return value:
// True - if models are ready and association can proceed.
// False - if models are not ready. Associate() should be called when the
// models are ready.
virtual bool StartModels();
// Perform any DataType controller specific state cleanup before stopping
// the datatype controller. The default implementation is a no-op.
virtual void StopModels();
// DataTypeController interface.
virtual void OnModelLoaded() OVERRIDE;
// Helper methods for cleaning up state and invoking the start callback.
virtual void StartFailed(StartResult result, const syncer::SyncError& error);
virtual void StartDone(StartResult result);
// Record association time.
virtual void RecordAssociationTime(base::TimeDelta time);
// Record causes of start failure.
virtual void RecordStartFailure(StartResult result);
ProfileSyncComponentsFactory* const profile_sync_factory_;
Profile* const profile_;
ProfileSyncService* const sync_service_;
State state_;
StartCallback start_callback_;
ModelLoadCallback model_load_callback_;
// The sync datatype being controlled.
syncer::ModelType type_;
// Sync's interface to the datatype. All sync changes for |type_| are pushed
// through it to the datatype as well as vice versa.
//
// Lifetime: it gets created when Start()) is called, and a reference to it
// is passed to |local_service_| during Associate(). We release our reference
// when Stop() or StartFailed() is called, and |local_service_| releases its
// reference when local_service_->StopSyncing() is called or when it is
// destroyed.
//
// Note: we use refcounting here primarily so that we can keep a uniform
// SyncableService API, whether the datatype lives on the UI thread or not
// (a syncer::SyncableService takes ownership of its SyncChangeProcessor when
// MergeDataAndStartSyncing is called). This will help us eventually merge the
// two datatype controller implementations (for ui and non-ui thread
// datatypes).
scoped_refptr<SharedChangeProcessor> shared_change_processor_;
// A weak pointer to the actual local syncable service, which performs all the
// real work. We do not own the object.
base::WeakPtr<syncer::SyncableService> local_service_;
private:
// Associate the sync model with the service's model, then start syncing.
virtual void Associate();
virtual void AbortModelLoad();
DISALLOW_COPY_AND_ASSIGN(UIDataTypeController);
};
} // namespace browser_sync
#endif // CHROME_BROWSER_SYNC_GLUE_UI_DATA_TYPE_CONTROLLER_H__
|
