Files.app: Rename the FileBrowserPrivateAPI's functions.

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/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
 #include <utime.h>
@@ skipping 160 matching lines @@
     return false;
 
   struct utimbuf times;
   times.actime = stat_buffer.st_atime;
   times.modtime = timestamp;
   return utime(local_path.value().c_str(), &times) == 0;
 }
 
 }  // namespace
 
-RequestFileSystemFunction::RequestFileSystemFunction() {
+FileBrowserPrivateRequestFileSystemFunction::
+    FileBrowserPrivateRequestFileSystemFunction() {
 }
 
-RequestFileSystemFunction::~RequestFileSystemFunction() {
+FileBrowserPrivateRequestFileSystemFunction::
+    ~FileBrowserPrivateRequestFileSystemFunction() {
 }
 
-void RequestFileSystemFunction::DidOpenFileSystem(
+void FileBrowserPrivateRequestFileSystemFunction::DidOpenFileSystem(
     scoped_refptr<fileapi::FileSystemContext> file_system_context,
     base::PlatformFileError result,
     const std::string& name,
     const GURL& root_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (result != base::PLATFORM_FILE_OK) {
     DidFail(result);
     return;
   }
@@ skipping 23 matching lines @@
   SetDriveMountPointPermissions(profile_, extension_id(), render_view_host());
 
   DictionaryValue* dict = new DictionaryValue();
   SetResult(dict);
   dict->SetString("name", name);
   dict->SetString("path", root_path.spec());
   dict->SetInteger("error", drive::FILE_ERROR_OK);
   SendResponse(true);
 }
 
-void RequestFileSystemFunction::DidFail(
+void FileBrowserPrivateRequestFileSystemFunction::DidFail(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   error_ = base::StringPrintf(kFileError, static_cast<int>(error_code));
   SendResponse(false);
 }
 
-bool RequestFileSystemFunction::SetupFileSystemAccessPermissions(
-    scoped_refptr<fileapi::FileSystemContext> file_system_context,
-    int child_id,
-    scoped_refptr<const extensions::Extension> extension) {
+bool FileBrowserPrivateRequestFileSystemFunction::
+    SetupFileSystemAccessPermissions(
+        scoped_refptr<fileapi::FileSystemContext> file_system_context,
+        int child_id,
+        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
   // local file system.
   if (extension_->location() != extensions::Manifest::COMPONENT) {
     NOTREACHED() << "Private method access by non-component extension "
                  << extension->id();
@@ skipping 11 matching lines @@
   // Grant R/W file permissions to the renderer hosting component
   // extension for all paths exposed by our local file system backend.
   std::vector<base::FilePath> root_dirs = backend->GetRootDirectories();
   for (size_t i = 0; i < root_dirs.size(); ++i) {
     ChildProcessSecurityPolicy::GetInstance()->GrantCreateReadWriteFile(
         child_id, root_dirs[i]);
   }
   return true;
 }
 
-bool RequestFileSystemFunction::RunImpl() {
+bool FileBrowserPrivateRequestFileSystemFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!dispatcher() || !render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   set_log_on_completion(true);
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   const GURL origin_url = source_url_.GetOrigin();
   file_system_context->OpenFileSystem(
       origin_url,
       fileapi::kFileSystemTypeExternal,
       fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
-      base::Bind(&RequestFileSystemFunction::DidOpenFileSystem,
+      base::Bind(&FileBrowserPrivateRequestFileSystemFunction::
+                     DidOpenFileSystem,
                  this,
                  file_system_context));
   return true;
 }
 
 FileWatchFunctionBase::FileWatchFunctionBase() {
 }
 
 FileWatchFunctionBase::~FileWatchFunctionBase() {
 }
@@ skipping 25 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;
 }
 
-AddFileWatchFunction::AddFileWatchFunction() {
+FileBrowserPrivateAddFileWatchFunction::
+    FileBrowserPrivateAddFileWatchFunction() {
 }
 
-AddFileWatchFunction::~AddFileWatchFunction() {
+FileBrowserPrivateAddFileWatchFunction::
+    ~FileBrowserPrivateAddFileWatchFunction() {
 }
 
-void AddFileWatchFunction::PerformFileWatchOperation(
+void FileBrowserPrivateAddFileWatchFunction::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(profile_)->event_router();
   event_router->AddFileWatch(
       local_path,
       virtual_path,
       extension_id,
-      base::Bind(&AddFileWatchFunction::Respond, this));
+      base::Bind(&FileBrowserPrivateAddFileWatchFunction::Respond, this));
 }
 
-RemoveFileWatchFunction::RemoveFileWatchFunction() {
+FileBrowserPrivateRemoveFileWatchFunction::
+    FileBrowserPrivateRemoveFileWatchFunction() {
 }
 
-RemoveFileWatchFunction::~RemoveFileWatchFunction() {
+FileBrowserPrivateRemoveFileWatchFunction::
+    ~FileBrowserPrivateRemoveFileWatchFunction() {
 }
 
-void RemoveFileWatchFunction::PerformFileWatchOperation(
+void FileBrowserPrivateRemoveFileWatchFunction::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(profile_)->event_router();
   event_router->RemoveFileWatch(local_path, extension_id);
   Respond(true);
 }
 
-SetLastModifiedFunction::SetLastModifiedFunction() {
+FileBrowserPrivateSetLastModifiedFunction::
+    FileBrowserPrivateSetLastModifiedFunction() {
 }
 
-SetLastModifiedFunction::~SetLastModifiedFunction() {
+FileBrowserPrivateSetLastModifiedFunction::
+    ~FileBrowserPrivateSetLastModifiedFunction() {
 }
 
-bool SetLastModifiedFunction::RunImpl() {
+bool FileBrowserPrivateSetLastModifiedFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (args_->GetSize() != 2) {
     return false;
   }
 
   std::string file_url;
   if (!args_->GetString(0, &file_url))
     return false;
 
   std::string timestamp;
   if (!args_->GetString(1, &timestamp))
     return false;
 
   base::FilePath local_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(file_url));
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&SetLastModifiedOnBlockingPool,
                  local_path,
                  strtoul(timestamp.c_str(), NULL, 0)),
-      base::Bind(&SetLastModifiedFunction::SendResponse,
+      base::Bind(&FileBrowserPrivateSetLastModifiedFunction::SendResponse,
                  this));
   return true;
 }
 
-GetSizeStatsFunction::GetSizeStatsFunction() {
+FileBrowserPrivateGetSizeStatsFunction::
+    FileBrowserPrivateGetSizeStatsFunction() {
 }
 
-GetSizeStatsFunction::~GetSizeStatsFunction() {
+FileBrowserPrivateGetSizeStatsFunction::
+    ~FileBrowserPrivateGetSizeStatsFunction() {
 }
 
-bool GetSizeStatsFunction::RunImpl() {
+bool FileBrowserPrivateGetSizeStatsFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string mount_url;
   if (!args_->GetString(0, &mount_url))
     return false;
 
   base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(mount_url));
   if (file_path.empty())
     return false;
 
   if (file_path == drive::util::GetDriveMountPointPath()) {
     drive::DriveIntegrationService* integration_service =
         drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
     // |integration_service| is NULL if Drive is disabled.
     if (!integration_service) {
       // If stats couldn't be gotten for drive, result should be left
       // undefined. See comments in GetDriveAvailableSpaceCallback().
       SendResponse(true);
       return true;
     }
 
     drive::FileSystemInterface* file_system =
         integration_service->file_system();
 
     file_system->GetAvailableSpace(
-        base::Bind(&GetSizeStatsFunction::GetDriveAvailableSpaceCallback,
+        base::Bind(&FileBrowserPrivateGetSizeStatsFunction::
+                       GetDriveAvailableSpaceCallback,
                    this));
 
   } else {
     uint64* total_size = new uint64(0);
     uint64* remaining_size = new uint64(0);
     BrowserThread::PostBlockingPoolTaskAndReply(
         FROM_HERE,
         base::Bind(&GetSizeStatsOnBlockingPool,
                    file_path.value(),
                    total_size,
                    remaining_size),
-        base::Bind(&GetSizeStatsFunction::GetSizeStatsCallback,
+        base::Bind(&FileBrowserPrivateGetSizeStatsFunction::
+                       GetSizeStatsCallback,
                    this,
                    base::Owned(total_size),
                    base::Owned(remaining_size)));
   }
   return true;
 }
 
-void GetSizeStatsFunction::GetDriveAvailableSpaceCallback(
+void FileBrowserPrivateGetSizeStatsFunction::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 GetSizeStatsFunction::GetSizeStatsCallback(
+void FileBrowserPrivateGetSizeStatsFunction::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);
 }
 
-GetVolumeMetadataFunction::GetVolumeMetadataFunction() {
+FileBrowserPrivateGetVolumeMetadataFunction::
+    FileBrowserPrivateGetVolumeMetadataFunction() {
 }
 
-GetVolumeMetadataFunction::~GetVolumeMetadataFunction() {
+FileBrowserPrivateGetVolumeMetadataFunction::
+    ~FileBrowserPrivateGetVolumeMetadataFunction() {
 }
 
-bool GetVolumeMetadataFunction::RunImpl() {
+bool FileBrowserPrivateGetVolumeMetadataFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string volume_mount_url;
   if (!args_->GetString(0, &volume_mount_url)) {
     NOTREACHED();
     return false;
   }
@@ skipping 16 matching lines @@
   } else {
     const DiskMountManager::Disk* volume = GetVolumeAsDisk(file_path.value());
     if (volume)
       SetResult(CreateValueFromDisk(profile_, extension_->id(), volume));
   }
 
   SendResponse(true);
   return true;
 }
 
-ValidatePathNameLengthFunction::ValidatePathNameLengthFunction() {
+FileBrowserPrivateValidatePathNameLengthFunction::
+    FileBrowserPrivateValidatePathNameLengthFunction() {
 }
 
-ValidatePathNameLengthFunction::~ValidatePathNameLengthFunction() {
+FileBrowserPrivateValidatePathNameLengthFunction::
+    ~FileBrowserPrivateValidatePathNameLengthFunction() {
 }
 
-bool ValidatePathNameLengthFunction::RunImpl() {
+bool FileBrowserPrivateValidatePathNameLengthFunction::RunImpl() {
   std::string parent_url;
   if (!args_->GetString(0, &parent_url))
     return false;
 
   std::string name;
   if (!args_->GetString(1, &name))
     return false;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   fileapi::FileSystemURL filesystem_url(
       file_system_context->CrackURL(GURL(parent_url)));
   if (!chromeos::FileSystemBackend::CanHandleURL(filesystem_url))
     return false;
 
   // No explicit limit on the length of Drive file names.
   if (filesystem_url.type() == fileapi::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(&ValidatePathNameLengthFunction::OnFilePathLimitRetrieved,
+      base::Bind(&FileBrowserPrivateValidatePathNameLengthFunction::
+                     OnFilePathLimitRetrieved,
                  this, name.size()));
   return true;
 }
 
-void ValidatePathNameLengthFunction::OnFilePathLimitRetrieved(
+void FileBrowserPrivateValidatePathNameLengthFunction::OnFilePathLimitRetrieved(
     size_t current_length,
     size_t max_length) {
   SetResult(new base::FundamentalValue(current_length <= max_length));
   SendResponse(true);
 }
 
-FormatDeviceFunction::FormatDeviceFunction() {
+FileBrowserPrivateFormatDeviceFunction::
+    FileBrowserPrivateFormatDeviceFunction() {
 }
 
-FormatDeviceFunction::~FormatDeviceFunction() {
+FileBrowserPrivateFormatDeviceFunction::
+    ~FileBrowserPrivateFormatDeviceFunction() {
 }
 
-bool FormatDeviceFunction::RunImpl() {
+bool FileBrowserPrivateFormatDeviceFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string volume_file_url;
   if (!args_->GetString(0, &volume_file_url)) {
     NOTREACHED();
     return false;
   }
 
   base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(volume_file_url));
   if (file_path.empty())
     return false;
 
   DiskMountManager::GetInstance()->FormatMountedDevice(file_path.value());
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions