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

chrome/browser/sync_file_system/local/local_file_change_tracker.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/local/local_file_change_tracker.h"
 
 #include <queue>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_status.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
-#include "webkit/browser/fileapi/file_system_context.h"
-#include "webkit/browser/fileapi/file_system_file_util.h"
-#include "webkit/browser/fileapi/file_system_operation_context.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_file_util.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemContext;
-using fileapi::FileSystemFileUtil;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
-using fileapi::FileSystemURLSet;
+using storage::FileSystemContext;
+using storage::FileSystemFileUtil;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
+using storage::FileSystemURLSet;
 
 namespace sync_file_system {
 
 namespace {
 const base::FilePath::CharType kDatabaseName[] =
     FILE_PATH_LITERAL("LocalFileChangeTracker");
 const char kMark[] = "d";
 }  // namespace
 
 // A database class that stores local file changes in a local database. This
@@ skipping 126 matching lines @@
   demoted_changes_.erase(url);
   FileChangeMap::iterator found = changes_.find(url);
   if (found == changes_.end())
     return;
   change_seqs_.erase(found->second.change_seq);
   changes_.erase(found);
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::CreateFreshMirrorForURL(
-    const fileapi::FileSystemURL& url) {
+    const storage::FileSystemURL& url) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!ContainsKey(mirror_changes_, url));
   mirror_changes_[url] = ChangeInfo();
 }
 
 void LocalFileChangeTracker::RemoveMirrorAndCommitChangesForURL(
-    const fileapi::FileSystemURL& url) {
+    const storage::FileSystemURL& url) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   FileChangeMap::iterator found = mirror_changes_.find(url);
   if (found == mirror_changes_.end())
     return;
   mirror_changes_.erase(found);
 
   if (ContainsKey(changes_, url) || ContainsKey(demoted_changes_, url))
     MarkDirtyOnDatabase(url);
   else
     ClearDirtyOnDatabase(url);
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::ResetToMirrorAndCommitChangesForURL(
-    const fileapi::FileSystemURL& url) {
+    const storage::FileSystemURL& url) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   FileChangeMap::iterator found = mirror_changes_.find(url);
   if (found == mirror_changes_.end() || found->second.change_list.empty()) {
     ClearChangesForURL(url);
     return;
   }
   const ChangeInfo& info = found->second;
   if (ContainsKey(demoted_changes_, url)) {
     DCHECK(!ContainsKey(changes_, url));
     demoted_changes_[url] = info;
   } else {
     DCHECK(!ContainsKey(demoted_changes_, url));
     change_seqs_[info.change_seq] = url;
     changes_[url] = info;
   }
   RemoveMirrorAndCommitChangesForURL(url);
 }
 
 void LocalFileChangeTracker::DemoteChangesForURL(
-    const fileapi::FileSystemURL& url) {
+    const storage::FileSystemURL& url) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
 
   FileChangeMap::iterator found = changes_.find(url);
   if (found == changes_.end())
     return;
   DCHECK(!ContainsKey(demoted_changes_, url));
   change_seqs_.erase(found->second.change_seq);
   demoted_changes_.insert(*found);
   changes_.erase(found);
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::PromoteDemotedChangesForURL(
-    const fileapi::FileSystemURL& url) {
+    const storage::FileSystemURL& url) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
 
   FileChangeMap::iterator iter = demoted_changes_.find(url);
   if (iter == demoted_changes_.end())
     return;
 
   FileChangeList::List change_list = iter->second.change_list.list();
   // Make sure that this URL is in no queues.
   DCHECK(!ContainsKey(change_seqs_, iter->second.change_seq));
   DCHECK(!ContainsKey(changes_, url));
 
   change_seqs_[iter->second.change_seq] = url;
   changes_.insert(*iter);
   demoted_changes_.erase(iter);
   UpdateNumChanges();
 }
 
 bool LocalFileChangeTracker::PromoteDemotedChanges() {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   if (demoted_changes_.empty())
     return false;
   while (!demoted_changes_.empty()) {
-    fileapi::FileSystemURL url = demoted_changes_.begin()->first;
+    storage::FileSystemURL url = demoted_changes_.begin()->first;
     PromoteDemotedChangesForURL(url);
   }
   UpdateNumChanges();
   return true;
 }
 
 SyncStatusCode LocalFileChangeTracker::Initialize(
     FileSystemContext* file_system_context) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!initialized_);
   DCHECK(file_system_context);
 
   SyncStatusCode status = CollectLastDirtyChanges(file_system_context);
   if (status == SYNC_STATUS_OK)
     initialized_ = true;
   return status;
 }
 
-void LocalFileChangeTracker::ResetForFileSystem(
-    const GURL& origin,
-    fileapi::FileSystemType type) {
+void LocalFileChangeTracker::ResetForFileSystem(const GURL& origin,
+                                                storage::FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   for (FileChangeMap::iterator iter = changes_.begin();
        iter != changes_.end();) {
-    fileapi::FileSystemURL url = iter->first;
+    storage::FileSystemURL url = iter->first;
     int change_seq = iter->second.change_seq;
     // Advance |iter| before calling ResetForURL to avoid the iterator
     // invalidation in it.
     ++iter;
     if (url.origin() == origin && url.type() == type)
       ResetForURL(url, change_seq, batch.get());
   }
 
   for (FileChangeMap::iterator iter = demoted_changes_.begin();
        iter != demoted_changes_.end();) {
-    fileapi::FileSystemURL url = iter->first;
+    storage::FileSystemURL url = iter->first;
     int change_seq = iter->second.change_seq;
     // Advance |iter| before calling ResetForURL to avoid the iterator
     // invalidation in it.
     ++iter;
     if (url.origin() == origin && url.type() == type)
       ResetForURL(url, change_seq, batch.get());
   }
 
   // Fail to apply batch to database wouldn't have critical effect, they'll be
   // just marked deleted on next relaunch.
@@ skipping 55 matching lines @@
   DCHECK(file_util);
   scoped_ptr<FileSystemOperationContext> context(
       new FileSystemOperationContext(file_system_context));
 
   base::File::Info file_info;
   base::FilePath platform_path;
 
   while (!dirty_files.empty()) {
     const FileSystemURL url = dirty_files.front();
     dirty_files.pop();
-    DCHECK_EQ(url.type(), fileapi::kFileSystemTypeSyncable);
+    DCHECK_EQ(url.type(), storage::kFileSystemTypeSyncable);
 
     switch (file_util->GetFileInfo(context.get(), url,
                                    &file_info, &platform_path)) {
       case base::File::FILE_OK: {
         if (!file_info.is_directory) {
           RecordChange(url, FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                                        SYNC_FILE_TYPE_FILE));
           break;
         }
 
@@ skipping 60 matching lines @@
   info.change_list.Update(change);
   if (info.change_list.empty()) {
     changes->erase(url);
     return;
   }
   info.change_seq = new_change_seq;
   if (change_seqs)
     (*change_seqs)[info.change_seq] = url;
 }
 
-void LocalFileChangeTracker::ResetForURL(const fileapi::FileSystemURL& url,
+void LocalFileChangeTracker::ResetForURL(const storage::FileSystemURL& url,
                                          int change_seq,
                                          leveldb::WriteBatch* batch) {
   mirror_changes_.erase(url);
   demoted_changes_.erase(url);
   change_seqs_.erase(change_seq);
   changes_.erase(url);
 
   std::string serialized_url;
   if (!SerializeSyncableFileSystemURL(url, &serialized_url)) {
     NOTREACHED() << "Failed to serialize: " << url.DebugString();
     return;
   }
   batch->Delete(serialized_url);
 }
 
 // TrackerDB -------------------------------------------------------------------
 
 LocalFileChangeTracker::TrackerDB::TrackerDB(const base::FilePath& base_path,
                                              leveldb::Env* env_override)
   : base_path_(base_path),
     env_override_(env_override),
     db_status_(SYNC_STATUS_OK) {}
 
 SyncStatusCode LocalFileChangeTracker::TrackerDB::Init(
     RecoveryOption recovery_option) {
   if (db_.get() && db_status_ == SYNC_STATUS_OK)
     return SYNC_STATUS_OK;
 
-  std::string path = fileapi::FilePathToString(
-      base_path_.Append(kDatabaseName));
+  std::string path =
+      storage::FilePathToString(base_path_.Append(kDatabaseName));
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = true;
   if (env_override_)
     options.env = env_override_;
   leveldb::DB* db;
   leveldb::Status status = leveldb::DB::Open(options, path, &db);
   if (status.ok()) {
     db_.reset(db);
     return SYNC_STATUS_OK;
@@ skipping 119 matching lines @@
   if (!status.ok() && !status.IsNotFound()) {
     HandleError(FROM_HERE, status);
     db_status_ = LevelDBStatusToSyncStatusCode(status);
     db_.reset();
     return db_status_;
   }
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system