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

chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_service.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_v1/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 20 matching lines @@
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
 #include "chrome/browser/sync_file_system/sync_file_type.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
-#include "webkit/browser/fileapi/file_system_url.h"
-#include "webkit/common/blob/scoped_file.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/browser/fileapi/file_system_url.h"
+#include "storage/common/blob/scoped_file.h"
+#include "storage/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemURL;
+using storage::FileSystemURL;
 
 namespace sync_file_system {
 
 typedef RemoteFileSyncService::OriginStatusMap OriginStatusMap;
 
 namespace {
 
 const base::FilePath::CharType kTempDirName[] = FILE_PATH_LITERAL("tmp");
 
 void EmptyStatusCallback(SyncStatusCode status) {}
@@ skipping 737 matching lines @@
     metadata.set_md5_checksum(std::string());
     metadata.set_conflicted(false);
     metadata.set_to_be_fetched(true);
 
     if (file_type == SYNC_FILE_TYPE_FILE)
       metadata.set_type(DriveMetadata::RESOURCE_TYPE_FILE);
     else
       metadata.set_type(DriveMetadata::RESOURCE_TYPE_FOLDER);
 
     base::FilePath path = TitleToPath(entry.title());
-    fileapi::FileSystemURL url(CreateSyncableFileSystemURL(
-        origin, path));
+    storage::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
     // TODO(calvinlo): Write metadata and origin data as single batch command
     // so it's not possible for the DB to contain a DriveMetadata with an
     // unknown origin.
     metadata_store_->UpdateEntry(url, metadata,
                                  base::Bind(&EmptyStatusCallback));
 
     AppendFetchChange(origin, path, entry.resource_id(), file_type);
   }
 
   GURL next_feed_url;
@@ skipping 11 matching lines @@
 
   metadata_store_->AddIncrementalSyncOrigin(origin, resource_id);
   may_have_unfetched_changes_ = true;
   callback.Run(SYNC_STATUS_OK);
 }
 
 void DriveFileSyncService::DidProcessRemoteChange(
     const SyncFileCallback& sync_callback,
     const SyncStatusCallback& completion_callback,
     SyncStatusCode status) {
-  fileapi::FileSystemURL url;
+  storage::FileSystemURL url;
   if (running_remote_sync_task_)
     url = running_remote_sync_task_->url();
   running_remote_sync_task_.reset();
 
   completion_callback.Run(status);
   sync_callback.Run(status, url);
 }
 
 void DriveFileSyncService::DidApplyLocalChange(
     const SyncStatusCallback& callback,
@@ skipping 41 matching lines @@
 
 bool DriveFileSyncService::AppendRemoteChangeInternal(
     const GURL& origin,
     const base::FilePath& path,
     bool is_deleted,
     const std::string& remote_resource_id,
     int64 changestamp,
     const std::string& remote_file_md5,
     const base::Time& updated_time,
     SyncFileType file_type) {
-  fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
+  storage::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
   DCHECK(url.is_valid());
 
   // Note that we create a normalized path from url.path() rather than
   // path here (as FileSystemURL does extra normalization).
   base::FilePath::StringType normalized_path =
-    fileapi::VirtualPath::GetNormalizedFilePath(url.path());
+      storage::VirtualPath::GetNormalizedFilePath(url.path());
 
   std::string local_resource_id;
   std::string local_file_md5;
 
   DriveMetadata metadata;
   bool has_db_entry =
       (metadata_store_->ReadEntry(url, &metadata) == SYNC_STATUS_OK);
   if (has_db_entry) {
     local_resource_id = metadata.resource_id();
     if (!metadata.to_be_fetched())
@@ skipping 71 matching lines @@
            << file_change.DebugString();
 
   return true;
 }
 
 void DriveFileSyncService::RemoveRemoteChange(
     const FileSystemURL& url) {
   remote_change_handler_.RemoveChangeForURL(url);
 }
 
-void DriveFileSyncService::MarkConflict(
-    const fileapi::FileSystemURL& url,
-    DriveMetadata* drive_metadata,
-    const SyncStatusCallback& callback) {
+void DriveFileSyncService::MarkConflict(const storage::FileSystemURL& url,
+                                        DriveMetadata* drive_metadata,
+                                        const SyncStatusCallback& callback) {
   DCHECK(drive_metadata);
   DCHECK(!drive_metadata->resource_id().empty());
   drive_metadata->set_conflicted(true);
   drive_metadata->set_to_be_fetched(false);
   metadata_store_->UpdateEntry(
       url, *drive_metadata, base::Bind(
           &DriveFileSyncService::NotifyConflict,
           AsWeakPtr(), url, callback));
 }
 
-void DriveFileSyncService::NotifyConflict(
-    const fileapi::FileSystemURL& url,
-    const SyncStatusCallback& callback,
-    SyncStatusCode status) {
+void DriveFileSyncService::NotifyConflict(const storage::FileSystemURL& url,
+                                          const SyncStatusCallback& callback,
+                                          SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
   NotifyObserversFileStatusChanged(url,
                                    SYNC_FILE_STATUS_CONFLICTING,
                                    SYNC_ACTION_NONE,
                                    SYNC_DIRECTION_NONE);
   callback.Run(status);
 }
@@ skipping 305 matching lines @@
     metadata_store_->SetOriginRootDirectory(origin, resource_id);
   }
   callback.Run(status, resource_id);
 }
 
 std::string DriveFileSyncService::sync_root_resource_id() {
   return metadata_store_->sync_root_directory();
 }
 
 }  // namespace sync_file_system