components/sync_driver/fake_sync_service.cc

   1 // Copyright 2015 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 "components/sync_driver/fake_sync_service.h"
   6
   7 #include "base/values.h"
   8 #include "sync/internal_api/public/base_transaction.h"
   9 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
  10 #include "sync/internal_api/public/user_share.h"
  11
  12 namespace sync_driver {
  13
  14 FakeSyncService::FakeSyncService()
  15     : error_(GoogleServiceAuthError::NONE),
  16       user_share_(make_scoped_ptr(new syncer::UserShare())) {}
  17
  18 FakeSyncService::~FakeSyncService() {
  19 }
  20
  21 bool FakeSyncService::HasSyncSetupCompleted() const {
  22   return false;
  23 }
  24
  25 bool FakeSyncService::IsSyncAllowed() const {
  26   return false;
  27 }
  28
  29 bool FakeSyncService::IsSyncActive() const {
  30   return false;
  31 }
  32
  33 syncer::ModelTypeSet FakeSyncService::GetActiveDataTypes() const {
  34   return syncer::ModelTypeSet();
  35 }
  36
  37 void FakeSyncService::AddObserver(SyncServiceObserver* observer) {
  38 }
  39
  40 void FakeSyncService::RemoveObserver(SyncServiceObserver* observer) {
  41 }
  42
  43 bool FakeSyncService::HasObserver(const SyncServiceObserver* observer) const {
  44   return false;
  45 }
  46
  47 bool FakeSyncService::CanSyncStart() const {
  48   return false;
  49 }
  50
  51 void FakeSyncService::OnDataTypeRequestsSyncStartup(syncer::ModelType type) {
  52 }
  53
  54 void FakeSyncService::RequestStop(
  55     sync_driver::SyncService::SyncStopDataFate data_fate) {
  56 }
  57
  58 void FakeSyncService::RequestStart() {
  59 }
  60
  61 syncer::ModelTypeSet FakeSyncService::GetPreferredDataTypes() const {
  62   return syncer::ModelTypeSet();
  63 }
  64
  65 void FakeSyncService::OnUserChoseDatatypes(bool sync_everything,
  66                                            syncer::ModelTypeSet chosen_types) {
  67 }
  68
  69 void FakeSyncService::SetSyncSetupCompleted() {
  70 }
  71
  72 bool FakeSyncService::IsFirstSetupInProgress() const {
  73   return false;
  74 }
  75
  76 void FakeSyncService::SetSetupInProgress(bool setup_in_progress) {
  77 }
  78
  79 bool FakeSyncService::IsSetupInProgress() const {
  80   return false;
  81 }
  82
  83 bool FakeSyncService::ConfigurationDone() const {
  84   return false;
  85 }
  86
  87 const GoogleServiceAuthError& FakeSyncService::GetAuthError() const {
  88   return error_;
  89 }
  90
  91 bool FakeSyncService::HasUnrecoverableError() const {
  92   return false;
  93 }
  94
  95 bool FakeSyncService::IsBackendInitialized() const {
  96   return false;
  97 }
  98
  99 OpenTabsUIDelegate* FakeSyncService::GetOpenTabsUIDelegate() {
 100   return nullptr;
 101 }
 102
 103 bool FakeSyncService::IsPassphraseRequiredForDecryption() const {
 104   return false;
 105 }
 106
 107 base::Time FakeSyncService::GetExplicitPassphraseTime() const {
 108   return base::Time();
 109 }
 110
 111 bool FakeSyncService::IsUsingSecondaryPassphrase() const {
 112   return false;
 113 }
 114
 115 void FakeSyncService::EnableEncryptEverything() {
 116 }
 117
 118 bool FakeSyncService::IsEncryptEverythingEnabled() const {
 119   return false;
 120 }
 121
 122 void FakeSyncService::SetEncryptionPassphrase(const std::string& passphrase,
 123                                               PassphraseType type) {
 124 }
 125
 126 bool FakeSyncService::SetDecryptionPassphrase(const std::string& passphrase) {
 127   return false;
 128 }
 129
 130 bool FakeSyncService::IsCryptographerReady(
 131     const syncer::BaseTransaction* trans) const {
 132   return false;
 133 }
 134
 135 syncer::UserShare* FakeSyncService::GetUserShare() const {
 136   return user_share_.get();
 137 }
 138
 139 LocalDeviceInfoProvider* FakeSyncService::GetLocalDeviceInfoProvider() const {
 140   return nullptr;
 141 }
 142
 143 void FakeSyncService::RegisterDataTypeController(
 144       sync_driver::DataTypeController* data_type_controller) {
 145 }
 146
 147 void FakeSyncService::ReenableDatatype(syncer::ModelType type) {}
 148
 149 void FakeSyncService::DeactivateDataType(syncer::ModelType type) {}
 150
 151 bool FakeSyncService::IsPassphraseRequired() const {
 152   return false;
 153 }
 154
 155 syncer::ModelTypeSet FakeSyncService::GetEncryptedDataTypes() const {
 156   return syncer::ModelTypeSet();
 157 }
 158
 159 FakeSyncService::SyncTokenStatus FakeSyncService::GetSyncTokenStatus() const {
 160   return FakeSyncService::SyncTokenStatus();
 161 }
 162
 163 std::string FakeSyncService::QuerySyncStatusSummaryString() {
 164   return "";
 165 }
 166
 167 bool FakeSyncService::QueryDetailedSyncStatus(syncer::SyncStatus* result) {
 168   return false;
 169 }
 170
 171 base::string16 FakeSyncService::GetLastSyncedTimeString() const {
 172   return base::string16();
 173 }
 174
 175 std::string FakeSyncService::GetBackendInitializationStateString() const {
 176   return std::string();
 177 }
 178
 179 syncer::sessions::SyncSessionSnapshot FakeSyncService::GetLastSessionSnapshot()
 180     const {
 181   return syncer::sessions::SyncSessionSnapshot();
 182 }
 183
 184 base::Value* FakeSyncService::GetTypeStatusMap() const {
 185   return new base::ListValue();
 186 }
 187
 188 const GURL& FakeSyncService::sync_service_url() const {
 189   return sync_service_url_;
 190 }
 191
 192 std::string FakeSyncService::unrecoverable_error_message() const {
 193   return unrecoverable_error_message_;
 194 }
 195
 196 tracked_objects::Location FakeSyncService::unrecoverable_error_location()
 197     const {
 198   return tracked_objects::Location();
 199 }
 200
 201 }  // namespace sync_driver