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

chrome/browser/sync_file_system/local/local_file_sync_status.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_sync_status.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemURL;
-using fileapi::FileSystemURLSet;
+using storage::FileSystemURL;
+using storage::FileSystemURLSet;
 
 namespace sync_file_system {
 
 namespace {
 
 typedef LocalFileSyncStatus::OriginAndType OriginAndType;
 
-OriginAndType GetOriginAndType(const fileapi::FileSystemURL& url) {
+OriginAndType GetOriginAndType(const storage::FileSystemURL& url) {
   return std::make_pair(url.origin(), url.type());
 }
 
 base::FilePath NormalizePath(const base::FilePath& path) {
   // Ensure |path| has single trailing path-separator, so that we can use
   // prefix-match to find descendants of |path| in an ordered container.
   return base::FilePath(path.StripTrailingSeparators().value() +
-                        fileapi::VirtualPath::kSeparator);
+                        storage::VirtualPath::kSeparator);
 }
 
 struct SetKeyHelper {
   template <typename Iterator>
   static const base::FilePath& GetKey(Iterator itr) {
     return *itr;
   }
 };
 
 struct MapKeyHelper {
@@ skipping 17 matching lines @@
 
   if (upper != paths.end() &&
       normalized_path.IsParent(get_key_helper.GetKey(upper)))
     return true;
 
   // Check if any ancestor of |normalized_path| is in |writing_|.
   while (true) {
     if (ContainsKey(paths, normalized_path))
       return true;
 
-    if (fileapi::VirtualPath::IsRootPath(normalized_path))
+    if (storage::VirtualPath::IsRootPath(normalized_path))
       return false;
 
     normalized_path =
-        NormalizePath(fileapi::VirtualPath::DirName(normalized_path));
+        NormalizePath(storage::VirtualPath::DirName(normalized_path));
   }
 }
 
 }  // namespace
 
 LocalFileSyncStatus::LocalFileSyncStatus() {}
 
 LocalFileSyncStatus::~LocalFileSyncStatus() {}
 
 void LocalFileSyncStatus::StartWriting(const FileSystemURL& url) {
@@ skipping 75 matching lines @@
     const FileSystemURL& url) const {
   DCHECK(CalledOnValidThread());
   URLSet::const_iterator found = syncing_.find(GetOriginAndType(url));
   if (found == syncing_.end())
     return false;
   return ContainsChildOrParent(found->second, url.path(),
                                SetKeyHelper());
 }
 
 }  // namespace sync_file_system