FileAPI: Add Initialize() function to FileSystemBackend

webkit/browser/fileapi/sandbox_file_system_backend.cc

 // Copyright (c) 2012 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/browser/fileapi/sandbox_file_system_backend.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 117 matching lines @@
 
 }  // anonymous namespace
 
 SandboxFileSystemBackend::SandboxFileSystemBackend(
     SandboxContext* sandbox_context,
     const FileSystemOptions& file_system_options)
     : file_system_options_(file_system_options),
       sandbox_context_(sandbox_context),
       enable_temporary_file_system_in_incognito_(false),
       weak_factory_(this) {
+}
+
+SandboxFileSystemBackend::~SandboxFileSystemBackend() {
+}
+
+bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
+  return type == kFileSystemTypeTemporary ||
+         type == kFileSystemTypePersistent ||
+         type == kFileSystemTypeSyncable ||
+         type == kFileSystemTypeSyncableForInternalSync;
+}
+
+void SandboxFileSystemBackend::Initialize(FileSystemContext* context) {
   // Set quota observers.
   if (sandbox_context_->is_usage_tracking_enabled()) {
     update_observers_ = update_observers_.AddObserver(
         sandbox_context_->quota_observer(),
         sandbox_context_->file_task_runner());
     access_observers_ = access_observers_.AddObserver(
         sandbox_context_->quota_observer(), NULL);
   }
 
   syncable_update_observers_ = update_observers_;
 
   if (!sandbox_context_->file_task_runner()->RunsTasksOnCurrentThread()) {
     // Post prepopulate task only if it's not already running on
     // file_task_runner (which implies running in tests).
     sandbox_context_->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase,
                   base::Unretained(sandbox_sync_file_util())));
   }
 }
 
-SandboxFileSystemBackend::~SandboxFileSystemBackend() {
-}
-
-bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
-  return type == kFileSystemTypeTemporary ||
-         type == kFileSystemTypePersistent ||
-         type == kFileSystemTypeSyncable ||
-         type == kFileSystemTypeSyncableForInternalSync;
-}
-
-void SandboxFileSystemBackend::InitializeFileSystem(
+void SandboxFileSystemBackend::OpenFileSystem(
     const GURL& origin_url,
     fileapi::FileSystemType type,
     OpenFileSystemMode mode,
-    FileSystemContext* context,
-    const InitializeFileSystemCallback& callback) {
+    const OpenFileSystemCallback& callback) {
   if (file_system_options_.is_incognito() &&
       !(type == kFileSystemTypeTemporary &&
         enable_temporary_file_system_in_incognito_)) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
@@ skipping 466 matching lines @@
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     usage += enumerator->Size();
     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
 
   return usage;
 }
 
 }  // namespace fileapi