[SyncFS] Add RemoteToLocalSyncer skeleton

 * Implements RemoteToLocalSyncer by the main point
 * Add necessary functions of MetadataDatabase as skeletons

BUG=240165
NOTRY=true

Review URL: https://codereview.chromium.org/59193003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@233249 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/sync_file_system/drive_backend/metadata_database.cc

@@ -895,6 +895,19 @@ void MetadataDatabase::UpdateTracker(int64 tracker_id,
   WriteToDatabase(batch.Pass(), callback);
 }
 
+bool MetadataDatabase::GetNormalPriorityDirtyTracker(FileTracker* tracker) {
+  // TODO(tzik): Split |dirty_trackers| to |normal_priority_dirty_trackers|
+  // and |low_priority_dirty_trackers|.
+  // Add a function to mark a dirty tracker low priority.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool MetadataDatabase::GetLowPriorityDirtyTracker(FileTracker* tracker) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
 MetadataDatabase::MetadataDatabase(base::SequencedTaskRunner* task_runner)
     : task_runner_(task_runner), weak_ptr_factory_(this) {
   DCHECK(task_runner);

chrome/browser/sync_file_system/drive_backend/metadata_database.h

@@ -224,6 +224,14 @@ class MetadataDatabase {
                      const FileDetails& updated_details,
                      const SyncStatusCallback& callback);
 
+  // Returns true if there is a normal priority dirty tracker.
+  // Assigns the dirty tracker if exists and |tracker| is non-NULL.
+  bool GetNormalPriorityDirtyTracker(FileTracker* tracker);
+
+  // Returns true if there is a low priority dirty tracker.
+  // Assigns the dirty tracker if exists and |tracker| is non-NULL.
+  bool GetLowPriorityDirtyTracker(FileTracker* tracker);
+
  private:
   friend class ListChangesTaskTest;
   friend class MetadataDatabaseTest;

chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.cc

@@ -4,15 +4,42 @@
 
 #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(SyncEngineContext* sync_context)
+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),
+      missing_remote_details_(false),
+      missing_synced_details_(false),
+      deleted_remote_details_(false),
+      deleted_synced_details_(false),
+      title_changed_(false),
+      content_changed_(false),
+      needs_folder_listing_(false),
+      missing_parent_(false),
+      sync_root_modification_(false),
       weak_ptr_factory_(this) {
 }
 
@@ -21,6 +48,199 @@ RemoteToLocalSyncer::~RemoteToLocalSyncer() {
 }
 
 void RemoteToLocalSyncer::Run(const SyncStatusCallback& callback) {
+  if (priorities_ & PRIORITY_NORMAL) {
+    if (metadata_database()->GetNormalPriorityDirtyTracker(&dirty_tracker_)) {
+      ResolveRemoteChange(callback);
+      return;
+    }
+  }
+
+  if (priorities_ & PRIORITY_LOW) {
+    if (metadata_database()->GetLowPriorityDirtyTracker(&dirty_tracker_)) {
+      ResolveRemoteChange(callback);
+      return;
+    }
+  }
+
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, SYNC_STATUS_NO_CHANGE_TO_SYNC));
+}
+
+void RemoteToLocalSyncer::AnalyzeCurrentDirtyTracker() {
+  if (!metadata_database()->FindFileByFileID(
+          dirty_tracker_.file_id(), &remote_metadata_)) {
+    missing_remote_details_ = true;
+    return;
+  }
+  missing_remote_details_ = false;
+
+  if (dirty_tracker_.has_synced_details() &&
+      !dirty_tracker_.synced_details().title().empty()) { // Just in case
+    missing_synced_details_ = true;
+    return;
+  }
+  missing_synced_details_ = false;
+
+  const FileDetails& synced_details = dirty_tracker_.synced_details();
+  const FileDetails& remote_details = remote_metadata_.details();
+
+  deleted_remote_details_ = remote_details.deleted();
+  deleted_synced_details_ = synced_details.deleted();
+  title_changed_ = synced_details.title() != remote_details.title();
+
+  switch (dirty_tracker_.synced_details().file_kind()) {
+    case FILE_KIND_UNSUPPORTED:
+      break;
+    case FILE_KIND_FILE:
+      content_changed_ = synced_details.md5() != remote_details.md5();
+      break;
+    case FILE_KIND_FOLDER:
+      needs_folder_listing_ = dirty_tracker_.needs_folder_listing();
+      break;
+  }
+
+  bool unknown_parent = !metadata_database()->FindTrackerByTrackerID(
+      dirty_tracker_.parent_tracker_id(), &parent_tracker_);
+  if (unknown_parent) {
+    DCHECK_EQ(metadata_database()->GetSyncRootTrackerID(),
+              dirty_tracker_.tracker_id());
+    sync_root_modification_ = true;
+  } else {
+    missing_parent_ = true;
+    std::string parent_folder_id = parent_tracker_.file_id();
+    for (int i = 0; i < remote_details.parent_folder_ids_size(); ++i) {
+      if (remote_details.parent_folder_ids(i) == parent_folder_id) {
+        missing_parent_ = false;
+        break;
+      }
+    }
+  }
+}
+
+void RemoteToLocalSyncer::ResolveRemoteChange(
+    const SyncStatusCallback& callback) {
+  AnalyzeCurrentDirtyTracker();
+
+  if (missing_remote_details_) {
+    GetRemoteResource(callback);
+    return;
+  }
+
+  if (missing_synced_details_) {
+    if (deleted_remote_details_) {
+      SyncCompleted(callback);
+      return;
+    }
+    HandleNewFile(callback);
+    return;
+  }
+
+  if (deleted_synced_details_) {
+    if (deleted_remote_details_) {
+      SyncCompleted(callback);
+      return;
+    }
+
+    HandleNewFile(callback);
+    return;
+  }
+
+  if (deleted_remote_details_) {
+    HandleDeletion(callback);
+    return;
+  }
+
+  if (title_changed_) {
+    HandleRename(callback);
+    return;
+  }
+
+  if (content_changed_) {
+    HandleContentUpdate(callback);
+    return;
+  }
+
+  if (needs_folder_listing_) {
+    ListFolderContent(callback);
+    return;
+  }
+
+  if (missing_parent_) {
+    HandleReorganize(callback);
+    return;
+  }
+
+  HandleOfflineSolvable(callback);
+}
+
+void RemoteToLocalSyncer::GetRemoteResource(
+    const SyncStatusCallback& callback) {
+  // TODO(tzik): FileMetadata is missing, retrieve and store it to
+  // MetadataDatabase.
+
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::HandleDeletion(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::HandleNewFile(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::HandleContentUpdate(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::ListFolderContent(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::HandleRename(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::HandleReorganize(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::HandleOfflineSolvable(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::SyncCompleted(
+    const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+}
+
+void RemoteToLocalSyncer::Prepare(const SyncStatusCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(SYNC_STATUS_FAILED);
+  // TODO(tzik): Call RemoteChangeProcessor::PrepareForProcessRemoteChange
+}
+
+void RemoteToLocalSyncer::DidPrepare(const SyncStatusCallback& callback,
+                                     SyncStatusCode status,
+                                     const SyncFileMetadata& metadata,
+                                     const FileChangeList& changes) {
   NOTIMPLEMENTED();
   callback.Run(SYNC_STATUS_FAILED);
 }

chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.h

@@ -6,6 +6,7 @@
 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_REMOTE_TO_LOCAL_SYNCER_H_
 
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/remote_change_processor.h"
 #include "chrome/browser/sync_file_system/sync_callbacks.h"
 #include "chrome/browser/sync_file_system/sync_task.h"
@@ -14,6 +15,10 @@ namespace drive {
 class DriveServiceInterface;
 }
 
+namespace drive {
+class DriveServiceInterface;
+}
+
 namespace sync_file_system {
 namespace drive_backend {
 
@@ -22,17 +27,64 @@ class SyncEngineContext;
 
 class RemoteToLocalSyncer : public SyncTask {
  public:
-  explicit RemoteToLocalSyncer(SyncEngineContext* sync_context);
+  enum Priority {
+    PRIORITY_NORMAL = 1 << 0,
+    PRIORITY_LOW = 1 << 1,
+  };
+
+  // |priorities| must be a bitwise-or'd value of Priority.
+  // Conflicting trackers will have low priority for RemoteToLocalSyncer so that
+  // it should be resolved by LocatToRemoteSyncer.
+  RemoteToLocalSyncer(SyncEngineContext* sync_context,
+                      int priorities);
   virtual ~RemoteToLocalSyncer();
   virtual void Run(const SyncStatusCallback& callback) OVERRIDE;
 
  private:
+  void AnalyzeCurrentDirtyTracker();
+
+  void ResolveRemoteChange(const SyncStatusCallback& callback);
+
+  void GetRemoteResource(const SyncStatusCallback& callback);
+
+  void HandleDeletion(const SyncStatusCallback& callback);
+  void HandleNewFile(const SyncStatusCallback& callback);
+  void HandleContentUpdate(const SyncStatusCallback& callback);
+  void ListFolderContent(const SyncStatusCallback& callback);
+  void HandleRename(const SyncStatusCallback& callback);
+  void HandleReorganize(const SyncStatusCallback& callback);
+  void HandleOfflineSolvable(const SyncStatusCallback& callback);
+
+  void SyncCompleted(const SyncStatusCallback& callback);
+
+  void Prepare(const SyncStatusCallback& callback);
+  void DidPrepare(const SyncStatusCallback& callback,
+                  SyncStatusCode status,
+                  const SyncFileMetadata& metadata,
+                  const FileChangeList& changes);
+
   drive::DriveServiceInterface* drive_service();
   MetadataDatabase* metadata_database();
   RemoteChangeProcessor* remote_change_processor();
 
   SyncEngineContext* sync_context_;  // Not owned.
 
+  int priorities_;
+  FileTracker dirty_tracker_;
+  FileTracker parent_tracker_;
+  FileMetadata remote_metadata_;
+
+  bool missing_remote_details_;
+  bool missing_synced_details_;
+  bool deleted_remote_details_;
+  bool deleted_synced_details_;
+  bool title_changed_;
+  bool content_changed_;
+  bool needs_folder_listing_;
+  bool missing_parent_;
+
+  bool sync_root_modification_;
+
   base::WeakPtrFactory<RemoteToLocalSyncer> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteToLocalSyncer);

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

@@ -119,7 +119,8 @@ void SyncEngine::UninstallOrigin(
 
 void SyncEngine::ProcessRemoteChange(
     const SyncFileCallback& callback) {
-  RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(this);
+  RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(
+      this, RemoteToLocalSyncer::PRIORITY_NORMAL);
   task_manager_->ScheduleSyncTask(
       scoped_ptr<SyncTask>(syncer),
       base::Bind(&SyncEngine::DidProcessRemoteChange,