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

chrome/browser/sync_file_system/sync_file_system_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/sync_file_system_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 180 matching lines @@
     const fileapi::SyncFileStatusCallback& callback) {
   DCHECK(local_file_service_);
   DCHECK(remote_file_service_);
 
   // It's possible to get an invalid FileEntry.
   if (!url.is_valid()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    fileapi::SYNC_FILE_ERROR_INVALID_URL,
-                   fileapi::SYNC_FILE_STATUS_UNKNOWN));
+                   SYNC_FILE_STATUS_UNKNOWN));
     return;
   }
 
   if (remote_file_service_->IsConflicting(url)) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    fileapi::SYNC_STATUS_OK,
-                   fileapi::SYNC_FILE_STATUS_CONFLICTING));
+                   SYNC_FILE_STATUS_CONFLICTING));
     return;
   }
 
   local_file_service_->HasPendingLocalChanges(
       url,
       base::Bind(&SyncFileSystemService::DidGetLocalChangeStatus,
                  AsWeakPtr(), callback));
 }
 
 void SyncFileSystemService::AddSyncEventObserver(SyncEventObserver* observer) {
@@ skipping 197 matching lines @@
       FROM_HERE, base::Bind(&SyncFileSystemService::MaybeStartSync,
                             AsWeakPtr()));
 }
 
 void SyncFileSystemService::DidGetLocalChangeStatus(
     const fileapi::SyncFileStatusCallback& callback,
     fileapi::SyncStatusCode status,
     bool has_pending_local_changes) {
   callback.Run(
       status,
-      has_pending_local_changes ? fileapi::SYNC_FILE_STATUS_HAS_PENDING_CHANGES
-                                : fileapi::SYNC_FILE_STATUS_SYNCED);
+      has_pending_local_changes ?
+          SYNC_FILE_STATUS_HAS_PENDING_CHANGES : SYNC_FILE_STATUS_SYNCED);
 }
 
 void SyncFileSystemService::OnSyncEnabledForRemoteSync() {
   is_waiting_remote_sync_enabled_ = false;
   MaybeStartRemoteSync();
 }
 
 void SyncFileSystemService::OnLocalChangeAvailable(int64 pending_changes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_GE(pending_changes, 0);
@@ skipping 67 matching lines @@
 
 void SyncFileSystemService::OnStateChanged() {
   ProfileSyncServiceBase* profile_sync_service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (profile_sync_service)
     UpdateSyncEnabledStatus(profile_sync_service);
 }
 
 void SyncFileSystemService::OnFileStatusChanged(
     const FileSystemURL& url,
-    fileapi::SyncFileStatus sync_status,
-    fileapi::SyncAction action_taken,
-    fileapi::SyncDirection direction) {
+    SyncFileStatus sync_status,
+    SyncAction action_taken,
+    SyncDirection direction) {
   FOR_EACH_OBSERVER(
       SyncEventObserver, observers_,
       OnFileSynced(url, sync_status, action_taken, direction));
 }
 
 void SyncFileSystemService::UpdateSyncEnabledStatus(
     ProfileSyncServiceBase* profile_sync_service) {
   if (!profile_sync_service->HasSyncSetupCompleted())
     return;
   sync_enabled_ = profile_sync_service->GetPreferredDataTypes().Has(
@@ skipping 45 matching lines @@
     remote_file_service = mock_remote_file_service_.Pass();
   else
     remote_file_service.reset(new DriveFileSyncService(profile));
 
   service->Initialize(local_file_service.Pass(),
                       remote_file_service.Pass());
   return service;
 }
 
 }  // namespace sync_file_system