Migrated sync_file_type and file_change from namespace fileapi to sync_file_system.

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 65 matching lines @@
 
 void EmptyStatusCallback(fileapi::SyncStatusCode code) {}
 
 void DidRemoveOrigin(const GURL& origin, fileapi::SyncStatusCode status) {
   // TODO(calvinlo): Disable syncing if status not ok (http://crbug.com/171611).
   DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
   LOG(WARNING) << "Remove origin failed for: " << origin.spec()
                << " status=" << status;
 }
 
-fileapi::FileChange CreateFileChange(bool is_deleted) {
+FileChange CreateFileChange(bool is_deleted) {
   if (is_deleted) {
-    return fileapi::FileChange(fileapi::FileChange::FILE_CHANGE_DELETE,
-                               fileapi::SYNC_FILE_TYPE_UNKNOWN);
+    return FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_UNKNOWN);
   }
-  return fileapi::FileChange(fileapi::FileChange::FILE_CHANGE_ADD_OR_UPDATE,
-                             fileapi::SYNC_FILE_TYPE_FILE);
+  return FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE, SYNC_FILE_TYPE_FILE);
 }
 
 }  // namespace
 
 const char DriveFileSyncService::kServiceName[] = "drive";
 
 class DriveFileSyncService::TaskToken {
  public:
   explicit TaskToken(const base::WeakPtr<DriveFileSyncService>& sync_service)
       : sync_service_(sync_service),
@@ skipping 119 matching lines @@
   if (left.changestamp != right.changestamp)
     return left.changestamp < right.changestamp;
   if (left.sync_type != right.sync_type)
     return left.sync_type < right.sync_type;
   return fileapi::FileSystemURL::Comparator()(left.url, right.url);
 }
 
 DriveFileSyncService::RemoteChange::RemoteChange()
     : changestamp(0),
       sync_type(REMOTE_SYNC_TYPE_INCREMENTAL),
-      change(fileapi::FileChange::FILE_CHANGE_ADD_OR_UPDATE,
-             fileapi::SYNC_FILE_TYPE_UNKNOWN) {
+      change(FileChange::FILE_CHANGE_ADD_OR_UPDATE, SYNC_FILE_TYPE_UNKNOWN) {
 }
 
 DriveFileSyncService::RemoteChange::RemoteChange(
     int64 changestamp,
     const std::string& resource_id,
     const std::string& md5_checksum,
     RemoteSyncType sync_type,
     const fileapi::FileSystemURL& url,
-    const fileapi::FileChange& change,
+    const FileChange& change,
     PendingChangeQueue::iterator position_in_queue)
     : changestamp(changestamp),
       resource_id(resource_id),
       md5_checksum(md5_checksum),
       sync_type(sync_type),
       url(url),
       change(change),
       position_in_queue(position_in_queue) {
 }
 
@@ skipping 258 matching lines @@
       Observer, service_observers_,
       OnRemoteServiceStateUpdated(GetCurrentState(), status_message));
 
   if (GetCurrentState() == REMOTE_SERVICE_OK) {
     UpdatePollingDelay(kMinimumPollingDelaySeconds);
     SchedulePolling();
   }
 }
 
 void DriveFileSyncService::ApplyLocalChange(
-    const fileapi::FileChange& local_file_change,
+    const FileChange& local_file_change,
     const base::FilePath& local_file_path,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback) {
   // TODO(nhiroki): support directory operations (http://crbug.com/161442).
   DCHECK(!local_file_change.IsDirectory());
 
   scoped_ptr<TaskToken> token(GetToken(
       FROM_HERE, TASK_TYPE_DATABASE, "Apply local change"));
   if (!token) {
     pending_tasks_.push_back(base::Bind(
@@ skipping 533 matching lines @@
     const fileapi::SyncStatusCallback& callback,
     fileapi::SyncStatusCode status) {
   NotifyTaskDone(status, token.Pass());
   callback.Run(status);
 }
 
 void DriveFileSyncService::DidGetRemoteFileMetadata(
     const fileapi::SyncFileMetadataCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceEntry> entry) {
-  fileapi::SyncFileType file_type = fileapi::SYNC_FILE_TYPE_UNKNOWN;
+  SyncFileType file_type = SYNC_FILE_TYPE_UNKNOWN;
   if (entry->is_file())
-    file_type = fileapi::SYNC_FILE_TYPE_FILE;
+    file_type = SYNC_FILE_TYPE_FILE;
   else if (entry->is_folder())
-    file_type = fileapi::SYNC_FILE_TYPE_DIRECTORY;
+    file_type = SYNC_FILE_TYPE_DIRECTORY;
   callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error),
                fileapi::SyncFileMetadata(file_type,
                                          entry->file_size(),
                                          entry->updated_time()));
 }
 
 DriveFileSyncService::LocalSyncOperationType
 DriveFileSyncService::ResolveLocalSyncOperationType(
-    const fileapi::FileChange& local_file_change,
+    const FileChange& local_file_change,
     const fileapi::FileSystemURL& url) {
   DriveMetadata metadata;
   const bool has_metadata =
       (metadata_store_->ReadEntry(url, &metadata) == fileapi::SYNC_STATUS_OK);
 
   if (has_metadata && metadata.conflicted()) {
     // The file has been marked as conflicted.
     if (local_file_change.IsAddOrUpdate())
       return LOCAL_SYNC_OPERATION_NONE;
     else if (local_file_change.IsDelete())
       return LOCAL_SYNC_OPERATION_RESOLVE_TO_REMOTE;
     NOTREACHED();
     return LOCAL_SYNC_OPERATION_FAIL;
   }
 
   RemoteChange remote_change;
   const bool has_remote_change = GetPendingChangeForFileSystemURL(
       url, &remote_change);
 
   if (has_remote_change) {
     // Remote change for the file identified by |url| exists in the pending
     // change queue.
-    const fileapi::FileChange& remote_file_change = remote_change.change;
+    const FileChange& remote_file_change = remote_change.change;
 
     // (RemoteChange) + (LocalChange) -> (Operation Type)
     // AddOrUpdate    + AddOrUpdate   -> CONFLICT
     // AddOrUpdate    + Delete        -> NONE
     // Delete         + AddOrUpdate   -> ADD
     // Delete         + Delete        -> NONE
 
     if (remote_file_change.IsAddOrUpdate() && local_file_change.IsAddOrUpdate())
       return LOCAL_SYNC_OPERATION_CONFLICT;
     else if (remote_file_change.IsDelete() && local_file_change.IsAddOrUpdate())
@@ skipping 186 matching lines @@
       FinalizeLocalSync(token.Pass(), callback, status);
       return;
     }
   }
 }
 
 void DriveFileSyncService::DidPrepareForProcessRemoteChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     fileapi::SyncStatusCode status,
     const fileapi::SyncFileMetadata& metadata,
-    const fileapi::FileChangeList& local_changes) {
+    const FileChangeList& local_changes) {
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
   const fileapi::FileSystemURL& url = param->remote_change.url;
   const DriveMetadata& drive_metadata = param->drive_metadata;
-  const fileapi::FileChange& remote_file_change = param->remote_change.change;
+  const FileChange& remote_file_change = param->remote_change.change;
 
   status = metadata_store_->ReadEntry(param->remote_change.url,
                                       &param->drive_metadata);
   DCHECK(status == fileapi::SYNC_STATUS_OK ||
          status == fileapi::SYNC_DATABASE_ERROR_NOT_FOUND);
 
   bool missing_db_entry = (status != fileapi::SYNC_STATUS_OK);
   if (missing_db_entry) {
     param->drive_metadata.set_resource_id(param->remote_change.resource_id);
     param->drive_metadata.set_md5_checksum(std::string());
     param->drive_metadata.set_conflicted(false);
     param->drive_metadata.set_to_be_fetched(false);
   }
   bool missing_local_file =
-      (metadata.file_type == fileapi::SYNC_FILE_TYPE_UNKNOWN);
+      (metadata.file_type == SYNC_FILE_TYPE_UNKNOWN);
 
   if (param->drive_metadata.conflicted()) {
     if (missing_local_file) {
       if (remote_file_change.IsAddOrUpdate()) {
         // Resolve conflict to remote change automatically.
         DVLOG(1) << "ProcessRemoteChange for " << url.DebugString()
                  << (param->drive_metadata.conflicted() ? " (conflicted)" : " ")
                  << (missing_local_file ? " (missing local file)" : " ")
                  << " remote_change: " << remote_file_change.DebugString()
                  << " ==> operation: ResolveConflictToRemoteChange";
@@ skipping 34 matching lines @@
              << (missing_local_file ? " (missing local file)" : " ")
              << " remote_change: " << remote_file_change.DebugString()
              << " ==> operation: ResolveConflictToLocalChange";
 
     param->sync_action = fileapi::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),
+        FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE, 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;
@@ skipping 35 matching lines @@
       param->sync_action = fileapi::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;
 
-    const fileapi::FileChange& file_change = remote_file_change;
+    const 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;
@@ skipping 71 matching lines @@
     return;
   }
 
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
   param->drive_metadata.set_md5_checksum(md5_checksum);
-  const fileapi::FileChange& change = param->remote_change.change;
+  const FileChange& change = param->remote_change.change;
   const base::FilePath& temporary_file_path = param->temporary_file_path;
   const fileapi::FileSystemURL& url = param->remote_change.url;
   param->processor->ApplyRemoteChange(
       change, temporary_file_path, url,
       base::Bind(&DriveFileSyncService::DidApplyRemoteChange,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidApplyRemoteChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
@@ skipping 180 matching lines @@
       !local_file_md5.empty() &&
       remote_file_md5 == local_file_md5)
     return false;
 
   // Drop any change if the change has unknown resource id.
   if (!remote_resource_id.empty() &&
       !local_resource_id.empty() &&
       remote_resource_id != local_resource_id)
     return false;
 
-  fileapi::FileChange file_change(CreateFileChange(is_deleted));
+  FileChange file_change(CreateFileChange(is_deleted));
 
   // Do not return in this block. These changes should be done together.
   {
     if (overridden_queue_item != pending_changes_.end())
       pending_changes_.erase(overridden_queue_item);
 
     std::pair<PendingChangeQueue::iterator, bool> inserted_to_queue =
         pending_changes_.insert(ChangeQueueItem(changestamp, sync_type, url));
     DCHECK(inserted_to_queue.second);
 
@@ skipping 262 matching lines @@
     DCHECK_EQ(fileapi::SYNC_ACTION_NONE, action_taken);
     DCHECK_EQ(fileapi::SYNC_DIRECTION_NONE, direction);
   }
 
   FOR_EACH_OBSERVER(
       FileStatusObserver, file_status_observers_,
       OnFileStatusChanged(url, sync_status, action_taken, direction));
 }
 
 }  // namespace sync_file_system