Migrated sync_file_status, sync_action and sync_direction from fileapi:: namespace to sync_file_sys…

chrome/browser/sync_file_system/drive_file_sync_service.cc

 // Copyright (c) 2012 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_file_sync_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 167 matching lines @@
 struct DriveFileSyncService::ProcessRemoteChangeParam {
   scoped_ptr<TaskToken> token;
   RemoteChangeProcessor* processor;
   RemoteChange remote_change;
   fileapi::SyncFileCallback callback;
 
   DriveMetadata drive_metadata;
   bool metadata_updated;
   base::FilePath temporary_file_path;
   std::string md5_checksum;
-  fileapi::SyncAction sync_action;
+  SyncAction sync_action;
   bool clear_local_changes;
 
   ProcessRemoteChangeParam(scoped_ptr<TaskToken> token,
                            RemoteChangeProcessor* processor,
                            const RemoteChange& remote_change,
                            const fileapi::SyncFileCallback& callback)
       : token(token.Pass()),
         processor(processor),
         remote_change(remote_change),
         callback(callback),
         metadata_updated(false),
-        sync_action(fileapi::SYNC_ACTION_NONE),
+        sync_action(SYNC_ACTION_NONE),
         clear_local_changes(true) {
   }
 };
 
 DriveFileSyncService::ChangeQueueItem::ChangeQueueItem()
     : changestamp(0),
       sync_type(REMOTE_SYNC_TYPE_INCREMENTAL) {
 }
 
 DriveFileSyncService::ChangeQueueItem::ChangeQueueItem(
@@ skipping 401 matching lines @@
         metadata.set_md5_checksum(std::string());
       }
       metadata.set_conflicted(true);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url,
                      google_apis::HTTP_CONFLICT, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
     case LOCAL_SYNC_OPERATION_RESOLVE_TO_REMOTE: {
       // Mark the file as to-be-fetched.
       DriveMetadata metadata;
       const fileapi::SyncStatusCode status =
           metadata_store_->ReadEntry(url, &metadata);
       DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
       metadata.set_conflicted(false);
       metadata.set_to_be_fetched(true);
@@ skipping 556 matching lines @@
     DriveMetadata metadata;
     metadata.set_resource_id(resource_id);
     metadata.set_md5_checksum(file_md5);
     metadata.set_conflicted(false);
     metadata.set_to_be_fetched(false);
     metadata_store_->UpdateEntry(
         url, metadata,
         base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                    AsWeakPtr(), base::Passed(&token), url, error, callback));
     NotifyObserversFileStatusChanged(url,
-                                     fileapi::SYNC_FILE_STATUS_SYNCED,
-                                     fileapi::SYNC_ACTION_ADDED,
-                                     fileapi::SYNC_DIRECTION_LOCAL_TO_REMOTE);
+                                     SYNC_FILE_STATUS_SYNCED,
+                                     SYNC_ACTION_ADDED,
+                                     SYNC_DIRECTION_LOCAL_TO_REMOTE);
     return;
   }
   FinalizeLocalSync(token.Pass(), callback,
                     GDataErrorCodeToSyncStatusCodeWrapper(error));
 }
 
 void DriveFileSyncService::DidUploadExistingFileForLocalSync(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
     const std::string& file_md5) {
   switch (error) {
     case google_apis::HTTP_SUCCESS: {
       DriveMetadata metadata;
       metadata.set_resource_id(resource_id);
       metadata.set_md5_checksum(file_md5);
       metadata.set_conflicted(false);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_SYNCED,
-                                       fileapi::SYNC_ACTION_UPDATED,
-                                       fileapi::SYNC_DIRECTION_LOCAL_TO_REMOTE);
+                                       SYNC_FILE_STATUS_SYNCED,
+                                       SYNC_ACTION_UPDATED,
+                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
       return;
     }
     case google_apis::HTTP_CONFLICT: {
       // Mark the file as conflicted.
       DriveMetadata metadata;
       const fileapi::SyncStatusCode status =
           metadata_store_->ReadEntry(url, &metadata);
       DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
       metadata.set_conflicted(true);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
     case google_apis::HTTP_NOT_MODIFIED: {
       DidApplyLocalChange(token.Pass(), url, google_apis::HTTP_SUCCESS,
                           callback, fileapi::SYNC_STATUS_OK);
       return;
     }
     default: {
       const fileapi::SyncStatusCode status =
           GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(fileapi::SYNC_STATUS_OK, status);
       FinalizeLocalSync(token.Pass(), callback, status);
       return;
     }
   }
 }
 
 void DriveFileSyncService::DidDeleteFileForLocalSync(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error) {
   switch (error) {
     case google_apis::HTTP_SUCCESS: {
       metadata_store_->DeleteEntry(
           url,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_SYNCED,
-                                       fileapi::SYNC_ACTION_DELETED,
-                                       fileapi::SYNC_DIRECTION_LOCAL_TO_REMOTE);
+                                       SYNC_FILE_STATUS_SYNCED,
+                                       SYNC_ACTION_DELETED,
+                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
       return;
     }
     case google_apis::HTTP_PRECONDITION:
       // FALLTHROUGH
     case google_apis::HTTP_CONFLICT: {
       // Mark the file as conflicted.
       DriveMetadata metadata;
       const fileapi::SyncStatusCode status =
           metadata_store_->ReadEntry(url, &metadata);
       DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
       metadata.set_conflicted(true);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
     default: {
       const fileapi::SyncStatusCode status =
           GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(fileapi::SYNC_STATUS_OK, status);
       FinalizeLocalSync(token.Pass(), callback, status);
       return;
     }
   }
@@ skipping 37 matching lines @@
                  << (missing_local_file ? " (missing local file)" : " ")
                  << " remote_change: " << remote_file_change.DebugString()
                  << " ==> operation: ResolveConflictToRemoteChange";
 
         const fileapi::FileSystemURL& url = param->remote_change.url;
         param->drive_metadata.set_conflicted(false);
         param->drive_metadata.set_to_be_fetched(true);
         metadata_store_->UpdateEntry(
             url, drive_metadata, base::Bind(&EmptyStatusCallback));
 
-        param->sync_action = fileapi::SYNC_ACTION_ADDED;
+        param->sync_action = SYNC_ACTION_ADDED;
         DownloadForRemoteSync(param.Pass());
         return;
       }
 
       DCHECK(remote_file_change.IsDelete());
-      param->sync_action = fileapi::SYNC_ACTION_NONE;
+      param->sync_action = SYNC_ACTION_NONE;
       DeleteMetadataForRemoteSync(param.Pass());
       return;
     }
 
     DCHECK(!missing_local_file);
     if (remote_file_change.IsAddOrUpdate()) {
-      param->sync_action = fileapi::SYNC_ACTION_NONE;
+      param->sync_action = SYNC_ACTION_NONE;
       param->drive_metadata.set_conflicted(true);
       param->drive_metadata.set_to_be_fetched(false);
 
       metadata_store_->UpdateEntry(
           url, drive_metadata,
           base::Bind(&DriveFileSyncService::CompleteRemoteSync, AsWeakPtr(),
                      base::Passed(&param)));
       return;
     }
 
     DCHECK(remote_file_change.IsDelete());
     DVLOG(1) << "ProcessRemoteChange for " << url.DebugString()
              << (param->drive_metadata.conflicted() ? " (conflicted)" : " ")
              << (missing_local_file ? " (missing local file)" : " ")
              << " remote_change: " << remote_file_change.DebugString()
              << " ==> operation: ResolveConflictToLocalChange";
 
-    param->sync_action = fileapi::SYNC_ACTION_NONE;
+    param->sync_action = SYNC_ACTION_NONE;
     param->clear_local_changes = false;
 
     RemoteChangeProcessor* processor = param->processor;
     processor->RecordFakeLocalChange(
         url,
         fileapi::FileChange(fileapi::FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                             fileapi::SYNC_FILE_TYPE_FILE),
         base::Bind(&DriveFileSyncService::DidResolveConflictToLocalChange,
                    AsWeakPtr(), base::Passed(&param)));
     return;
   }
 
   DCHECK(!param->drive_metadata.conflicted());
   if (remote_file_change.IsAddOrUpdate()) {
     if (local_changes.empty()) {
       if (missing_local_file) {
-        param->sync_action = fileapi::SYNC_ACTION_ADDED;
+        param->sync_action = SYNC_ACTION_ADDED;
         DownloadForRemoteSync(param.Pass());
         return;
       }
 
       DCHECK(!missing_local_file);
-      param->sync_action = fileapi::SYNC_ACTION_UPDATED;
+      param->sync_action = SYNC_ACTION_UPDATED;
       DownloadForRemoteSync(param.Pass());
       return;
     }
 
     DCHECK(!local_changes.empty());
     if (local_changes.list().back().IsAddOrUpdate()) {
       param->drive_metadata.set_conflicted(true);
       param->drive_metadata.set_to_be_fetched(false);
 
       metadata_store_->UpdateEntry(
           url, drive_metadata,
           base::Bind(&DriveFileSyncService::CompleteRemoteSync, AsWeakPtr(),
                      base::Passed(&param)));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
 
     DCHECK(local_changes.list().back().IsDelete());
-    param->sync_action = fileapi::SYNC_ACTION_ADDED;
+    param->sync_action = SYNC_ACTION_ADDED;
     DownloadForRemoteSync(param.Pass());
     return;
   }
 
   DCHECK(remote_file_change.IsDelete());
   if (local_changes.empty()) {
     if (missing_local_file) {
-      param->sync_action = fileapi::SYNC_ACTION_NONE;
+      param->sync_action = SYNC_ACTION_NONE;
       if (missing_db_entry)
         CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
       else
         DeleteMetadataForRemoteSync(param.Pass());
       return;
     }
     DCHECK(!missing_local_file);
-    param->sync_action = fileapi::SYNC_ACTION_DELETED;
+    param->sync_action = SYNC_ACTION_DELETED;
 
     const fileapi::FileChange& file_change = remote_file_change;
     param->processor->ApplyRemoteChange(
         file_change, base::FilePath(), url,
         base::Bind(&DriveFileSyncService::DidApplyRemoteChange, AsWeakPtr(),
                    base::Passed(&param)));
     return;
   }
 
   DCHECK(!local_changes.empty());
   if (local_changes.list().back().IsAddOrUpdate()) {
-    param->sync_action = fileapi::SYNC_ACTION_NONE;
+    param->sync_action = SYNC_ACTION_NONE;
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
   }
 
   DCHECK(local_changes.list().back().IsDelete());
-  param->sync_action = fileapi::SYNC_ACTION_NONE;
+  param->sync_action = SYNC_ACTION_NONE;
   if (missing_db_entry)
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
   else
     DeleteMetadataForRemoteSync(param.Pass());
 }
 
 void DriveFileSyncService::DidResolveConflictToLocalChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     fileapi::SyncStatusCode status) {
   if (status != fileapi::SYNC_STATUS_OK) {
@@ skipping 43 matching lines @@
       temporary_file_path,
       base::Bind(&DriveFileSyncService::DidDownloadFileForRemoteSync,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidDownloadFileForRemoteSync(
     scoped_ptr<ProcessRemoteChangeParam> param,
     google_apis::GDataErrorCode error,
     const std::string& md5_checksum) {
   if (error == google_apis::HTTP_NOT_MODIFIED) {
-    param->sync_action = fileapi::SYNC_ACTION_NONE;
+    param->sync_action = SYNC_ACTION_NONE;
     DidApplyRemoteChange(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
   }
 
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
@@ skipping 100 matching lines @@
                         AsWeakPtr(), base::Passed(&param), status));
     return;
   }
 
   if (!param->temporary_file_path.empty())
     DeleteTemporaryFile(param->temporary_file_path);
   NotifyTaskDone(status, param->token.Pass());
   if (status == fileapi::SYNC_STATUS_HAS_CONFLICT ||
       param->drive_metadata.conflicted()) {
     NotifyObserversFileStatusChanged(param->remote_change.url,
-                                     fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                     fileapi::SYNC_ACTION_NONE,
-                                     fileapi::SYNC_DIRECTION_NONE);
+                                     SYNC_FILE_STATUS_CONFLICTING,
+                                     SYNC_ACTION_NONE,
+                                     SYNC_DIRECTION_NONE);
   } else if (status == fileapi::SYNC_STATUS_OK &&
-             param->sync_action != fileapi::SYNC_ACTION_NONE) {
+             param->sync_action != SYNC_ACTION_NONE) {
     NotifyObserversFileStatusChanged(param->remote_change.url,
-                                     fileapi::SYNC_FILE_STATUS_SYNCED,
+                                     SYNC_FILE_STATUS_SYNCED,
                                      param->sync_action,
-                                     fileapi::SYNC_DIRECTION_REMOTE_TO_LOCAL);
+                                     SYNC_DIRECTION_REMOTE_TO_LOCAL);
   }
   param->callback.Run(status, param->remote_change.url);
 }
 
 bool DriveFileSyncService::AppendRemoteChange(
     const GURL& origin,
     const google_apis::ResourceEntry& entry,
     int64 changestamp,
     RemoteSyncType sync_type) {
   // TODO(tzik): Normalize the path here.
@@ skipping 332 matching lines @@
 DriveFileSyncService::GDataErrorCodeToSyncStatusCodeWrapper(
     google_apis::GDataErrorCode error) const {
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != fileapi::SYNC_STATUS_OK && !sync_client_->IsAuthenticated())
     return fileapi::SYNC_STATUS_AUTHENTICATION_FAILED;
   return status;
 }
 
 void DriveFileSyncService::NotifyObserversFileStatusChanged(
     const fileapi::FileSystemURL& url,
-    fileapi::SyncFileStatus sync_status,
-    fileapi::SyncAction action_taken,
-    fileapi::SyncDirection direction) {
-  if (sync_status != fileapi::SYNC_FILE_STATUS_SYNCED) {
-    DCHECK_EQ(fileapi::SYNC_ACTION_NONE, action_taken);
-    DCHECK_EQ(fileapi::SYNC_DIRECTION_NONE, direction);
+    SyncFileStatus sync_status,
+    SyncAction action_taken,
+    SyncDirection direction) {
+  if (sync_status != SYNC_FILE_STATUS_SYNCED) {
+    DCHECK_EQ(SYNC_ACTION_NONE, action_taken);
+    DCHECK_EQ(SYNC_DIRECTION_NONE, direction);
   }
 
   FOR_EACH_OBSERVER(
       FileStatusObserver, file_status_observers_,
       OnFileStatusChanged(url, sync_status, action_taken, direction));
 }
 
 }  // namespace sync_file_system