[SyncFS] Create FakeSyncWorker class

chrome/browser/sync_file_system/drive_backend/fake_sync_worker.cc

+// Copyright 2014 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.
+
+#include "chrome/browser/sync_file_system/drive_backend/fake_sync_worker.h"
+
+#include "base/values.h"
+#include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
+#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
+#include "chrome/browser/sync_file_system/sync_status_code.h"
+
+namespace sync_file_system {
+namespace drive_backend {
+
+FakeSyncWorker::FakeSyncWorker(
+    const base::FilePath& base_dir,
+    scoped_ptr<SyncEngineContext> sync_engine_context,
+    leveldb::Env* env_override)
+    : base_dir_(base_dir),
+      sync_engine_context_(sync_engine_context.Pass()),
+      env_override_(env_override),
+      sync_enabled_(true),
+      has_refresh_token_(true),
+      network_available_(true),
+      weak_ptr_factory_(this) {
+  sequence_checker_.DetachFromSequence();
+}
+
+FakeSyncWorker::~FakeSyncWorker() {
+  observers_.Clear();
+}
+
+void FakeSyncWorker::Initialize() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  MetadataDatabase::Create(
+      sync_engine_context_->GetWorkerTaskRunner(),
+      sync_engine_context_->GetFileTaskRunner(),
+      base_dir_.Append(kDatabaseName),
+      env_override_,
+      base::Bind(&FakeSyncWorker::DidCreateMetadataDatabase,
+                 weak_ptr_factory_.GetWeakPtr()));

[tzik, 2014/06/12 07:54:52]

Can we drop MetadataDatabase dependency from this class?

[peria, 2014/06/12 10:49:30]

Done.

+}
+
+void FakeSyncWorker::DidCreateMetadataDatabase(
+    SyncStatusCode status,
+    scoped_ptr<MetadataDatabase> metadata_database) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  if (metadata_database)
+    sync_engine_context_->SetMetadataDatabase(metadata_database.Pass());
+}
+
+void FakeSyncWorker::RegisterOrigin(const GURL& origin,
+                                    const SyncStatusCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  status_map_[origin] = true;
+  callback.Run(SYNC_STATUS_OK);
+}
+
+void FakeSyncWorker::EnableOrigin(const GURL& origin,
+                                  const SyncStatusCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  status_map_[origin] = true;
+  callback.Run(SYNC_STATUS_OK);
+}
+
+void FakeSyncWorker::DisableOrigin(const GURL& origin,
+                                   const SyncStatusCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  status_map_[origin] = false;
+  callback.Run(SYNC_STATUS_OK);
+}
+
+void FakeSyncWorker::UninstallOrigin(const GURL& origin,

[nhiroki, 2014/06/12 08:00:08]

You may want to record uninstalled origins like Registered/Enabled/Disabled
origins? For example,

enum AppStatus {
  REGISTERED,
  ENABLED,
  DISABLED,
  UNINSTALLED,
};
std::map<GURL, AppStatus> status_map_;

[peria, 2014/06/12 10:49:30]

Done.

+                                     RemoteFileSyncService::UninstallFlag flag,
+                                     const SyncStatusCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  status_map_.erase(origin);
+  callback.Run(SYNC_STATUS_OK);
+}
+
+void FakeSyncWorker::ProcessRemoteChange(
+    const SyncFileCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  callback.Run(SYNC_STATUS_OK, fileapi::FileSystemURL());
+}
+
+void FakeSyncWorker::SetRemoteChangeProcessor(
+    RemoteChangeProcessorOnWorker* remote_change_processor_on_worker) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+}
+
+RemoteServiceState FakeSyncWorker::GetCurrentState() const {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return REMOTE_SERVICE_OK;
+}
+
+void FakeSyncWorker::GetOriginStatusMap(
+    const RemoteFileSyncService::StatusMapCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  scoped_ptr<RemoteFileSyncService::OriginStatusMap>
+      status_map(new RemoteFileSyncService::OriginStatusMap);
+  for (StatusMap::const_iterator itr = status_map_.begin();
+       itr != status_map_.end(); ++itr) {
+    (*status_map)[itr->first] = itr->second ? "Enabled" : "Disabled";
+  }
+  callback.Run(status_map.Pass());
+}
+
+scoped_ptr<base::ListValue> FakeSyncWorker::DumpFiles(const GURL& origin) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return scoped_ptr<base::ListValue>();
+}
+
+scoped_ptr<base::ListValue> FakeSyncWorker::DumpDatabase() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return scoped_ptr<base::ListValue>();
+}
+
+void FakeSyncWorker::SetSyncEnabled(bool enabled) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  sync_enabled_ = enabled;
+
+  if (enabled)
+    UpdateServiceState(REMOTE_SERVICE_OK, "Set FakeSyncWorker enabled.");
+  else
+    UpdateServiceState(REMOTE_SERVICE_DISABLED, "Disabled FakeSyncWorker.");
+}
+
+void FakeSyncWorker::PromoteDemotedChanges() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  FOR_EACH_OBSERVER(
+      Observer,
+      observers_,
+      OnPendingFileListUpdated(10));
+}
+
+void FakeSyncWorker::ApplyLocalChange(
+    const FileChange& local_change,
+    const base::FilePath& local_path,
+    const SyncFileMetadata& local_metadata,
+    const fileapi::FileSystemURL& url,
+    const SyncStatusCallback& callback) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  callback.Run(SYNC_STATUS_OK);
+}
+
+void FakeSyncWorker::OnNotificationReceived() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  UpdateServiceState(REMOTE_SERVICE_OK, "Got push notification for Drive.");
+}
+
+void FakeSyncWorker::OnReadyToSendRequests(const std::string& account_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  has_refresh_token_ = true;
+  UpdateServiceState(REMOTE_SERVICE_OK, "ReadyToSendRequests");
+}
+
+void FakeSyncWorker::OnRefreshTokenInvalid() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  has_refresh_token_ = false;
+  UpdateServiceState(REMOTE_SERVICE_OK, "RefreshTokenInvalid");
+}
+
+void FakeSyncWorker::OnNetworkChanged(
+    net::NetworkChangeNotifier::ConnectionType type) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  bool new_network_availability =
+      type != net::NetworkChangeNotifier::CONNECTION_NONE;
+  if (network_available_ && !new_network_availability) {
+    UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, "Disconnected");
+  } else if (!network_available_ && new_network_availability) {
+    UpdateServiceState(REMOTE_SERVICE_OK, "Connected");
+  }
+  network_available_ = new_network_availability;
+}
+
+drive::DriveServiceInterface* FakeSyncWorker::GetDriveService() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return sync_engine_context_->GetDriveService();
+}
+
+drive::DriveUploaderInterface* FakeSyncWorker::GetDriveUploader() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return sync_engine_context_->GetDriveUploader();
+}
+
+MetadataDatabase* FakeSyncWorker::GetMetadataDatabase() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return sync_engine_context_->GetMetadataDatabase();
+}
+
+SyncTaskManager* FakeSyncWorker::GetSyncTaskManager() {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  return NULL;
+}
+
+void FakeSyncWorker::DetachFromSequence() {
+  sequence_checker_.DetachFromSequence();
+}
+
+void FakeSyncWorker::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void FakeSyncWorker::UpdateServiceStateForTesting(
+    RemoteServiceState state,
+    const std::string& description,
+    const base::Closure& closure) {
+  UpdateServiceState(state, description);
+  closure.Run();
+}
+
+void FakeSyncWorker::SetHasRefreshToken(bool has_refresh_token) {
+}
+
+void FakeSyncWorker::UpdateServiceState(RemoteServiceState state,
+                                        const std::string& description) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  FOR_EACH_OBSERVER(
+      Observer, observers_,
+      UpdateServiceState(state, description));
+}
+
+
+}  // namespace drive_backend
+}  // namespace sync_file_system