fake_sync_worker.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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#include "chrome/browser/sync_file_system/drive_backend/fake_sync_worker.h"
6
7#include "base/values.h"
8#include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
9#include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
10#include "chrome/browser/sync_file_system/sync_status_code.h"
11
12namespace sync_file_system {
13namespace drive_backend {
14
15FakeSyncWorker::FakeSyncWorker()
16    : sync_enabled_(true),
17      has_refresh_token_(true),
18      network_available_(true) {
19  sequence_checker_.DetachFromSequence();
20}
21
22FakeSyncWorker::~FakeSyncWorker() {
23  observers_.Clear();
24}
25
26void FakeSyncWorker::Initialize(
27    scoped_ptr<SyncEngineContext> sync_engine_context) {
28  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
29
30  sync_engine_context_ = sync_engine_context.Pass();
31  status_map_.clear();
32  // TODO(peria): Set |status_map_| as a fake metadata database.
33}
34
35void FakeSyncWorker::RegisterOrigin(const GURL& origin,
36                                    const SyncStatusCallback& callback) {
37  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
38  // TODO(peria): Check how it should act on installing installed app?
39  status_map_[origin] = REGISTERED;
40  callback.Run(SYNC_STATUS_OK);
41}
42
43void FakeSyncWorker::EnableOrigin(const GURL& origin,
44                                  const SyncStatusCallback& callback) {
45  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
46  // TODO(peria): Check how it should act on enabling non-installed app?
47  status_map_[origin] = ENABLED;
48  callback.Run(SYNC_STATUS_OK);
49}
50
51void FakeSyncWorker::DisableOrigin(const GURL& origin,
52                                   const SyncStatusCallback& callback) {
53  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
54  // TODO(peria): Check how it should act on disabling non-installed app?
55  status_map_[origin] = DISABLED;
56  callback.Run(SYNC_STATUS_OK);
57}
58
59void FakeSyncWorker::UninstallOrigin(const GURL& origin,
60                                     RemoteFileSyncService::UninstallFlag flag,
61                                     const SyncStatusCallback& callback) {
62  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
63  // TODO(peria): Check how it should act on uninstalling non-installed app?
64  status_map_[origin] = UNINSTALLED;
65  callback.Run(SYNC_STATUS_OK);
66}
67
68void FakeSyncWorker::ProcessRemoteChange(
69    const SyncFileCallback& callback) {
70  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
71  callback.Run(SYNC_STATUS_OK, fileapi::FileSystemURL());
72}
73
74void FakeSyncWorker::SetRemoteChangeProcessor(
75    RemoteChangeProcessorOnWorker* remote_change_processor_on_worker) {
76  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
77}
78
79RemoteServiceState FakeSyncWorker::GetCurrentState() const {
80  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
81  return REMOTE_SERVICE_OK;
82}
83
84void FakeSyncWorker::GetOriginStatusMap(
85    const RemoteFileSyncService::StatusMapCallback& callback) {
86  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
87
88  scoped_ptr<RemoteFileSyncService::OriginStatusMap>
89      status_map(new RemoteFileSyncService::OriginStatusMap);
90  for (StatusMap::const_iterator itr = status_map_.begin();
91       itr != status_map_.end(); ++itr) {
92    switch (itr->second) {
93    case REGISTERED:
94      (*status_map)[itr->first] = "Registered";
95      break;
96    case ENABLED:
97      (*status_map)[itr->first] = "Enabled";
98      break;
99    case DISABLED:
100      (*status_map)[itr->first] = "Disabled";
101      break;
102    case UNINSTALLED:
103      (*status_map)[itr->first] = "Uninstalled";
104      break;
105    default:
106      (*status_map)[itr->first] = "Unknown";
107      break;
108    }
109  }
110  callback.Run(status_map.Pass());
111}
112
113scoped_ptr<base::ListValue> FakeSyncWorker::DumpFiles(const GURL& origin) {
114  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
115  return scoped_ptr<base::ListValue>();
116}
117
118scoped_ptr<base::ListValue> FakeSyncWorker::DumpDatabase() {
119  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
120  return scoped_ptr<base::ListValue>();
121}
122
123void FakeSyncWorker::SetSyncEnabled(bool enabled) {
124  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
125  sync_enabled_ = enabled;
126
127  if (enabled)
128    UpdateServiceState(REMOTE_SERVICE_OK, "Set FakeSyncWorker enabled.");
129  else
130    UpdateServiceState(REMOTE_SERVICE_DISABLED, "Disabled FakeSyncWorker.");
131}
132
133void FakeSyncWorker::PromoteDemotedChanges() {
134  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
135  FOR_EACH_OBSERVER(
136      Observer,
137      observers_,
138      OnPendingFileListUpdated(10));
139}
140
141void FakeSyncWorker::ApplyLocalChange(
142    const FileChange& local_change,
143    const base::FilePath& local_path,
144    const SyncFileMetadata& local_metadata,
145    const fileapi::FileSystemURL& url,
146    const SyncStatusCallback& callback) {
147  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
148  callback.Run(SYNC_STATUS_OK);
149}
150
151void FakeSyncWorker::OnNotificationReceived() {
152  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
153  UpdateServiceState(REMOTE_SERVICE_OK, "Got push notification for Drive.");
154}
155
156void FakeSyncWorker::OnReadyToSendRequests() {
157  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
158  has_refresh_token_ = true;
159  UpdateServiceState(REMOTE_SERVICE_OK, "ReadyToSendRequests");
160}
161
162void FakeSyncWorker::OnRefreshTokenInvalid() {
163  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
164  has_refresh_token_ = false;
165  UpdateServiceState(REMOTE_SERVICE_OK, "RefreshTokenInvalid");
166}
167
168void FakeSyncWorker::OnNetworkChanged(
169    net::NetworkChangeNotifier::ConnectionType type) {
170  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
171  bool new_network_availability =
172      type != net::NetworkChangeNotifier::CONNECTION_NONE;
173  if (network_available_ && !new_network_availability) {
174    UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, "Disconnected");
175  } else if (!network_available_ && new_network_availability) {
176    UpdateServiceState(REMOTE_SERVICE_OK, "Connected");
177  }
178  network_available_ = new_network_availability;
179}
180
181void FakeSyncWorker::DetachFromSequence() {
182  sequence_checker_.DetachFromSequence();
183}
184
185void FakeSyncWorker::AddObserver(Observer* observer) {
186  // This method is called on UI thread.
187  observers_.AddObserver(observer);
188}
189
190void FakeSyncWorker::SetHasRefreshToken(bool has_refresh_token) {
191  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
192  has_refresh_token_ = has_refresh_token;
193}
194
195void FakeSyncWorker::UpdateServiceState(RemoteServiceState state,
196                                        const std::string& description) {
197  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
198
199  FOR_EACH_OBSERVER(
200      Observer, observers_,
201      UpdateServiceState(state, description));
202}
203
204}  // namespace drive_backend
205}  // namespace sync_file_system
206