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
|
// 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_DATA_TYPE_CONTROLLER_H__
#define CHROME_BROWSER_SYNC_GLUE_DATA_TYPE_CONTROLLER_H__
#pragma once
#include <map>
#include <string>
#include "base/callback.h"
#include "base/location.h"
#include "base/message_loop_helpers.h"
#include "chrome/browser/sync/glue/data_type_error_handler.h"
#include "content/public/browser/browser_thread.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
#include "sync/internal_api/public/syncable/model_type.h"
#include "sync/internal_api/public/util/unrecoverable_error_handler.h"
class SyncError;
namespace browser_sync {
// Data type controllers need to be refcounted threadsafe, as they may
// need to run model associator or change processor on other threads.
class DataTypeController
: public base::RefCountedThreadSafe<
DataTypeController, content::BrowserThread::DeleteOnUIThread>,
public DataTypeErrorHandler {
public:
enum State {
NOT_RUNNING, // The controller has never been started or has
// previously been stopped. Must be in this state to start.
MODEL_STARTING, // The controller is waiting on dependent services
// that need to be available before model
// association.
MODEL_LOADED, // The model has finished loading and can start
// associating now.
ASSOCIATING, // Model association is in progress.
RUNNING, // The controller is running and the data type is
// in sync with the cloud.
STOPPING, // The controller is in the process of stopping
// and is waiting for dependent services to stop.
DISABLED // The controller was started but encountered an error
// so it is disabled waiting for it to be stopped.
};
enum StartResult {
OK, // The data type has started normally.
OK_FIRST_RUN, // Same as OK, but sent on first successful
// start for this type for this user as
// determined by cloud state.
BUSY, // Start() was called while already in progress.
NOT_ENABLED, // This data type is not enabled for the current user.
ASSOCIATION_FAILED, // An error occurred during model association.
ABORTED, // Start was aborted by calling Stop().
UNRECOVERABLE_ERROR, // An unrecoverable error occured.
NEEDS_CRYPTO, // The data type cannot be started yet because it
// depends on the cryptographer.
MAX_START_RESULT
};
typedef base::Callback<void(StartResult, const SyncError&)> StartCallback;
typedef base::Callback<void(syncable::ModelType,
SyncError)> ModelLoadCallback;
typedef std::map<syncable::ModelType,
scoped_refptr<DataTypeController> > TypeMap;
typedef std::map<syncable::ModelType, DataTypeController::State> StateMap;
// Returns true if the start result should trigger an unrecoverable error.
// Public so unit tests can use this function as well.
static bool IsUnrecoverableResult(StartResult result);
// Begins asynchronous operation of loading the model to get it ready for
// model association. Once the models are loaded the callback will be invoked
// with the result. If the models are already loaded it is safe to call the
// callback right away. Else the callback needs to be stored and called when
// the models are ready.
virtual void LoadModels(const ModelLoadCallback& model_load_callback) = 0;
// Will start a potentially asynchronous operation to perform the
// model association. Once the model association is done the callback will
// be invoked.
virtual void StartAssociating(const StartCallback& start_callback) = 0;
// Synchronously stops the data type. If StartAssociating has already been
// called but is not done yet it will be aborted. Similarly if LoadModels
// has not completed it will also be aborted.
virtual void Stop() = 0;
// Unique model type for this data type controller.
virtual syncable::ModelType type() const = 0;
// Name of this data type. For logging purposes only.
virtual std::string name() const = 0;
// The model safe group of this data type. This should reflect the
// thread that should be used to modify the data type's native
// model.
virtual browser_sync::ModelSafeGroup model_safe_group() const = 0;
// Current state of the data type controller.
virtual State state() const = 0;
// Partial implementation of DataTypeErrorHandler.
// This is thread safe.
virtual SyncError CreateAndUploadError(
const tracked_objects::Location& location,
const std::string& message,
syncable::ModelType type) OVERRIDE;
protected:
friend struct content::BrowserThread::DeleteOnThread<
content::BrowserThread::UI>;
friend class base::DeleteHelper<DataTypeController>;
// If the DTC is waiting for models to load, once the models are
// loaded the datatype service will call this function on DTC to let
// us know that it is safe to start associating.
virtual void OnModelLoaded() = 0;
virtual ~DataTypeController() {}
// Handles the reporting of unrecoverable error. It records stuff in
// UMA and reports to breakpad.
// Virtual for testing purpose.
virtual void RecordUnrecoverableError(
const tracked_objects::Location& from_here,
const std::string& message);
};
} // namespace browser_sync
#endif // CHROME_BROWSER_SYNC_GLUE_DATA_TYPE_CONTROLLER_H__
|
