Cleanup: Reorder methods in SandboxMountPointProvider

webkit/fileapi/sandbox_mount_point_provider.cc

 // Copyright (c) 2011 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 "webkit/fileapi/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_callback_factory.h"
@@ skipping 261 matching lines @@
 const FilePath::CharType SandboxMountPointProvider::kOldFileSystemDirectory[] =
     FILE_PATH_LITERAL("FileSystem");
 
 const FilePath::CharType SandboxMountPointProvider::kNewFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 const FilePath::CharType
     SandboxMountPointProvider::kRenamedOldFileSystemDirectory[] =
         FILE_PATH_LITERAL("FS.old");
 
-SandboxMountPointProvider::SandboxMountPointProvider(
-    FileSystemPathManager* path_manager,
-    scoped_refptr<base::MessageLoopProxy> file_message_loop,
-    const FilePath& profile_path)
-    : FileSystemQuotaUtil(file_message_loop),
-      path_manager_(path_manager),
-      file_message_loop_(file_message_loop),
-      profile_path_(profile_path),
-      sandbox_file_util_(
-          new ObfuscatedFileUtil(
-              profile_path.Append(kNewFileSystemDirectory),
-              QuotaFileUtil::CreateDefault())) {
-}
-
-SandboxMountPointProvider::~SandboxMountPointProvider() {
-  if (!file_message_loop_->BelongsToCurrentThread())
-    file_message_loop_->ReleaseSoon(FROM_HERE, sandbox_file_util_.release());
-}
-
-bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
-                                                FileSystemType type,
-                                                const FilePath& unused) {
-  if (type != kFileSystemTypeTemporary && type != kFileSystemTypePersistent)
-    return false;
-  // We essentially depend on quota to do our access controls.
-  return path_manager_->IsAllowedScheme(origin_url);
-}
-
 class SandboxMountPointProvider::GetFileSystemRootPathTask
     : public base::RefCountedThreadSafe<
         SandboxMountPointProvider::GetFileSystemRootPathTask> {
  public:
   GetFileSystemRootPathTask(
       scoped_refptr<base::MessageLoopProxy> file_message_loop,
       const GURL& origin_url,
       FileSystemType type,
       ObfuscatedFileUtil* file_util,
       const FilePath& old_base_path,
@@ skipping 60 matching lines @@
 
   scoped_refptr<base::MessageLoopProxy> file_message_loop_;
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   GURL origin_url_;
   FileSystemType type_;
   scoped_refptr<ObfuscatedFileUtil> file_util_;
   FilePath old_base_path_;
   FileSystemPathManager::GetRootPathCallback callback_;
 };
 
-FilePath SandboxMountPointProvider::old_base_path() const {
-  return profile_path_.Append(kOldFileSystemDirectory);
+SandboxMountPointProvider::SandboxMountPointProvider(
+    FileSystemPathManager* path_manager,
+    scoped_refptr<base::MessageLoopProxy> file_message_loop,
+    const FilePath& profile_path)
+    : FileSystemQuotaUtil(file_message_loop),
+      path_manager_(path_manager),
+      file_message_loop_(file_message_loop),
+      profile_path_(profile_path),
+      sandbox_file_util_(
+          new ObfuscatedFileUtil(
+              profile_path.Append(kNewFileSystemDirectory),
+              QuotaFileUtil::CreateDefault())) {
 }
 
-FilePath SandboxMountPointProvider::new_base_path() const {
-  return profile_path_.Append(kNewFileSystemDirectory);
+SandboxMountPointProvider::~SandboxMountPointProvider() {
+  if (!file_message_loop_->BelongsToCurrentThread())
+    file_message_loop_->ReleaseSoon(FROM_HERE, sandbox_file_util_.release());
 }
 
-FilePath SandboxMountPointProvider::renamed_old_base_path() const {
-  return profile_path_.Append(kRenamedOldFileSystemDirectory);
-}
-
-bool SandboxMountPointProvider::IsRestrictedFileName(const FilePath& filename)
-    const {
-  if (filename.value().empty())
+bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
+                                                FileSystemType type,
+                                                const FilePath& unused) {
+  if (type != kFileSystemTypeTemporary && type != kFileSystemTypePersistent)
     return false;
-
-  std::string filename_lower = StringToLowerASCII(
-      FilePathStringToASCII(filename.value()));
-
-  for (size_t i = 0; i < arraysize(kRestrictedNames); ++i) {
-    // Exact match.
-    if (filename_lower == kRestrictedNames[i])
-      return true;
-  }
-
-  for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
-    if (filename.value().find(kRestrictedChars[i]) !=
-        FilePath::StringType::npos)
-      return true;
-  }
-
-  return false;
-}
-
-std::vector<FilePath> SandboxMountPointProvider::GetRootDirectories() const {
-  NOTREACHED();
-  // TODO(ericu): Implement this method and check for access permissions as
-  // fileBrowserPrivate extension API does. We currently have another mechanism,
-  // but we should switch over.  This may also need to call MigrateIfNeeded().
-  return  std::vector<FilePath>();
-}
-
-SandboxMountPointProvider::OriginEnumerator*
-SandboxMountPointProvider::CreateOriginEnumerator() const {
-  MigrateIfNeeded(sandbox_file_util_, old_base_path());
-  return new ObfuscatedOriginEnumerator(sandbox_file_util_.get());
+  // We essentially depend on quota to do our access controls.
+  return path_manager_->IsAllowedScheme(origin_url);
 }
 
 void SandboxMountPointProvider::ValidateFileSystemRootAndGetURL(
     const GURL& origin_url, fileapi::FileSystemType type, bool create,
     const FileSystemPathManager::GetRootPathCallback& callback) {
   FilePath origin_base_path;
 
   if (path_manager_->is_incognito()) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(false, FilePath(), std::string());
@@ skipping 28 matching lines @@
 
   if (!path_manager_->IsAllowedScheme(origin_url))
     return FilePath();
 
   MigrateIfNeeded(sandbox_file_util_, old_base_path());
 
   return sandbox_file_util_->GetDirectoryForOriginAndType(
       origin_url, type, create);
 }
 
+bool SandboxMountPointProvider::IsRestrictedFileName(const FilePath& filename)
+    const {
+  if (filename.value().empty())
+    return false;
+
+  std::string filename_lower = StringToLowerASCII(
+      FilePathStringToASCII(filename.value()));
+
+  for (size_t i = 0; i < arraysize(kRestrictedNames); ++i) {
+    // Exact match.
+    if (filename_lower == kRestrictedNames[i])
+      return true;
+  }
+
+  for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
+    if (filename.value().find(kRestrictedChars[i]) !=
+        FilePath::StringType::npos)
+      return true;
+  }
+
+  return false;
+}
+
+std::vector<FilePath> SandboxMountPointProvider::GetRootDirectories() const {
+  NOTREACHED();
+  // TODO(ericu): Implement this method and check for access permissions as
+  // fileBrowserPrivate extension API does. We currently have another mechanism,
+  // but we should switch over.  This may also need to call MigrateIfNeeded().
+  return  std::vector<FilePath>();
+}
+
+FileSystemFileUtil* SandboxMountPointProvider::GetFileUtil() {
+  return sandbox_file_util_.get();
+}
+
+FilePath SandboxMountPointProvider::old_base_path() const {
+  return profile_path_.Append(kOldFileSystemDirectory);
+}
+
+FilePath SandboxMountPointProvider::new_base_path() const {
+  return profile_path_.Append(kNewFileSystemDirectory);
+}
+
+FilePath SandboxMountPointProvider::renamed_old_base_path() const {
+  return profile_path_.Append(kRenamedOldFileSystemDirectory);
+}
+
+SandboxMountPointProvider::OriginEnumerator*
+SandboxMountPointProvider::CreateOriginEnumerator() const {
+  MigrateIfNeeded(sandbox_file_util_, old_base_path());
+  return new ObfuscatedOriginEnumerator(sandbox_file_util_.get());
+}
+
 FilePath SandboxMountPointProvider::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) const {
 
   MigrateIfNeeded(sandbox_file_util_, old_base_path());
 
   return sandbox_file_util_->GetDirectoryForOriginAndType(
       origin_url, type, create);
 }
 
 bool SandboxMountPointProvider::DeleteOriginDataOnFileThread(
@@ skipping 138 matching lines @@
 
 void SandboxMountPointProvider::InvalidateUsageCache(
     const GURL& origin_url, fileapi::FileSystemType type) {
   DCHECK(type == fileapi::kFileSystemTypeTemporary ||
          type == fileapi::kFileSystemTypePersistent);
   FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       origin_url, type);
   FileSystemUsageCache::IncrementDirty(usage_file_path);
 }
 
-FileSystemFileUtil* SandboxMountPointProvider::GetFileUtil() {
-  return sandbox_file_util_.get();
-}
-
 FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
     const GURL& origin_url, fileapi::FileSystemType type) const {
   FilePath base_path =
       GetBaseDirectoryForOriginAndType(origin_url, type, false);
   if (base_path.empty())
     return FilePath();
   return base_path.AppendASCII(FileSystemUsageCache::kUsageFileName);
 }
 
 FilePath SandboxMountPointProvider::OldCreateFileSystemRootPath(
@@ skipping 15 matching lines @@
 
   // Creates the root directory.
   root = origin_base_path.Append(OldCreateUniqueDirectoryName(origin_url));
   if (!file_util::CreateDirectory(root))
     return FilePath();
 
   return root;
 }
 
 }  // namespace fileapi