Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

chrome/browser/sync_file_system/local/local_file_sync_context.cc

 // Copyright 2013 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/local/local_file_sync_context.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/sync_file_system/file_change.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/local_origin_change_observer.h"
 #include "chrome/browser/sync_file_system/local/root_delete_helper.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/local/syncable_file_operation_runner.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/common/blob/scoped_file.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemContext;
-using fileapi::FileSystemFileUtil;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemFileUtil;
+using storage::FileSystemOperation;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
 
 namespace sync_file_system {
 
 namespace {
 
 const int kMaxConcurrentSyncableOperation = 3;
 const int kNotifyChangesDurationInSec = 1;
 const int kMaxURLsToFetchForLocalSync = 5;
 
 const base::FilePath::CharType kSnapshotDir[] = FILE_PATH_LITERAL("snapshots");
@@ skipping 31 matching lines @@
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   callback_queue.push_back(callback);
   if (callback_queue.size() > 1)
     return;
 
   // The sync service always expects the origin (app) is initialized
   // for writable way (even when MaybeInitializeFileSystemContext is called
   // from read-only OpenFileSystem), so open the filesystem with
   // CREATE_IF_NONEXISTENT here.
-  fileapi::FileSystemBackend::OpenFileSystemCallback open_filesystem_callback =
+  storage::FileSystemBackend::OpenFileSystemCallback open_filesystem_callback =
       base::Bind(&LocalFileSyncContext::InitializeFileSystemContextOnIOThread,
-                 this, source_url, make_scoped_refptr(file_system_context));
+                 this,
+                 source_url,
+                 make_scoped_refptr(file_system_context));
   io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&fileapi::SandboxFileSystemBackendDelegate::OpenFileSystem,
+      base::Bind(&storage::SandboxFileSystemBackendDelegate::OpenFileSystem,
                  base::Unretained(file_system_context->sandbox_delegate()),
-                 source_url, fileapi::kFileSystemTypeSyncable,
-                 fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
-                 open_filesystem_callback, GURL()));
+                 source_url,
+                 storage::kFileSystemTypeSyncable,
+                 storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                 open_filesystem_callback,
+                 GURL()));
 }
 
 void LocalFileSyncContext::ShutdownOnUIThread() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   shutdown_on_ui_ = true;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::ShutdownOnIOThread, this));
 }
 
@@ skipping 33 matching lines @@
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->ClearChangesForURL(url);
 
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::FinalizeSnapshotSync(
-    fileapi::FileSystemContext* file_system_context,
-    const fileapi::FileSystemURL& url,
+    storage::FileSystemContext* file_system_context,
+    const storage::FileSystemURL& url,
     SyncStatusCode sync_finish_status,
     const base::Closure& done_callback) {
   DCHECK(file_system_context);
   DCHECK(url.is_valid());
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::FinalizeSnapshotSync,
                    this, make_scoped_refptr(file_system_context),
@@ skipping 19 matching lines @@
   // to unblock sync activities.
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(
           &LocalFileSyncContext::FinalizeSnapshotSyncOnIOThread, this, url));
 
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::FinalizeExclusiveSync(
-    fileapi::FileSystemContext* file_system_context,
-    const fileapi::FileSystemURL& url,
+    storage::FileSystemContext* file_system_context,
+    const storage::FileSystemURL& url,
     bool clear_local_changes,
     const base::Closure& done_callback) {
   DCHECK(file_system_context);
   if (!url.is_valid()) {
     done_callback.Run();
     return;
   }
 
   if (clear_local_changes) {
     ClearChangesForURL(file_system_context, url,
@@ skipping 98 matching lines @@
 }
 
 void LocalFileSyncContext::HandleRemoteDelete(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
 
   // Handle root directory case differently.
-  if (fileapi::VirtualPath::IsRootPath(url.path())) {
+  if (storage::VirtualPath::IsRootPath(url.path())) {
     DCHECK(!root_delete_helper_);
     root_delete_helper_.reset(new RootDeleteHelper(
         file_system_context, sync_status(), url,
         base::Bind(&LocalFileSyncContext::DidApplyRemoteChange,
                    this, url, callback)));
     root_delete_helper_->Run();
     return;
   }
 
   file_system_context->operation_runner()->Remove(
       url_for_sync, true /* recursive */,
       base::Bind(&LocalFileSyncContext::DidApplyRemoteChange,
                  this, url, callback));
 }
 
 void LocalFileSyncContext::HandleRemoteAddOrUpdate(
     FileSystemContext* file_system_context,
     const FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
 
-  if (fileapi::VirtualPath::IsRootPath(url.path())) {
+  if (storage::VirtualPath::IsRootPath(url.path())) {
     DidApplyRemoteChange(url, callback, base::File::FILE_OK);
     return;
   }
 
   file_system_context->operation_runner()->Remove(
       url_for_sync, true /* recursive */,
       base::Bind(
           &LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate,
           this,
           make_scoped_refptr(file_system_context),
@@ skipping 24 matching lines @@
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
   FileSystemOperation::StatusCallback operation_callback = base::Bind(
       &LocalFileSyncContext::DidApplyRemoteChange, this, url, callback);
 
   DCHECK_EQ(FileChange::FILE_CHANGE_ADD_OR_UPDATE, change.change());
   switch (change.file_type()) {
     case SYNC_FILE_TYPE_FILE: {
       DCHECK(!local_path.empty());
-      base::FilePath dir_path = fileapi::VirtualPath::DirName(url.path());
+      base::FilePath dir_path = storage::VirtualPath::DirName(url.path());
       if (dir_path.empty() ||
-          fileapi::VirtualPath::DirName(dir_path) == dir_path) {
+          storage::VirtualPath::DirName(dir_path) == dir_path) {
         // Copying into the root directory.
         file_system_context->operation_runner()->CopyInForeignFile(
             local_path, url_for_sync, operation_callback);
       } else {
         FileSystemURL dir_url = file_system_context->CreateCrackedFileSystemURL(
             url_for_sync.origin(),
             url_for_sync.mount_type(),
-            fileapi::VirtualPath::DirName(url_for_sync.virtual_path()));
+            storage::VirtualPath::DirName(url_for_sync.virtual_path()));
         file_system_context->operation_runner()->CreateDirectory(
             dir_url,
             false /* exclusive */,
             true /* recursive */,
             base::Bind(&LocalFileSyncContext::DidCreateDirectoryForCopyIn,
                        this,
                        make_scoped_refptr(file_system_context),
                        local_path,
                        url,
                        operation_callback));
@@ skipping 89 matching lines @@
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback,
                                        SYNC_STATUS_OK,
                                        !changes.empty()));
 }
 
 void LocalFileSyncContext::PromoteDemotedChanges(
     const GURL& origin,
-    fileapi::FileSystemContext* file_system_context,
+    storage::FileSystemContext* file_system_context,
     const base::Closure& callback) {
   // This is initially called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::PromoteDemotedChanges,
                    this, origin, make_scoped_refptr(file_system_context),
@@ skipping 281 matching lines @@
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     const LocalFileSyncInfoCallback& callback,
     scoped_ptr<FileSystemURLQueue> urls) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(urls);
 
   if (shutdown_on_ui_) {
-    callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(),
-                 webkit_blob::ScopedFile());
+    callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(), storage::ScopedFile());
     return;
   }
 
   if (urls->empty()) {
-    callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC, LocalFileSyncInfo(),
-                 webkit_blob::ScopedFile());
+    callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC,
+                 LocalFileSyncInfo(),
+                 storage::ScopedFile());
     return;
   }
 
   const FileSystemURL url = urls->front();
   urls->pop_front();
 
   PrepareForSync(
       file_system_context, url, SYNC_SNAPSHOT,
       base::Bind(&LocalFileSyncContext::DidTryPrepareForLocalSync,
                  this, make_scoped_refptr(file_system_context),
                  base::Passed(&urls), callback));
 }
 
 void LocalFileSyncContext::DidTryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemURLQueue> remaining_urls,
     const LocalFileSyncInfoCallback& callback,
     SyncStatusCode status,
     const LocalFileSyncInfo& sync_file_info,
-    webkit_blob::ScopedFile snapshot) {
+    storage::ScopedFile snapshot) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (status != SYNC_STATUS_FILE_BUSY) {
     PromoteDemotedChangesForURLs(file_system_context,
                                  remaining_urls.Pass());
     callback.Run(status, sync_file_info, snapshot.Pass());
     return;
   }
 
   PromoteDemotedChangesForURL(file_system_context, sync_file_info.url);
 
@@ skipping 51 matching lines @@
     SyncStatusCode status,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_) {
-      callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(),
-                   webkit_blob::ScopedFile());
+      callback.Run(
+          SYNC_STATUS_ABORT, LocalFileSyncInfo(), storage::ScopedFile());
       return;
     }
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
                    this, make_scoped_refptr(file_system_context),
                    status, url, sync_mode, callback));
     return;
   }
 
@@ skipping 10 matching lines @@
       file_system_context->sandbox_delegate()->sync_file_util();
   DCHECK(file_util);
 
   base::File::Error file_error = file_util->GetFileInfo(
       make_scoped_ptr(
           new FileSystemOperationContext(file_system_context)).get(),
       url,
       &file_info,
       &platform_path);
 
-  webkit_blob::ScopedFile snapshot;
+  storage::ScopedFile snapshot;
   if (file_error == base::File::FILE_OK && sync_mode == SYNC_SNAPSHOT) {
     base::FilePath snapshot_path;
     base::CreateTemporaryFileInDir(local_base_path_.Append(kSnapshotDir),
                                    &snapshot_path);
     if (base::CopyFile(platform_path, snapshot_path)) {
       platform_path = snapshot_path;
-      snapshot = webkit_blob::ScopedFile(
-          snapshot_path,
-          webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
-          file_system_context->default_file_task_runner());
+      snapshot =
+          storage::ScopedFile(snapshot_path,
+                              storage::ScopedFile::DELETE_ON_SCOPE_OUT,
+                              file_system_context->default_file_task_runner());
     }
   }
 
   if (status == SYNC_STATUS_OK &&
       file_error != base::File::FILE_OK &&
       file_error != base::File::FILE_ERROR_NOT_FOUND) {
     status = FileErrorToSyncStatusCode(file_error);
 }
 
   DCHECK(!file_info.is_symbolic_link);
@@ skipping 108 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system