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

chrome/browser/sync_file_system/drive_backend/sync_engine.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/sync_engine.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 36 matching lines @@
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.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/extension.h"
 #include "google_apis/drive/drive_api_url_generator.h"
 #include "google_apis/drive/gdata_wapi_url_generator.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "webkit/common/blob/scoped_file.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/common/blob/scoped_file.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 namespace sync_file_system {
 
 class RemoteChangeProcessor;
 
 namespace drive_backend {
 
 scoped_ptr<drive::DriveServiceInterface>
 SyncEngine::DriveServiceFactory::CreateDriveService(
     OAuth2TokenService* oauth2_token_service,
@@ skipping 32 matching lines @@
     }
 
     DCHECK(sequence_checker_.CalledOnValidSequencedThread());
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SyncEngine::OnPendingFileListUpdated,
                    sync_engine_,
                    item_count));
   }
 
-  virtual void OnFileStatusChanged(const fileapi::FileSystemURL& url,
+  virtual void OnFileStatusChanged(const storage::FileSystemURL& url,
                                    SyncFileStatus file_status,
                                    SyncAction sync_action,
                                    SyncDirection direction) OVERRIDE {
     if (ui_task_runner_->RunsTasksOnCurrentThread()) {
       if (sync_engine_)
         sync_engine_->OnFileStatusChanged(
             url, file_status, sync_action, direction);
       return;
     }
 
@@ skipping 330 matching lines @@
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::UninstallOrigin,
                  base::Unretained(sync_worker_.get()),
                  origin, flag, relayed_callback));
 }
 
 void SyncEngine::ProcessRemoteChange(const SyncFileCallback& callback) {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED) {
-    callback.Run(SYNC_STATUS_SYNC_DISABLED, fileapi::FileSystemURL());
+    callback.Run(SYNC_STATUS_SYNC_DISABLED, storage::FileSystemURL());
     return;
   }
 
   base::Closure abort_closure =
-      base::Bind(callback, SYNC_STATUS_ABORT, fileapi::FileSystemURL());
+      base::Bind(callback, SYNC_STATUS_ABORT, storage::FileSystemURL());
 
   if (!sync_worker_) {
     abort_closure.Run();
     return;
   }
 
   SyncFileCallback tracked_callback = callback_tracker_.Register(
       abort_closure, callback);
   SyncFileCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, tracked_callback);
@@ skipping 121 matching lines @@
   base::Closure relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, callback_tracker_.Register(callback, callback));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorkerInterface::PromoteDemotedChanges,
                  base::Unretained(sync_worker_.get()),
                  relayed_callback));
 }
 
-void SyncEngine::ApplyLocalChange(
-    const FileChange& local_change,
-    const base::FilePath& local_path,
-    const SyncFileMetadata& local_metadata,
-    const fileapi::FileSystemURL& url,
-    const SyncStatusCallback& callback) {
+void SyncEngine::ApplyLocalChange(const FileChange& local_change,
+                                  const base::FilePath& local_path,
+                                  const SyncFileMetadata& local_metadata,
+                                  const storage::FileSystemURL& url,
+                                  const SyncStatusCallback& callback) {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED) {
     callback.Run(SYNC_STATUS_SYNC_DISABLED);
     return;
   }
 
   if (!sync_worker_) {
     callback.Run(SYNC_STATUS_ABORT);
     return;
   }
 
@@ skipping 130 matching lines @@
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 void SyncEngine::OnPendingFileListUpdated(int item_count) {
   FOR_EACH_OBSERVER(
       SyncServiceObserver,
       service_observers_,
       OnRemoteChangeQueueUpdated(item_count));
 }
 
-void SyncEngine::OnFileStatusChanged(const fileapi::FileSystemURL& url,
+void SyncEngine::OnFileStatusChanged(const storage::FileSystemURL& url,
                                      SyncFileStatus file_status,
                                      SyncAction sync_action,
                                      SyncDirection direction) {
   FOR_EACH_OBSERVER(FileStatusObserver,
                     file_status_observers_,
                     OnFileStatusChanged(
                         url, file_status, sync_action, direction));
 }
 
 void SyncEngine::UpdateServiceState(RemoteServiceState state,
                                     const std::string& description) {
   service_state_ = state;
 
   FOR_EACH_OBSERVER(
       SyncServiceObserver, service_observers_,
       OnRemoteServiceStateUpdated(GetCurrentState(), description));
 }
 
 SyncStatusCallback SyncEngine::TrackCallback(
     const SyncStatusCallback& callback) {
   return callback_tracker_.Register(
       base::Bind(callback, SYNC_STATUS_ABORT),
       callback);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system