[SyncFS] Add RemoteToLocalSyncer skeleton

chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.cc

 // Copyright 2013 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/remote_to_local_syncer.h"
 
+#include "base/bind.h"
 #include "base/callback.h"
+#include "base/location.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
-RemoteToLocalSyncer::RemoteToLocalSyncer() {
+namespace {
+
+bool BuildFileSystemURLForTracker(
+    MetadataDatabase* metadata_database,
+    int tracker_id,
+    fileapi::FileSystemURL* url) {
   NOTIMPLEMENTED();
+  return false;
+}
+
+}  // namespace
+
+RemoteToLocalSyncer::RemoteToLocalSyncer(SyncEngineContext* sync_context,
+                                         int priorities)
+    : sync_context_(sync_context),
+      priorities_(priorities),
+      weak_ptr_factory_(this) {
 }
 
 RemoteToLocalSyncer::~RemoteToLocalSyncer() {
   NOTIMPLEMENTED();
 }
 
 void RemoteToLocalSyncer::Run(const SyncStatusCallback& callback) {
+  if (priorities_ & PRIORITY_NORMAL) {
+    if (metadata_database()->GetNormalPriorityDirtyTracker(&dirty_tracker_)) {
+      ResolveTrivial(callback);
+      return;
+    }
+  }
+
+  if (priorities_ & PRIORITY_LOW) {
+    if (metadata_database()->GetNormalPriorityDirtyTracker(&dirty_tracker_)) {

[kinuko, 2013/11/05 13:36:13]

GetLowPriorityDirtyTracker?

[tzik, 2013/11/06 04:56:08]

Done.

+      ResolveTrivial(callback);
+      return;
+    }
+  }
+
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, SYNC_STATUS_NO_CHANGE_TO_SYNC));
+}
+
+void RemoteToLocalSyncer::ResolveTrivial(const SyncStatusCallback& callback) {
+  metadata_database()->ResolveTrivialDirtiness(
+      dirty_tracker_.tracker_id(),
+      base::Bind(&RemoteToLocalSyncer::DidResolveTrivial,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void RemoteToLocalSyncer::DidResolveTrivial(
+    const SyncStatusCallback& callback,
+    SyncStatusCode status) {
+  if (status == SYNC_STATUS_OK) {
+    callback.Run(SYNC_STATUS_OK);
+    return;
+  }
+
+  DCHECK_EQ(SYNC_STATUS_NO_CHANGE_TO_SYNC, status);
+
+  fileapi::FileSystemURL url;
+  BuildFileSystemURLForTracker(metadata_database(),
+                               dirty_tracker_.tracker_id(),
+                               &url);
+  remote_change_processor()->PrepareForProcessRemoteChange(
+      url,
+      base::Bind(&RemoteToLocalSyncer::DidPrepare,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback));
+}
+
+void RemoteToLocalSyncer::DidPrepare(const SyncStatusCallback& callback,
+                                     SyncStatusCode status,
+                                     const SyncFileMetadata& metadata,
+                                     const FileChangeList& changes) {
   NOTIMPLEMENTED();
   callback.Run(SYNC_STATUS_FAILED);
 }
 
+drive::DriveServiceInterface* RemoteToLocalSyncer::drive_service() {
+  return sync_context_->GetDriveService();
+}
+
+MetadataDatabase* RemoteToLocalSyncer::metadata_database() {
+  return sync_context_->GetMetadataDatabase();
+}
+
+RemoteChangeProcessor* RemoteToLocalSyncer::remote_change_processor() {
+  DCHECK(sync_context_->GetRemoteChangeProcessor());
+  return sync_context_->GetRemoteChangeProcessor();
+}
+
 }  // namespace drive_backend
 }  // namespace sync_file_system