Migrated sync_file_type and file_change from namespace fileapi to sync_file_system.

webkit/fileapi/syncable/local_file_sync_context.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 "webkit/fileapi/syncable/local_file_sync_context.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/platform_file.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/syncable/file_change.h"
 #include "webkit/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/local_origin_change_observer.h"
 #include "webkit/fileapi/syncable/sync_file_metadata.h"
 #include "webkit/fileapi/syncable/syncable_file_operation_runner.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
+using sync_file_system::FileChangeList;
+using sync_file_system::SyncFileType;
+
 namespace fileapi {
 
 namespace {
 const int kMaxConcurrentSyncableOperation = 3;
 const int kNotifyChangesDurationInSec = 1;
 const int kMaxURLsToFetchForLocalSync = 5;
 }  // namespace
 
 LocalFileSyncContext::LocalFileSyncContext(
     base::SingleThreadTaskRunner* ui_task_runner,
@@ skipping 131 matching lines @@
     // No need to register; fire the callback now.
     ui_task_runner_->PostTask(FROM_HERE, on_syncable_callback);
     return;
   }
   url_waiting_sync_on_io_ = url;
   url_syncable_callback_ = on_syncable_callback;
 }
 
 void LocalFileSyncContext::ApplyRemoteChange(
     FileSystemContext* file_system_context,
-    const FileChange& change,
+    const sync_file_system::FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::ApplyRemoteChange, this,
                    make_scoped_refptr(file_system_context),
                    change, local_path, url, callback));
     return;
   }
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!sync_status()->IsWritable(url));
   DCHECK(!sync_status()->IsWriting(url));
   LocalFileSystemOperation* operation = CreateFileSystemOperationForSync(
       file_system_context);
   DCHECK(operation);
   FileSystemOperation::StatusCallback operation_callback =
       base::Bind(&LocalFileSyncContext::DidApplyRemoteChange,
                  this, url, callback);
   switch (change.change()) {
-    case FileChange::FILE_CHANGE_ADD_OR_UPDATE:
+    case sync_file_system::FileChange::FILE_CHANGE_ADD_OR_UPDATE:
       switch (change.file_type()) {
-        case SYNC_FILE_TYPE_FILE:
+        case sync_file_system::SYNC_FILE_TYPE_FILE:
           DCHECK(!local_path.empty());
           operation->CopyInForeignFile(local_path, url, operation_callback);
           break;
-        case SYNC_FILE_TYPE_DIRECTORY:
+        case sync_file_system::SYNC_FILE_TYPE_DIRECTORY:
           operation->CreateDirectory(
               url, false /* exclusive */, true /* recursive */,
               operation_callback);
           break;
-        case SYNC_FILE_TYPE_UNKNOWN:
+        case sync_file_system::SYNC_FILE_TYPE_UNKNOWN:
           NOTREACHED() << "File type unknown for ADD_OR_UPDATE change";
       }
       break;
-    case FileChange::FILE_CHANGE_DELETE:
+    case sync_file_system::FileChange::FILE_CHANGE_DELETE:
       operation->Remove(url, true /* recursive */, operation_callback);
       break;
   }
 }
 
 void LocalFileSyncContext::RecordFakeLocalChange(
     FileSystemContext* file_system_context,
     const fileapi::FileSystemURL& url,
-    const fileapi::FileChange& change,
+    const sync_file_system::FileChange& change,
     const fileapi::SyncStatusCallback& callback) {
   // This is called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->task_runners()->file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->task_runners()->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::RecordFakeLocalChange,
                    this, make_scoped_refptr(file_system_context),
@@ skipping 343 matching lines @@
       url,
       &file_info,
       &platform_path);
   if (status == SYNC_STATUS_OK &&
       file_error != base::PLATFORM_FILE_OK &&
       file_error != base::PLATFORM_FILE_ERROR_NOT_FOUND)
     status = PlatformFileErrorToSyncStatusCode(file_error);
 
   DCHECK(!file_info.is_symbolic_link);
 
-  SyncFileType file_type = SYNC_FILE_TYPE_FILE;
+  SyncFileType file_type = sync_file_system::SYNC_FILE_TYPE_FILE;
   if (file_error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
-    file_type = SYNC_FILE_TYPE_UNKNOWN;
+    file_type = sync_file_system::SYNC_FILE_TYPE_UNKNOWN;
   else if (file_info.is_directory)
-    file_type = SYNC_FILE_TYPE_DIRECTORY;
+    file_type = sync_file_system::SYNC_FILE_TYPE_DIRECTORY;
 
   LocalFileSyncInfo sync_file_info;
   sync_file_info.url = url;
   sync_file_info.local_file_path = platform_path;
   sync_file_info.metadata.file_type = file_type;
   sync_file_info.metadata.size = file_info.size;
   sync_file_info.metadata.last_modified = file_info.last_modified;
   sync_file_info.changes = changes;
 
   ui_task_runner_->PostTask(FROM_HERE,
@@ skipping 22 matching lines @@
 }
 
 void LocalFileSyncContext::DidGetFileMetadata(
     const SyncFileMetadataCallback& callback,
     base::PlatformFileError file_error,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   SyncFileMetadata metadata;
   if (file_error == base::PLATFORM_FILE_OK) {
-    metadata.file_type = file_info.is_directory ? SYNC_FILE_TYPE_DIRECTORY
-                                                : SYNC_FILE_TYPE_FILE;
+    metadata.file_type = file_info.is_directory ?
+        sync_file_system::SYNC_FILE_TYPE_DIRECTORY :
+        sync_file_system::SYNC_FILE_TYPE_FILE;
     metadata.size = file_info.size;
     metadata.last_modified = file_info.last_modified;
   }
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  PlatformFileErrorToSyncStatusCode(file_error),
                  metadata));
 }
 
 base::TimeDelta LocalFileSyncContext::NotifyChangesDuration() {
   if (mock_notify_changes_duration_in_sec_ >= 0)
     return base::TimeDelta::FromSeconds(mock_notify_changes_duration_in_sec_);
   return base::TimeDelta::FromSeconds(kNotifyChangesDurationInSec);
 }
 
 }  // namespace fileapi