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

chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.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 <algorithm>
 #include <stack>
 
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/common/extension.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
-#include "webkit/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_context.h"
 
 #define FPL(a) FILE_PATH_LITERAL(a)
 
 namespace sync_file_system {
 namespace drive_backend {
 
-typedef fileapi::FileSystemOperation::FileEntryList FileEntryList;
+typedef storage::FileSystemOperation::FileEntryList FileEntryList;
 
 namespace {
 
 template <typename T>
 void SetValueAndCallClosure(const base::Closure& closure,
                             T* arg_out,
                             T arg) {
   *arg_out = base::internal::CallbackForward(arg);
   closure.Run();
 }
 
 void SetSyncStatusAndUrl(const base::Closure& closure,
                          SyncStatusCode* status_out,
-                         fileapi::FileSystemURL* url_out,
+                         storage::FileSystemURL* url_out,
                          SyncStatusCode status,
-                         const fileapi::FileSystemURL& url) {
+                         const storage::FileSystemURL& url) {
   *status_out = status;
   *url_out = url;
   closure.Run();
 }
 
 }  // namespace
 
 class DriveBackendSyncTest : public testing::Test,
                              public LocalFileSyncService::Observer,
                              public RemoteFileSyncService::Observer {
@@ skipping 87 matching lines @@
 
   virtual void OnRemoteChangeQueueUpdated(int64 pending_changes_hint) OVERRIDE {
     pending_remote_changes_ = pending_changes_hint;
   }
 
   virtual void OnLocalChangeAvailable(int64 pending_changes_hint) OVERRIDE {
     pending_local_changes_ = pending_changes_hint;
   }
 
  protected:
-  fileapi::FileSystemURL CreateURL(const std::string& app_id,
+  storage::FileSystemURL CreateURL(const std::string& app_id,
                                    const base::FilePath::StringType& path) {
     return CreateURL(app_id, base::FilePath(path));
   }
 
-  fileapi::FileSystemURL CreateURL(const std::string& app_id,
+  storage::FileSystemURL CreateURL(const std::string& app_id,
                                    const base::FilePath& path) {
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
     return CreateSyncableFileSystemURL(origin, path);
   }
 
   bool GetAppRootFolderID(const std::string& app_id,
                           std::string* folder_id) {
     base::RunLoop run_loop;
     bool success = false;
     FileTracker tracker;
@@ skipping 82 matching lines @@
                       const base::FilePath::StringType& path) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->CreateDirectory(
                   CreateURL(app_id, path)));
   }
 
   void AddOrUpdateLocalFile(const std::string& app_id,
                             const base::FilePath::StringType& path,
                             const std::string& content) {
-    fileapi::FileSystemURL url(CreateURL(app_id, path));
+    storage::FileSystemURL url(CreateURL(app_id, path));
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK, file_systems_[app_id]->CreateFile(url));
     int64 bytes_written = file_systems_[app_id]->WriteString(url, content);
     EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
     base::RunLoop().RunUntilIdle();
   }
 
   void UpdateLocalFile(const std::string& app_id,
                        const base::FilePath::StringType& path,
                        const std::string& content) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     int64 bytes_written = file_systems_[app_id]->WriteString(
         CreateURL(app_id, path), content);
     EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
     base::RunLoop().RunUntilIdle();
   }
 
   void RemoveLocal(const std::string& app_id,
                    const base::FilePath::StringType& path) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->Remove(
                   CreateURL(app_id, path),
                   true /* recursive */));
     base::RunLoop().RunUntilIdle();
   }
 
   SyncStatusCode ProcessLocalChange() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    fileapi::FileSystemURL url;
+    storage::FileSystemURL url;
     base::RunLoop run_loop;
     local_sync_service_->ProcessLocalChange(base::Bind(
         &SetSyncStatusAndUrl, run_loop.QuitClosure(), &status, &url));
     run_loop.Run();
     return status;
   }
 
   SyncStatusCode ProcessRemoteChange() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    fileapi::FileSystemURL url;
+    storage::FileSystemURL url;
     base::RunLoop run_loop;
     remote_sync_service_->ProcessRemoteChange(base::Bind(
         &SetSyncStatusAndUrl, run_loop.QuitClosure(), &status, &url));
     run_loop.Run();
     return status;
   }
 
   int64 GetLargestChangeID() {
     scoped_ptr<google_apis::AboutResource> about_resource;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
@@ skipping 128 matching lines @@
                   folder_id, &remote_entries));
     std::map<std::string, const google_apis::ResourceEntry*>
         remote_entry_by_title;
     for (size_t i = 0; i < remote_entries.size(); ++i) {
       google_apis::ResourceEntry* remote_entry = remote_entries[i];
       EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry->title()))
           << "title: " << remote_entry->title();
       remote_entry_by_title[remote_entry->title()] = remote_entry;
     }
 
-    fileapi::FileSystemURL url(CreateURL(app_id, path));
+    storage::FileSystemURL url(CreateURL(app_id, path));
     FileEntryList local_entries;
     EXPECT_EQ(base::File::FILE_OK,
               file_system->ReadDirectory(url, &local_entries));
     for (FileEntryList::iterator itr = local_entries.begin();
          itr != local_entries.end();
          ++itr) {
-      const fileapi::DirectoryEntry& local_entry = *itr;
-      fileapi::FileSystemURL entry_url(
+      const storage::DirectoryEntry& local_entry = *itr;
+      storage::FileSystemURL entry_url(
           CreateURL(app_id, path.Append(local_entry.name)));
       std::string title =
-          fileapi::VirtualPath::BaseName(entry_url.path()).AsUTF8Unsafe();
+          storage::VirtualPath::BaseName(entry_url.path()).AsUTF8Unsafe();
       SCOPED_TRACE(testing::Message() << "Verifying entry: " << title);
 
       ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
       const google_apis::ResourceEntry& remote_entry =
           *remote_entry_by_title[title];
       if (local_entry.is_directory) {
         ASSERT_TRUE(remote_entry.is_folder());
         VerifyConsistencyForFolder(app_id, entry_url.path(),
                                    remote_entry.resource_id(),
                                    file_system);
       } else {
         ASSERT_TRUE(remote_entry.is_file());
         VerifyConsistencyForFile(app_id, entry_url.path(),
                                  remote_entry.resource_id(),
                                  file_system);
       }
       remote_entry_by_title.erase(title);
     }
 
     EXPECT_TRUE(remote_entry_by_title.empty());
   }
 
   void VerifyConsistencyForFile(const std::string& app_id,
                                 const base::FilePath& path,
                                 const std::string& file_id,
                                 CannedSyncableFileSystem* file_system) {
-    fileapi::FileSystemURL url(CreateURL(app_id, path));
+    storage::FileSystemURL url(CreateURL(app_id, path));
     std::string file_content;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ReadFile(file_id, &file_content));
     EXPECT_EQ(base::File::FILE_OK,
               file_system->VerifyFile(url, file_content));
   }
 
   size_t CountApp() {
     return file_systems_.size();
   }
 
   size_t CountLocalFile(const std::string& app_id) {
     if (!ContainsKey(file_systems_, app_id))
       return 0;
 
     CannedSyncableFileSystem* file_system = file_systems_[app_id];
     std::stack<base::FilePath> folders;
     folders.push(base::FilePath());  // root folder
 
     size_t result = 1;
     while (!folders.empty()) {
-      fileapi::FileSystemURL url(CreateURL(app_id, folders.top()));
+      storage::FileSystemURL url(CreateURL(app_id, folders.top()));
       folders.pop();
 
       FileEntryList entries;
       EXPECT_EQ(base::File::FILE_OK,
                 file_system->ReadDirectory(url, &entries));
       for (FileEntryList::iterator itr = entries.begin();
            itr != entries.end(); ++itr) {
         ++result;
         if (itr->is_directory)
           folders.push(url.path().Append(itr->name));
@@ skipping 1188 matching lines @@
 
   EXPECT_EQ(1u, CountApp());
   EXPECT_EQ(1u, CountLocalFile(app_id));
 
   EXPECT_EQ(2u, CountMetadata());
   EXPECT_EQ(2u, CountTracker());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system