Stop returning the true root path of each filesystem from openFileSystem....

webkit/fileapi/file_system_usage_tracker.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/file_system_usage_tracker.h"
 
 #include <algorithm>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
+#include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 namespace fileapi {
 
 class FileSystemUsageTracker::GetUsageTask
     : public base::RefCountedThreadSafe<GetUsageTask> {
  public:
   GetUsageTask(
       FileSystemUsageTracker* tracker,
       scoped_refptr<base::MessageLoopProxy> file_message_loop,
       std::string fs_identifier,
@@ skipping 63 matching lines @@
   int64 fs_usage_;
   FilePath origin_base_path_;
 };
 
 FileSystemUsageTracker::FileSystemUsageTracker(
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     const FilePath& profile_path,
     bool is_incognito)
     : file_message_loop_(file_message_loop),
       base_path_(profile_path.Append(
-          FileSystemPathManager::kFileSystemDirectory)),
+          SandboxMountPointProvider::kFileSystemDirectory)),
       is_incognito_(is_incognito) {
   DCHECK(file_message_loop);
 }
 
 FileSystemUsageTracker::~FileSystemUsageTracker() {
   std::for_each(running_usage_tasks_.begin(),
                 running_usage_tasks_.end(),
                 std::mem_fun(&GetUsageTask::Cancel));
 }
 
 void FileSystemUsageTracker::GetOriginUsage(
     const GURL& origin_url,
     fileapi::FileSystemType type,
     GetUsageCallback* callback_ptr) {
   DCHECK(callback_ptr);
   scoped_ptr<GetUsageCallback> callback(callback_ptr);
 
   if (is_incognito_) {
     // We don't support FileSystem in incognito mode yet.
     callback->Run(0);
     return;
   }
 
   std::string origin_identifier =
-      FileSystemPathManager::GetOriginIdentifierFromURL(origin_url);
+      SandboxMountPointProvider::GetOriginIdentifierFromURL(origin_url);
   std::string type_string =
       FileSystemPathManager::GetFileSystemTypeString(type);
   std::string fs_identifier = origin_identifier + ":" + type_string;
 
   if (pending_usage_callbacks_.find(fs_identifier) !=
       pending_usage_callbacks_.end()) {
     // Another get usage task is running.  Add the callback to
     // the pending queue and return.
     pending_usage_callbacks_[fs_identifier].push_back(callback.release());
     return;
   }
 
   // Get the filesystem base path (i.e. "FileSystem/<origin>/<type>",
   // without unique part).
   FilePath origin_base_path =
-      FileSystemPathManager::GetFileSystemBaseDirectoryForOriginAndType(
+      SandboxMountPointProvider::GetFileSystemBaseDirectoryForOriginAndType(
           base_path_, origin_identifier, type);
   if (origin_base_path.empty()) {
     // The directory does not exist.
     callback->Run(0);
     return;
   }
 
   pending_usage_callbacks_[fs_identifier].push_back(callback.release());
   scoped_refptr<GetUsageTask> task(
       new GetUsageTask(this, file_message_loop_, fs_identifier,
@@ skipping 19 matching lines @@
   for (PendingCallbackList::iterator cb_iter = cb_list.begin();
         cb_iter != cb_list.end();
         ++cb_iter) {
     scoped_ptr<GetUsageCallback> callback(*cb_iter);
     callback->Run(usage);
   }
   pending_usage_callbacks_.erase(cb_list_iter);
 }
 
 }  // namespace fileapi