Home | History | Annotate | Download | only in drive_backend 
      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 
     12 namespace sync_file_system {
     13 namespace drive_backend {
     14 
     15 FakeSyncWorker::FakeSyncWorker()
     16     : sync_enabled_(true),
     17       has_refresh_token_(true),
     18       network_available_(true) {
     19   sequence_checker_.DetachFromSequence();
     20 }
     21 
     22 FakeSyncWorker::~FakeSyncWorker() {
     23   observers_.Clear();
     24 }
     25 
     26 void 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 
     35 void 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 
     43 void 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 
     51 void 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 
     59 void 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 
     68 void FakeSyncWorker::ProcessRemoteChange(
     69     const SyncFileCallback& callback) {
     70   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
     71   callback.Run(SYNC_STATUS_OK, fileapi::FileSystemURL());
     72 }
     73 
     74 void FakeSyncWorker::SetRemoteChangeProcessor(
     75     RemoteChangeProcessorOnWorker* remote_change_processor_on_worker) {
     76   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
     77 }
     78 
     79 RemoteServiceState FakeSyncWorker::GetCurrentState() const {
     80   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
     81   return REMOTE_SERVICE_OK;
     82 }
     83 
     84 void 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 
    113 scoped_ptr<base::ListValue> FakeSyncWorker::DumpFiles(const GURL& origin) {
    114   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    115   return scoped_ptr<base::ListValue>();
    116 }
    117 
    118 scoped_ptr<base::ListValue> FakeSyncWorker::DumpDatabase() {
    119   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    120   return scoped_ptr<base::ListValue>();
    121 }
    122 
    123 void 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 
    133 void FakeSyncWorker::PromoteDemotedChanges() {
    134   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    135   FOR_EACH_OBSERVER(
    136       Observer,
    137       observers_,
    138       OnPendingFileListUpdated(10));
    139 }
    140 
    141 void 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 
    151 void FakeSyncWorker::OnNotificationReceived() {
    152   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    153   UpdateServiceState(REMOTE_SERVICE_OK, "Got push notification for Drive.");
    154 }
    155 
    156 void FakeSyncWorker::OnReadyToSendRequests() {
    157   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    158   has_refresh_token_ = true;
    159   UpdateServiceState(REMOTE_SERVICE_OK, "ReadyToSendRequests");
    160 }
    161 
    162 void FakeSyncWorker::OnRefreshTokenInvalid() {
    163   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    164   has_refresh_token_ = false;
    165   UpdateServiceState(REMOTE_SERVICE_OK, "RefreshTokenInvalid");
    166 }
    167 
    168 void 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 
    181 drive::DriveServiceInterface* FakeSyncWorker::GetDriveService() {
    182   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    183   return NULL;
    184 }
    185 
    186 drive::DriveUploaderInterface* FakeSyncWorker::GetDriveUploader() {
    187   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    188   return NULL;
    189 }
    190 
    191 MetadataDatabase* FakeSyncWorker::GetMetadataDatabase() {
    192   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    193   return NULL;
    194 }
    195 
    196 SyncTaskManager* FakeSyncWorker::GetSyncTaskManager() {
    197   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    198   return NULL;
    199 }
    200 
    201 void FakeSyncWorker::DetachFromSequence() {
    202   sequence_checker_.DetachFromSequence();
    203 }
    204 
    205 void FakeSyncWorker::AddObserver(Observer* observer) {
    206   // This method is called on UI thread.
    207   observers_.AddObserver(observer);
    208 }
    209 
    210 void FakeSyncWorker::SetHasRefreshToken(bool has_refresh_token) {
    211   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    212   has_refresh_token_ = has_refresh_token;
    213 }
    214 
    215 void FakeSyncWorker::UpdateServiceState(RemoteServiceState state,
    216                                         const std::string& description) {
    217   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
    218 
    219   FOR_EACH_OBSERVER(
    220       Observer, observers_,
    221       UpdateServiceState(state, description));
    222 }
    223 
    224 }  // namespace drive_backend
    225 }  // namespace sync_file_system
    226