Rename fileBrowserPrivate to fileManagerPrivate

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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/chromeos/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/event_router.h"
-#include "chrome/browser/chromeos/extensions/file_manager/file_browser_private_api.h"
+#include "chrome/browser/chromeos/extensions/file_manager/file_manager_private_api.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/common/extensions/api/file_browser_private.h"
-#include "chrome/common/extensions/api/file_browser_private_internal.h"
+#include "chrome/common/extensions/api/file_manager_private.h"
+#include "chrome/common/extensions/api/file_manager_private_internal.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "net/base/escape.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/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_url.h"
@@ skipping 38 matching lines @@
 // Returns EventRouter for the |profile_id| if available.
 file_manager::EventRouter* GetEventRouterByProfileId(void* profile_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |profile_id| needs to be checked with ProfileManager::IsValidProfile
   // before using it.
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return NULL;
 
-  return file_manager::FileBrowserPrivateAPI::Get(profile)->event_router();
+  return file_manager::FileManagerPrivateAPI::Get(profile)->event_router();
 }
 
 // Notifies the copy progress to extensions via event router.
 void NotifyCopyProgress(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID operation_id,
     storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     int64 size) {
@@ skipping 99 matching lines @@
     scoped_refptr<storage::FileSystemContext> file_system_context,
     storage::FileSystemOperationRunner::OperationID operation_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_context->operation_runner()->Cancel(
       operation_id, base::Bind(&OnCopyCancelled));
 }
 
 }  // namespace
 
-void FileBrowserPrivateRequestFileSystemFunction::DidFail(
+void FileManagerPrivateRequestFileSystemFunction::DidFail(
     base::File::Error error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetError(base::StringPrintf("File error %d", static_cast<int>(error_code)));
   SendResponse(false);
 }
 
 bool
-FileBrowserPrivateRequestFileSystemFunction::SetupFileSystemAccessPermissions(
+FileManagerPrivateRequestFileSystemFunction::SetupFileSystemAccessPermissions(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     int child_id,
     Profile* profile,
     scoped_refptr<const extensions::Extension> extension) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!extension.get())
     return false;
 
   // Make sure that only component extension can access the entire
@@ skipping 29 matching lines @@
   for (size_t i = 0; i < profiles.size(); ++i) {
     if (!profiles[i]->IsOffTheRecord()) {
       file_manager::util::SetupProfileFileAccessPermissions(child_id,
                                                             profiles[i]);
     }
   }
 
   return true;
 }
 
-bool FileBrowserPrivateRequestFileSystemFunction::RunAsync() {
+bool FileManagerPrivateRequestFileSystemFunction::RunAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  using extensions::api::file_browser_private::RequestFileSystem::Params;
+  using extensions::api::file_manager_private::RequestFileSystem::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (!dispatcher() || !render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   set_log_on_completion(true);
 
   using file_manager::VolumeManager;
   using file_manager::VolumeInfo;
@@ skipping 28 matching lines @@
     DidFail(base::File::FILE_ERROR_INVALID_OPERATION);
     return false;
   }
   file_definition.is_directory = true;
 
   file_manager::util::ConvertFileDefinitionToEntryDefinition(
       GetProfile(),
       extension_id(),
       file_definition,
       base::Bind(
-          &FileBrowserPrivateRequestFileSystemFunction::OnEntryDefinition,
+          &FileManagerPrivateRequestFileSystemFunction::OnEntryDefinition,
           this));
   return true;
 }
 
-void FileBrowserPrivateRequestFileSystemFunction::OnEntryDefinition(
+void FileManagerPrivateRequestFileSystemFunction::OnEntryDefinition(
     const EntryDefinition& entry_definition) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_definition.error != base::File::FILE_OK) {
     DidFail(entry_definition.error);
     return;
   }
 
   if (!entry_definition.is_directory) {
     DidFail(base::File::FILE_ERROR_NOT_A_DIRECTORY);
@@ skipping 35 matching lines @@
   base::FilePath virtual_path = file_watch_url.virtual_path();
   if (local_path.empty()) {
     Respond(false);
     return true;
   }
   PerformFileWatchOperation(local_path, virtual_path, extension_id());
 
   return true;
 }
 
-void FileBrowserPrivateAddFileWatchFunction::PerformFileWatchOperation(
+void FileManagerPrivateAddFileWatchFunction::PerformFileWatchOperation(
     const base::FilePath& local_path,
     const base::FilePath& virtual_path,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   file_manager::EventRouter* event_router =
-      file_manager::FileBrowserPrivateAPI::Get(GetProfile())->event_router();
+      file_manager::FileManagerPrivateAPI::Get(GetProfile())->event_router();
   event_router->AddFileWatch(
       local_path,
       virtual_path,
       extension_id,
-      base::Bind(&FileBrowserPrivateAddFileWatchFunction::Respond, this));
+      base::Bind(&FileManagerPrivateAddFileWatchFunction::Respond, this));
 }
 
-void FileBrowserPrivateRemoveFileWatchFunction::PerformFileWatchOperation(
+void FileManagerPrivateRemoveFileWatchFunction::PerformFileWatchOperation(
     const base::FilePath& local_path,
     const base::FilePath& unused,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   file_manager::EventRouter* event_router =
-      file_manager::FileBrowserPrivateAPI::Get(GetProfile())->event_router();
+      file_manager::FileManagerPrivateAPI::Get(GetProfile())->event_router();
   event_router->RemoveFileWatch(local_path, extension_id);
   Respond(true);
 }
 
-bool FileBrowserPrivateGetSizeStatsFunction::RunAsync() {
-  using extensions::api::file_browser_private::GetSizeStats::Params;
+bool FileManagerPrivateGetSizeStatsFunction::RunAsync() {
+  using extensions::api::file_manager_private::GetSizeStats::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::VolumeInfo;
   VolumeManager* volume_manager = VolumeManager::Get(GetProfile());
   if (!volume_manager)
     return false;
 
   VolumeInfo volume_info;
   if (!volume_manager->FindVolumeInfoById(params->volume_id, &volume_info))
     return false;
 
   if (volume_info.type == file_manager::VOLUME_TYPE_GOOGLE_DRIVE) {
     drive::FileSystemInterface* file_system =
         drive::util::GetFileSystemByProfile(GetProfile());
     if (!file_system) {
       // |file_system| is NULL if Drive is disabled.
       // If stats couldn't be gotten for drive, result should be left
       // undefined. See comments in GetDriveAvailableSpaceCallback().
       SendResponse(true);
       return true;
     }
 
     file_system->GetAvailableSpace(
-        base::Bind(&FileBrowserPrivateGetSizeStatsFunction::
+        base::Bind(&FileManagerPrivateGetSizeStatsFunction::
                        GetDriveAvailableSpaceCallback,
                    this));
   } else {
     uint64* total_size = new uint64(0);
     uint64* remaining_size = new uint64(0);
     BrowserThread::PostBlockingPoolTaskAndReply(
         FROM_HERE,
         base::Bind(&GetSizeStatsOnBlockingPool,
                    volume_info.mount_path.value(),
                    total_size,
                    remaining_size),
-        base::Bind(&FileBrowserPrivateGetSizeStatsFunction::
+        base::Bind(&FileManagerPrivateGetSizeStatsFunction::
                        GetSizeStatsCallback,
                    this,
                    base::Owned(total_size),
                    base::Owned(remaining_size)));
   }
   return true;
 }
 
-void FileBrowserPrivateGetSizeStatsFunction::GetDriveAvailableSpaceCallback(
+void FileManagerPrivateGetSizeStatsFunction::GetDriveAvailableSpaceCallback(
     drive::FileError error,
     int64 bytes_total,
     int64 bytes_used) {
   if (error == drive::FILE_ERROR_OK) {
     const uint64 bytes_total_unsigned = bytes_total;
     const uint64 bytes_remaining_unsigned = bytes_total - bytes_used;
     GetSizeStatsCallback(&bytes_total_unsigned,
                          &bytes_remaining_unsigned);
   } else {
     // If stats couldn't be gotten for drive, result should be left undefined.
     SendResponse(true);
   }
 }
 
-void FileBrowserPrivateGetSizeStatsFunction::GetSizeStatsCallback(
+void FileManagerPrivateGetSizeStatsFunction::GetSizeStatsCallback(
     const uint64* total_size,
     const uint64* remaining_size) {
   base::DictionaryValue* sizes = new base::DictionaryValue();
   SetResult(sizes);
 
   sizes->SetDouble("totalSize", static_cast<double>(*total_size));
   sizes->SetDouble("remainingSize", static_cast<double>(*remaining_size));
 
   SendResponse(true);
 }
 
-bool FileBrowserPrivateValidatePathNameLengthFunction::RunAsync() {
-  using extensions::api::file_browser_private::ValidatePathNameLength::Params;
+bool FileManagerPrivateValidatePathNameLengthFunction::RunAsync() {
+  using extensions::api::file_manager_private::ValidatePathNameLength::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   storage::FileSystemURL filesystem_url(
       file_system_context->CrackURL(GURL(params->parent_directory_url)));
   if (!chromeos::FileSystemBackend::CanHandleURL(filesystem_url))
     return false;
 
   // No explicit limit on the length of Drive file names.
   if (filesystem_url.type() == storage::kFileSystemTypeDrive) {
     SetResult(new base::FundamentalValue(true));
     SendResponse(true);
     return true;
   }
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&GetFileNameMaxLengthOnBlockingPool,
                  filesystem_url.path().AsUTF8Unsafe()),
-      base::Bind(&FileBrowserPrivateValidatePathNameLengthFunction::
+      base::Bind(&FileManagerPrivateValidatePathNameLengthFunction::
                      OnFilePathLimitRetrieved,
                  this, params->name.size()));
   return true;
 }
 
-void FileBrowserPrivateValidatePathNameLengthFunction::OnFilePathLimitRetrieved(
+void FileManagerPrivateValidatePathNameLengthFunction::OnFilePathLimitRetrieved(
     size_t current_length,
     size_t max_length) {
   SetResult(new base::FundamentalValue(current_length <= max_length));
   SendResponse(true);
 }
 
-bool FileBrowserPrivateFormatVolumeFunction::RunAsync() {
-  using extensions::api::file_browser_private::FormatVolume::Params;
+bool FileManagerPrivateFormatVolumeFunction::RunAsync() {
+  using extensions::api::file_manager_private::FormatVolume::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::VolumeInfo;
   VolumeManager* volume_manager = VolumeManager::Get(GetProfile());
   if (!volume_manager)
     return false;
 
   VolumeInfo volume_info;
   if (!volume_manager->FindVolumeInfoById(params->volume_id, &volume_info))
     return false;
 
   DiskMountManager::GetInstance()->FormatMountedDevice(
       volume_info.mount_path.AsUTF8Unsafe());
   SendResponse(true);
   return true;
 }
 
-bool FileBrowserPrivateStartCopyFunction::RunAsync() {
+bool FileManagerPrivateStartCopyFunction::RunAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  using  extensions::api::file_browser_private::StartCopy::Params;
+  using  extensions::api::file_manager_private::StartCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (params->source_url.empty() || params->parent.empty() ||
       params->new_name.empty()) {
     // Error code in format of DOMError.name.
     SetError("EncodingError");
     return false;
   }
 
@@ skipping 19 matching lines @@
   }
 
   return BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&StartCopyOnIOThread,
                  GetProfile(),
                  file_system_context,
                  source_url,
                  destination_url),
-      base::Bind(&FileBrowserPrivateStartCopyFunction::RunAfterStartCopy,
+      base::Bind(&FileManagerPrivateStartCopyFunction::RunAfterStartCopy,
                  this));
 }
 
-void FileBrowserPrivateStartCopyFunction::RunAfterStartCopy(
+void FileManagerPrivateStartCopyFunction::RunAfterStartCopy(
     int operation_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetResult(new base::FundamentalValue(operation_id));
   SendResponse(true);
 }
 
-bool FileBrowserPrivateCancelCopyFunction::RunAsync() {
+bool FileManagerPrivateCancelCopyFunction::RunAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  using extensions::api::file_browser_private::CancelCopy::Params;
+  using extensions::api::file_manager_private::CancelCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   // We don't much take care about the result of cancellation.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&CancelCopyOnIOThread, file_system_context, params->copy_id));
   SendResponse(true);
   return true;
 }
 
-bool FileBrowserPrivateInternalResolveIsolatedEntriesFunction::RunAsync() {
-  using extensions::api::file_browser_private_internal::ResolveIsolatedEntries::
+bool FileManagerPrivateInternalResolveIsolatedEntriesFunction::RunAsync() {
+  using extensions::api::file_manager_private_internal::ResolveIsolatedEntries::
       Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
   DCHECK(file_system_context);
 
   const storage::ExternalFileSystemBackend* external_backend =
@@ skipping 18 matching lines @@
     // The API only supports isolated files.
     file_definition.is_directory = false;
     file_definition_list.push_back(file_definition);
   }
 
   file_manager::util::ConvertFileDefinitionListToEntryDefinitionList(
       GetProfile(),
       extension_->id(),
       file_definition_list,  // Safe, since copied internally.
       base::Bind(
-          &FileBrowserPrivateInternalResolveIsolatedEntriesFunction::
+          &FileManagerPrivateInternalResolveIsolatedEntriesFunction::
               RunAsyncAfterConvertFileDefinitionListToEntryDefinitionList,
           this));
   return true;
 }
 
-void FileBrowserPrivateInternalResolveIsolatedEntriesFunction::
+void FileManagerPrivateInternalResolveIsolatedEntriesFunction::
     RunAsyncAfterConvertFileDefinitionListToEntryDefinitionList(scoped_ptr<
         file_manager::util::EntryDefinitionList> entry_definition_list) {
-  using extensions::api::file_browser_private_internal::EntryDescription;
+  using extensions::api::file_manager_private_internal::EntryDescription;
   std::vector<linked_ptr<EntryDescription> > entries;
 
   for (size_t i = 0; i < entry_definition_list->size(); ++i) {
     if (entry_definition_list->at(i).error != base::File::FILE_OK)
       continue;
     linked_ptr<EntryDescription> entry(new EntryDescription);
     entry->file_system_name = entry_definition_list->at(i).file_system_name;
     entry->file_system_root = entry_definition_list->at(i).file_system_root_url;
     entry->file_full_path =
         "/" + entry_definition_list->at(i).full_path.AsUTF8Unsafe();
     entry->file_is_directory = entry_definition_list->at(i).is_directory;
     entries.push_back(entry);
   }
 
-  results_ = extensions::api::file_browser_private_internal::
+  results_ = extensions::api::file_manager_private_internal::
       ResolveIsolatedEntries::Results::Create(entries);
   SendResponse(true);
 }
 }  // namespace extensions