Files.app: Rename the FileBrowserPrivateAPI's functions.

chrome/browser/chromeos/extensions/file_manager/private_api_mount.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_mount.h"
 
 #include "base/format_macros.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
@@ skipping 50 matching lines @@
   result->SetString("mountPath", "Downloads");
   result->SetString(
       "mountCondition",
       DiskMountManager::MountConditionToString(
           chromeos::disks::MOUNT_CONDITION_NONE));
   return result;
 }
 
 }  // namespace
 
-AddMountFunction::AddMountFunction() {
+FileBrowserPrivateAddMountFunction::FileBrowserPrivateAddMountFunction() {
 }
 
-AddMountFunction::~AddMountFunction() {
+FileBrowserPrivateAddMountFunction::~FileBrowserPrivateAddMountFunction() {
 }
 
-bool AddMountFunction::RunImpl() {
+bool FileBrowserPrivateAddMountFunction::RunImpl() {
   // The third argument is simply ignored.
   if (args_->GetSize() != 2 && args_->GetSize() != 3) {
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string file_url;
   if (!args_->GetString(0, &file_url)) {
     return false;
   }
@@ skipping 51 matching lines @@
         drive::DriveIntegrationService* integration_service =
             drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
         drive::FileSystemInterface* file_system =
             integration_service ? integration_service->file_system() : NULL;
         if (!file_system) {
           SendResponse(false);
           break;
         }
         file_system->MarkCacheFileAsMounted(
             drive::util::ExtractDrivePath(path),
-            base::Bind(&AddMountFunction::OnMountedStateSet,
+            base::Bind(&FileBrowserPrivateAddMountFunction::OnMountedStateSet,
                        this, mount_type_str, display_name));
       } else {
         OnMountedStateSet(mount_type_str, display_name,
                           drive::FILE_ERROR_OK, path);
       }
       break;
     }
   }
 
   return true;
 }
 
-void AddMountFunction::OnMountedStateSet(
+void FileBrowserPrivateAddMountFunction::OnMountedStateSet(
     const std::string& mount_type,
     const base::FilePath::StringType& file_name,
     drive::FileError error,
     const base::FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   // Pass back the actual source path of the mount point.
   SetResult(new base::StringValue(file_path.value()));
   SendResponse(true);
   // MountPath() takes a std::string.
   disk_mount_manager->MountPath(
       file_path.AsUTF8Unsafe(), base::FilePath(file_name).Extension(),
       file_name, DiskMountManager::MountTypeFromString(mount_type));
 }
 
-RemoveMountFunction::RemoveMountFunction() {
+FileBrowserPrivateRemoveMountFunction::FileBrowserPrivateRemoveMountFunction() {
 }
 
-RemoveMountFunction::~RemoveMountFunction() {
+FileBrowserPrivateRemoveMountFunction::
+    ~FileBrowserPrivateRemoveMountFunction() {
 }
 
-bool RemoveMountFunction::RunImpl() {
+bool FileBrowserPrivateRemoveMountFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string mount_path;
   if (!args_->GetString(0, &mount_path)) {
     return false;
   }
 
   drive::util::Log(logging::LOG_INFO,
                    "%s[%d] called. (mount_path: '%s')",
                    name().c_str(),
                    request_id(),
                    mount_path.c_str());
   set_log_on_completion(true);
 
   std::vector<GURL> file_paths;
   file_paths.push_back(GURL(mount_path));
   file_manager::util::GetSelectedFileInfo(
       render_view_host(),
       profile(),
       file_paths,
       file_manager::util::NEED_LOCAL_PATH_FOR_OPENING,
-      base::Bind(&RemoveMountFunction::GetSelectedFileInfoResponse, this));
+      base::Bind(&FileBrowserPrivateRemoveMountFunction::
+                     GetSelectedFileInfoResponse, this));
   return true;
 }
 
-void RemoveMountFunction::GetSelectedFileInfoResponse(
+void FileBrowserPrivateRemoveMountFunction::GetSelectedFileInfoResponse(
     const std::vector<ui::SelectedFileInfo>& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
   // TODO(tbarzic): Send response when callback is received, it would make more
   // sense than remembering issued unmount requests in file manager and showing
   // errors for them when MountCompleted event is received.
   DiskMountManager::GetInstance()->UnmountPath(
       files[0].local_path.value(),
       chromeos::UNMOUNT_OPTIONS_NONE,
       DiskMountManager::UnmountPathCallback());
   SendResponse(true);
 }
 
-GetMountPointsFunction::GetMountPointsFunction() {
+FileBrowserPrivateGetMountPointsFunction::
+    FileBrowserPrivateGetMountPointsFunction() {
 }
 
-GetMountPointsFunction::~GetMountPointsFunction() {
+FileBrowserPrivateGetMountPointsFunction::
+    ~FileBrowserPrivateGetMountPointsFunction() {
 }
 
-bool GetMountPointsFunction::RunImpl() {
+bool FileBrowserPrivateGetMountPointsFunction::RunImpl() {
   if (args_->GetSize())
     return false;
 
   base::ListValue *mounts = new base::ListValue();
   SetResult(mounts);
 
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   DiskMountManager::MountPointMap mount_points =
       disk_mount_manager->mount_points();
 
@@ skipping 23 matching lines @@
                    name().c_str(),
                    request_id(),
                    log_string.c_str(),
                    mount_points.size());
 
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions