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

chrome/browser/chromeos/drive/fileapi/fileapi_worker.cc

 // Copyright 2014 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/chromeos/drive/fileapi/fileapi_worker.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 53 matching lines @@
   ConvertResourceEntryToFileInfo(*entry, &file_info);
   callback.Run(base::File::FILE_OK, file_info);
 }
 
 // Runs |callback| with entries.
 void RunReadDirectoryCallbackWithEntries(
     const ReadDirectoryCallback& callback,
     scoped_ptr<ResourceEntryVector> resource_entries) {
   DCHECK(resource_entries);
 
-  std::vector<fileapi::DirectoryEntry> entries;
+  std::vector<storage::DirectoryEntry> entries;
   // Convert drive files to File API's directory entry.
   entries.reserve(resource_entries->size());
   for (size_t i = 0; i < resource_entries->size(); ++i) {
     const ResourceEntry& resource_entry = (*resource_entries)[i];
-    fileapi::DirectoryEntry entry;
+    storage::DirectoryEntry entry;
     entry.name = resource_entry.base_name();
 
     const PlatformFileInfoProto& file_info = resource_entry.file_info();
     entry.is_directory = file_info.is_directory();
     entry.size = file_info.size();
     entry.last_modified_time =
         base::Time::FromInternalValue(file_info.last_modified());
     entries.push_back(entry);
   }
 
   callback.Run(base::File::FILE_OK, entries, true /*has_more*/);
 }
 
 // Runs |callback| with |error|.
 void RunReadDirectoryCallbackOnCompletion(const ReadDirectoryCallback& callback,
                                           FileError error) {
   callback.Run(FileErrorToBaseFileError(error),
-               std::vector<fileapi::DirectoryEntry>(), false /*has_more*/);
+               std::vector<storage::DirectoryEntry>(),
+               false /*has_more*/);
 }
 
 // Runs |callback| with arguments based on |error|, |local_path| and |entry|.
 void RunCreateSnapshotFileCallback(const CreateSnapshotFileCallback& callback,
                                    FileError error,
                                    const base::FilePath& local_path,
                                    scoped_ptr<ResourceEntry> entry) {
   if (error != FILE_ERROR_OK) {
-    callback.Run(
-        FileErrorToBaseFileError(error),
-        base::File::Info(), base::FilePath(),
-        webkit_blob::ScopedFile::ScopeOutPolicy());
+    callback.Run(FileErrorToBaseFileError(error),
+                 base::File::Info(),
+                 base::FilePath(),
+                 storage::ScopedFile::ScopeOutPolicy());
     return;
   }
 
   DCHECK(entry);
 
   // When reading file, last modified time specified in file info will be
   // compared to the last modified time of the local version of the drive file.
   // Since those two values don't generally match (last modification time on the
   // drive server vs. last modification time of the local, downloaded file), so
   // we have to opt out from this check. We do this by unsetting last_modified
   // value in the file info passed to the CreateSnapshot caller.
   base::File::Info file_info;
   ConvertResourceEntryToFileInfo(*entry, &file_info);
   file_info.last_modified = base::Time();
 
   // If the file is a hosted document, a temporary JSON file is created to
   // represent the document. The JSON file is not cached and its lifetime
   // is managed by ShareableFileReference.
-  webkit_blob::ScopedFile::ScopeOutPolicy scope_out_policy =
-      entry->file_specific_info().is_hosted_document() ?
-      webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT :
-      webkit_blob::ScopedFile::DONT_DELETE_ON_SCOPE_OUT;
+  storage::ScopedFile::ScopeOutPolicy scope_out_policy =
+      entry->file_specific_info().is_hosted_document()
+          ? storage::ScopedFile::DELETE_ON_SCOPE_OUT
+          : storage::ScopedFile::DONT_DELETE_ON_SCOPE_OUT;
 
   callback.Run(base::File::FILE_OK, file_info, local_path, scope_out_policy);
 }
 
 // Runs |callback| with arguments converted from |error| and |local_path|.
 void RunCreateWritableSnapshotFileCallback(
     const CreateWritableSnapshotFileCallback& callback,
     FileError error,
     const base::FilePath& local_path,
     const base::Closure& close_callback) {
@@ skipping 43 matching lines @@
   // Cache file prepared for modification is available. Open it locally.
   bool posted = base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
       base::Bind(&OpenFile, local_path, file_flags),
       base::Bind(&RunOpenFileCallback, callback, close_callback));
   DCHECK(posted);
 }
 
 }  // namespace
 
-FileSystemInterface* GetFileSystemFromUrl(const fileapi::FileSystemURL& url) {
+FileSystemInterface* GetFileSystemFromUrl(const storage::FileSystemURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Profile* profile = util::ExtractProfileFromPath(url.path());
   return profile ? util::GetFileSystemByProfile(profile) : NULL;
 }
 
 void RunFileSystemCallback(
     const FileSystemGetter& file_system_getter,
     const base::Callback<void(FileSystemInterface*)>& callback,
     const base::Closure& on_error_callback) {
@@ skipping 153 matching lines @@
                const StatusCallback& callback,
                FileSystemInterface* file_system) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   file_system->TouchFile(file_path, last_access_time, last_modified_time,
                          base::Bind(&RunStatusCallbackByFileError, callback));
 
 }
 
 }  // namespace fileapi_internal
 }  // namespace drive