Move storage-related files from webkit/ to new top-level directory storage/

chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.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/drive_backend/local_to_remote_syncer.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/folder_creator.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "net/base/mime_util.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 scoped_ptr<FileTracker> FindTrackerByID(MetadataDatabase* metadata_database,
                                         int64 tracker_id) {
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (metadata_database->FindTrackerByTrackerID(tracker_id, tracker.get()))
@@ skipping 25 matching lines @@
     return kMimeTypeOctetStream;
   return mime_type;
 }
 
 }  // namespace
 
 LocalToRemoteSyncer::LocalToRemoteSyncer(SyncEngineContext* sync_context,
                                          const SyncFileMetadata& local_metadata,
                                          const FileChange& local_change,
                                          const base::FilePath& local_path,
-                                         const fileapi::FileSystemURL& url)
+                                         const storage::FileSystemURL& url)
     : sync_context_(sync_context),
       local_change_(local_change),
       local_is_missing_(IsLocalFileMissing(local_metadata, local_change)),
       local_path_(local_path),
       url_(url),
       sync_action_(SYNC_ACTION_NONE),
       remote_file_change_id_(0),
       retry_on_success_(false),
       needs_remote_change_listing_(false),
       weak_ptr_factory_(this) {
@@ skipping 60 matching lines @@
       NOTREACHED();
       token->RecordLog(base::StringPrintf(
           "Detected invalid ancestor: %s",
           active_ancestor_path.value().c_str()));
       SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
       return;
     }
   }
 
   std::vector<base::FilePath::StringType> missing_components;
-  fileapi::VirtualPath::GetComponents(missing_entries, &missing_components);
+  storage::VirtualPath::GetComponents(missing_entries, &missing_components);
 
   if (!missing_components.empty()) {
     if (local_is_missing_) {
       token->RecordLog("Both local and remote are marked missing");
       // !IsDelete() but SYNC_FILE_TYPE_UNKNOWN could happen when a file is
       // deleted by recursive deletion (which is not recorded by tracker)
       // but there're remaining changes for the same file in the tracker.
 
       // Local file is deleted and remote file is missing, already deleted or
       // not yet synced.  There is nothing to do for the file.
@@ skipping 187 matching lines @@
   if (!metadata_database()->FindFileByFileID(
           remote_file_tracker_->file_id(), &remote_file_metadata)) {
     NOTREACHED();
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                                 weak_ptr_factory_.GetWeakPtr()),
                      token.Pass());
     return;
   }
 
   const FileDetails& remote_details = remote_file_metadata.details();
-  base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
+  base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   if (!remote_details.missing() &&
       remote_details.file_kind() == FILE_KIND_FOLDER &&
       remote_details.title() == title.AsUTF8Unsafe() &&
       HasFileAsParent(remote_details,
                       remote_parent_folder_tracker_->file_id())) {
 
     MoveToBackground(
         base::Bind(&LocalToRemoteSyncer::UpdateTrackerForReusedFolder,
                    weak_ptr_factory_.GetWeakPtr(),
                    remote_details),
@@ skipping 190 matching lines @@
 
   FileMetadata file;
   if (!metadata_database()->FindFileByFileID(
           remote_file_tracker_->file_id(), &file)) {
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   const FileDetails& details = file.details();
-  base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
+  base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   if (!details.missing() &&
       details.file_kind() == FILE_KIND_FILE &&
       details.title() == title.AsUTF8Unsafe() &&
       HasFileAsParent(details,
                       remote_parent_folder_tracker_->file_id())) {
     metadata_database()->UpdateTracker(
         remote_file_tracker_->tracker_id(),
         file.details(),
         base::Bind(&LocalToRemoteSyncer::SyncCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
@@ skipping 50 matching lines @@
       *entry,
       base::Bind(&LocalToRemoteSyncer::SyncCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::UploadNewFile(scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   sync_action_ = SYNC_ACTION_ADDED;
-  base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
+  base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   drive_uploader()->UploadNewFile(
       remote_parent_folder_tracker_->file_id(),
       local_path_,
       title.AsUTF8Unsafe(),
       GetMimeTypeFromTitle(title),
       drive::DriveUploader::UploadNewFileOptions(),
       base::Bind(&LocalToRemoteSyncer::DidUploadNewFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)),
       google_apis::ProgressCallback());
@@ skipping 23 matching lines @@
       remote_parent_folder_tracker_->tracker_id(), *entry,
       base::Bind(&LocalToRemoteSyncer::SyncCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::CreateRemoteFolder(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
-  base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
+  base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   sync_action_ = SYNC_ACTION_ADDED;
 
   DCHECK(!folder_creator_);
   folder_creator_.reset(new FolderCreator(
       drive_service(), metadata_database(),
       remote_parent_folder_tracker_->file_id(),
       title.AsUTF8Unsafe()));
   folder_creator_->Run(base::Bind(
       &LocalToRemoteSyncer::DidCreateRemoteFolder,
       weak_ptr_factory_.GetWeakPtr(),
@@ skipping 68 matching lines @@
   set_used_network(true);
   return sync_context_->GetDriveUploader();
 }
 
 MetadataDatabase* LocalToRemoteSyncer::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system