Rename fileBrowserPrivate to fileManagerPrivate

chrome/browser/chromeos/extensions/file_manager/private_api_drive.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_drive.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
@@ skipping 17 matching lines @@
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 
 using file_manager::util::EntryDefinition;
 using file_manager::util::EntryDefinitionCallback;
 using file_manager::util::EntryDefinitionList;
 using file_manager::util::EntryDefinitionListCallback;
 using file_manager::util::FileDefinition;
 using file_manager::util::FileDefinitionList;
-using extensions::api::file_browser_private::EntryProperties;
+using extensions::api::file_manager_private::EntryProperties;
 
 namespace extensions {
 namespace {
 
 // List of connection types of drive.
 // Keep this in sync with the DriveConnectionType in common/js/util.js.
 const char kDriveConnectionTypeOffline[] = "offline";
 const char kDriveConnectionTypeMetered[] = "metered";
 const char kDriveConnectionTypeOnline[] = "online";
 
@@ skipping 301 matching lines @@
     DCHECK(!callback_.is_null());
 
     callback_.Run(properties_.Pass(), drive::FileErrorToBaseFileError(error));
 
     delete this;
   }
 };  // class SingleEntryPropertiesGetterForDrive
 
 }  // namespace
 
-FileBrowserPrivateGetEntryPropertiesFunction::
-    FileBrowserPrivateGetEntryPropertiesFunction()
+FileManagerPrivateGetEntryPropertiesFunction::
+    FileManagerPrivateGetEntryPropertiesFunction()
     : processed_count_(0) {
 }
 
-FileBrowserPrivateGetEntryPropertiesFunction::
-    ~FileBrowserPrivateGetEntryPropertiesFunction() {
+FileManagerPrivateGetEntryPropertiesFunction::
+    ~FileManagerPrivateGetEntryPropertiesFunction() {
 }
 
-bool FileBrowserPrivateGetEntryPropertiesFunction::RunAsync() {
+bool FileManagerPrivateGetEntryPropertiesFunction::RunAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  using api::file_browser_private::GetEntryProperties::Params;
+  using api::file_manager_private::GetEntryProperties::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());
 
   properties_list_.resize(params->file_urls.size());
   for (size_t i = 0; i < params->file_urls.size(); i++) {
     const GURL url = GURL(params->file_urls[i]);
     const storage::FileSystemURL file_system_url =
         file_system_context->CrackURL(url);
     switch (file_system_url.type()) {
       case storage::kFileSystemTypeDrive:
         SingleEntryPropertiesGetterForDrive::Start(
             file_system_url.path(),
             GetProfile(),
-            base::Bind(&FileBrowserPrivateGetEntryPropertiesFunction::
+            base::Bind(&FileManagerPrivateGetEntryPropertiesFunction::
                            CompleteGetEntryProperties,
                        this,
                        i));
         break;
       case storage::kFileSystemTypeProvided:
         // TODO(mtomasz): Add support for provided file systems.
         NOTIMPLEMENTED();
         break;
       default:
         LOG(ERROR) << "Not supported file system type.";
         CompleteGetEntryProperties(i,
                                   make_scoped_ptr(new EntryProperties),
                                   base::File::FILE_ERROR_INVALID_OPERATION);
     }
   }
 
   return true;
 }
 
-void FileBrowserPrivateGetEntryPropertiesFunction::CompleteGetEntryProperties(
+void FileManagerPrivateGetEntryPropertiesFunction::CompleteGetEntryProperties(
     size_t index,
     scoped_ptr<EntryProperties> properties,
     base::File::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(0 <= processed_count_ && processed_count_ < properties_list_.size());
 
   properties_list_[index] = make_linked_ptr(properties.release());
 
   processed_count_++;
   if (processed_count_ < properties_list_.size())
     return;
 
-  results_ = extensions::api::file_browser_private::GetEntryProperties::
+  results_ = extensions::api::file_manager_private::GetEntryProperties::
       Results::Create(properties_list_);
   SendResponse(true);
 }
 
-bool FileBrowserPrivatePinDriveFileFunction::RunAsync() {
+bool FileManagerPrivatePinDriveFileFunction::RunAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  using extensions::api::file_browser_private::PinDriveFile::Params;
+  using extensions::api::file_manager_private::PinDriveFile::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system)  // |file_system| is NULL if Drive is disabled.
     return false;
 
   const base::FilePath drive_path =
       drive::util::ExtractDrivePath(file_manager::util::GetLocalPathFromURL(
           render_view_host(), GetProfile(), GURL(params->file_url)));
   if (params->pin) {
     file_system->Pin(drive_path,
-                     base::Bind(&FileBrowserPrivatePinDriveFileFunction::
+                     base::Bind(&FileManagerPrivatePinDriveFileFunction::
                                     OnPinStateSet, this));
   } else {
     file_system->Unpin(drive_path,
-                       base::Bind(&FileBrowserPrivatePinDriveFileFunction::
+                       base::Bind(&FileManagerPrivatePinDriveFileFunction::
                                       OnPinStateSet, this));
   }
   return true;
 }
 
-void FileBrowserPrivatePinDriveFileFunction::
+void FileManagerPrivatePinDriveFileFunction::
     OnPinStateSet(drive::FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == drive::FILE_ERROR_OK) {
     SendResponse(true);
   } else {
     SetError(drive::FileErrorToString(error));
     SendResponse(false);
   }
 }
 
-FileBrowserPrivateGetDriveFilesFunction::
-    FileBrowserPrivateGetDriveFilesFunction() {
+FileManagerPrivateGetDriveFilesFunction::
+    FileManagerPrivateGetDriveFilesFunction() {
 }
 
-FileBrowserPrivateGetDriveFilesFunction::
-    ~FileBrowserPrivateGetDriveFilesFunction() {
+FileManagerPrivateGetDriveFilesFunction::
+    ~FileManagerPrivateGetDriveFilesFunction() {
 }
 
-bool FileBrowserPrivateGetDriveFilesFunction::RunAsync() {
-  using extensions::api::file_browser_private::GetDriveFiles::Params;
+bool FileManagerPrivateGetDriveFilesFunction::RunAsync() {
+  using extensions::api::file_manager_private::GetDriveFiles::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Convert the list of strings to a list of GURLs.
   for (size_t i = 0; i < params->file_urls.size(); ++i) {
     const base::FilePath path = file_manager::util::GetLocalPathFromURL(
         render_view_host(), GetProfile(), GURL(params->file_urls[i]));
     DCHECK(drive::util::IsUnderDriveMountPoint(path));
     base::FilePath drive_path = drive::util::ExtractDrivePath(path);
     remaining_drive_paths_.push(drive_path);
   }
 
   GetFileOrSendResponse();
   return true;
 }
 
-void FileBrowserPrivateGetDriveFilesFunction::GetFileOrSendResponse() {
+void FileManagerPrivateGetDriveFilesFunction::GetFileOrSendResponse() {
   // Send the response if all files are obtained.
   if (remaining_drive_paths_.empty()) {
-    results_ = extensions::api::file_browser_private::
+    results_ = extensions::api::file_manager_private::
         GetDriveFiles::Results::Create(local_paths_);
     SendResponse(true);
     return;
   }
 
   // Get the file on the top of the queue.
   base::FilePath drive_path = remaining_drive_paths_.front();
 
   drive::FileSystemInterface* file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled or not mounted.
     OnFileReady(drive::FILE_ERROR_FAILED, drive_path,
                 scoped_ptr<drive::ResourceEntry>());
     return;
   }
 
   file_system->GetFile(
       drive_path,
-      base::Bind(&FileBrowserPrivateGetDriveFilesFunction::OnFileReady, this));
+      base::Bind(&FileManagerPrivateGetDriveFilesFunction::OnFileReady, this));
 }
 
 
-void FileBrowserPrivateGetDriveFilesFunction::OnFileReady(
+void FileManagerPrivateGetDriveFilesFunction::OnFileReady(
     drive::FileError error,
     const base::FilePath& local_path,
     scoped_ptr<drive::ResourceEntry> entry) {
   base::FilePath drive_path = remaining_drive_paths_.front();
 
   if (error == drive::FILE_ERROR_OK) {
     local_paths_.push_back(local_path.AsUTF8Unsafe());
     DVLOG(1) << "Got " << drive_path.value() << " as " << local_path.value();
   } else {
     local_paths_.push_back("");
     DVLOG(1) << "Failed to get " << drive_path.value()
              << " with error code: " << error;
   }
 
   remaining_drive_paths_.pop();
 
   // Start getting the next file.
   GetFileOrSendResponse();
 }
 
-bool FileBrowserPrivateCancelFileTransfersFunction::RunAsync() {
-  using extensions::api::file_browser_private::CancelFileTransfers::Params;
+bool FileManagerPrivateCancelFileTransfersFunction::RunAsync() {
+  using extensions::api::file_manager_private::CancelFileTransfers::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::FindForProfile(GetProfile());
   if (!integration_service || !integration_service->IsMounted())
     return false;
 
   // Create the mapping from file path to job ID.
   drive::JobListInterface* job_list = integration_service->job_list();
   DCHECK(job_list);
   std::vector<drive::JobInfo> jobs = job_list->GetJobInfoList();
 
   typedef std::map<base::FilePath, std::vector<drive::JobID> > PathToIdMap;
   PathToIdMap path_to_id_map;
   for (size_t i = 0; i < jobs.size(); ++i) {
     if (drive::IsActiveFileTransferJobInfo(jobs[i]))
       path_to_id_map[jobs[i].file_path].push_back(jobs[i].job_id);
   }
 
   // Cancel by Job ID.
-  std::vector<linked_ptr<api::file_browser_private::
+  std::vector<linked_ptr<api::file_manager_private::
                          FileTransferCancelStatus> > responses;
   for (size_t i = 0; i < params->file_urls.size(); ++i) {
     base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
         render_view_host(), GetProfile(), GURL(params->file_urls[i]));
     if (file_path.empty())
       continue;
 
     DCHECK(drive::util::IsUnderDriveMountPoint(file_path));
     file_path = drive::util::ExtractDrivePath(file_path);
 
     // Cancel all the jobs for the file.
     PathToIdMap::iterator it = path_to_id_map.find(file_path);
     if (it != path_to_id_map.end()) {
       for (size_t i = 0; i < it->second.size(); ++i)
         job_list->CancelJob(it->second[i]);
     }
-    linked_ptr<api::file_browser_private::FileTransferCancelStatus> result(
-        new api::file_browser_private::FileTransferCancelStatus);
+    linked_ptr<api::file_manager_private::FileTransferCancelStatus> result(
+        new api::file_manager_private::FileTransferCancelStatus);
     result->canceled = it != path_to_id_map.end();
     // TODO(kinaba): simplify cancelFileTransfer() to take single URL each time,
     // and eliminate this field; it is just returning a copy of the argument.
     result->file_url = params->file_urls[i];
     responses.push_back(result);
   }
-  results_ = api::file_browser_private::CancelFileTransfers::Results::Create(
+  results_ = api::file_manager_private::CancelFileTransfers::Results::Create(
       responses);
   SendResponse(true);
   return true;
 }
 
-bool FileBrowserPrivateSearchDriveFunction::RunAsync() {
-  using extensions::api::file_browser_private::SearchDrive::Params;
+bool FileManagerPrivateSearchDriveFunction::RunAsync() {
+  using extensions::api::file_manager_private::SearchDrive::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled.
     return false;
   }
 
   file_system->Search(
       params->search_params.query, GURL(params->search_params.next_feed),
-      base::Bind(&FileBrowserPrivateSearchDriveFunction::OnSearch, this));
+      base::Bind(&FileManagerPrivateSearchDriveFunction::OnSearch, this));
   return true;
 }
 
-void FileBrowserPrivateSearchDriveFunction::OnSearch(
+void FileManagerPrivateSearchDriveFunction::OnSearch(
     drive::FileError error,
     const GURL& next_link,
     scoped_ptr<SearchResultInfoList> results) {
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   // Outlives the following conversion, since the pointer is bound to the
   // callback.
   DCHECK(results.get());
   const SearchResultInfoList& results_ref = *results.get();
 
   ConvertSearchResultInfoListToEntryDefinitionList(
       GetProfile(),
       extension_->id(),
       results_ref,
-      base::Bind(&FileBrowserPrivateSearchDriveFunction::OnEntryDefinitionList,
+      base::Bind(&FileManagerPrivateSearchDriveFunction::OnEntryDefinitionList,
                  this,
                  next_link,
                  base::Passed(&results)));
 }
 
-void FileBrowserPrivateSearchDriveFunction::OnEntryDefinitionList(
+void FileManagerPrivateSearchDriveFunction::OnEntryDefinitionList(
     const GURL& next_link,
     scoped_ptr<SearchResultInfoList> search_result_info_list,
     scoped_ptr<EntryDefinitionList> entry_definition_list) {
   DCHECK_EQ(search_result_info_list->size(), entry_definition_list->size());
   base::ListValue* entries = new base::ListValue();
 
   // Convert Drive files to something File API stack can understand.
   for (EntryDefinitionList::const_iterator it = entry_definition_list->begin();
        it != entry_definition_list->end();
        ++it) {
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString("fileSystemName", it->file_system_name);
     entry->SetString("fileSystemRoot", it->file_system_root_url);
     entry->SetString("fileFullPath", "/" + it->full_path.AsUTF8Unsafe());
     entry->SetBoolean("fileIsDirectory", it->is_directory);
     entries->Append(entry);
   }
 
   base::DictionaryValue* result = new base::DictionaryValue();
   result->Set("entries", entries);
   result->SetString("nextFeed", next_link.spec());
 
   SetResult(result);
   SendResponse(true);
 }
 
-bool FileBrowserPrivateSearchDriveMetadataFunction::RunAsync() {
-  using api::file_browser_private::SearchDriveMetadata::Params;
+bool FileManagerPrivateSearchDriveMetadataFunction::RunAsync() {
+  using api::file_manager_private::SearchDriveMetadata::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger) {
     logger->Log(logging::LOG_INFO,
                 "%s[%d] called. (types: '%s', maxResults: '%d')",
                 name().c_str(),
                 request_id(),
-                api::file_browser_private::ToString(
+                api::file_manager_private::ToString(
                     params->search_params.types).c_str(),
                 params->search_params.max_results);
   }
   set_log_on_completion(true);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled.
     return false;
   }
 
   int options = -1;
   switch (params->search_params.types) {
-    case api::file_browser_private::SEARCH_TYPE_EXCLUDE_DIRECTORIES:
+    case api::file_manager_private::SEARCH_TYPE_EXCLUDE_DIRECTORIES:
       options = drive::SEARCH_METADATA_EXCLUDE_DIRECTORIES;
       break;
-    case api::file_browser_private::SEARCH_TYPE_SHARED_WITH_ME:
+    case api::file_manager_private::SEARCH_TYPE_SHARED_WITH_ME:
       options = drive::SEARCH_METADATA_SHARED_WITH_ME;
       break;
-    case api::file_browser_private::SEARCH_TYPE_OFFLINE:
+    case api::file_manager_private::SEARCH_TYPE_OFFLINE:
       options = drive::SEARCH_METADATA_OFFLINE;
       break;
-    case api::file_browser_private::SEARCH_TYPE_ALL:
+    case api::file_manager_private::SEARCH_TYPE_ALL:
       options = drive::SEARCH_METADATA_ALL;
       break;
-    case api::file_browser_private::SEARCH_TYPE_NONE:
+    case api::file_manager_private::SEARCH_TYPE_NONE:
       break;
   }
   DCHECK_NE(options, -1);
 
   file_system->SearchMetadata(
       params->search_params.query,
       options,
       params->search_params.max_results,
-      base::Bind(&FileBrowserPrivateSearchDriveMetadataFunction::
+      base::Bind(&FileManagerPrivateSearchDriveMetadataFunction::
                      OnSearchMetadata, this));
   return true;
 }
 
-void FileBrowserPrivateSearchDriveMetadataFunction::OnSearchMetadata(
+void FileManagerPrivateSearchDriveMetadataFunction::OnSearchMetadata(
     drive::FileError error,
     scoped_ptr<drive::MetadataSearchResultVector> results) {
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   // Outlives the following conversion, since the pointer is bound to the
   // callback.
   DCHECK(results.get());
   const drive::MetadataSearchResultVector& results_ref = *results.get();
 
   ConvertSearchResultInfoListToEntryDefinitionList(
       GetProfile(),
       extension_->id(),
       results_ref,
       base::Bind(
-          &FileBrowserPrivateSearchDriveMetadataFunction::OnEntryDefinitionList,
+          &FileManagerPrivateSearchDriveMetadataFunction::OnEntryDefinitionList,
           this,
           base::Passed(&results)));
 }
 
-void FileBrowserPrivateSearchDriveMetadataFunction::OnEntryDefinitionList(
+void FileManagerPrivateSearchDriveMetadataFunction::OnEntryDefinitionList(
     scoped_ptr<drive::MetadataSearchResultVector> search_result_info_list,
     scoped_ptr<EntryDefinitionList> entry_definition_list) {
   DCHECK_EQ(search_result_info_list->size(), entry_definition_list->size());
   base::ListValue* results_list = new base::ListValue();
 
   // Convert Drive files to something File API stack can understand.  See
   // file_browser_handler_custom_bindings.cc and
-  // file_browser_private_custom_bindings.js for how this is magically
+  // file_manager_private_custom_bindings.js for how this is magically
   // converted to a FileEntry.
   for (size_t i = 0; i < entry_definition_list->size(); ++i) {
     base::DictionaryValue* result_dict = new base::DictionaryValue();
 
     // FileEntry fields.
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString(
         "fileSystemName", entry_definition_list->at(i).file_system_name);
     entry->SetString(
         "fileSystemRoot", entry_definition_list->at(i).file_system_root_url);
     entry->SetString(
         "fileFullPath",
         "/" + entry_definition_list->at(i).full_path.AsUTF8Unsafe());
     entry->SetBoolean("fileIsDirectory",
                       entry_definition_list->at(i).is_directory);
 
     result_dict->Set("entry", entry);
     result_dict->SetString(
         "highlightedBaseName",
         search_result_info_list->at(i).highlighted_base_name);
     results_list->Append(result_dict);
   }
 
   SetResult(results_list);
   SendResponse(true);
 }
 
-bool FileBrowserPrivateGetDriveConnectionStateFunction::RunSync() {
-  api::file_browser_private::DriveConnectionState result;
+bool FileManagerPrivateGetDriveConnectionStateFunction::RunSync() {
+  api::file_manager_private::DriveConnectionState result;
 
   switch (drive::util::GetDriveConnectionStatus(GetProfile())) {
     case drive::util::DRIVE_DISCONNECTED_NOSERVICE:
       result.type = kDriveConnectionTypeOffline;
       result.reason.reset(new std::string(kDriveConnectionReasonNoService));
       break;
     case drive::util::DRIVE_DISCONNECTED_NONETWORK:
       result.type = kDriveConnectionTypeOffline;
       result.reason.reset(new std::string(kDriveConnectionReasonNoNetwork));
       break;
     case drive::util::DRIVE_DISCONNECTED_NOTREADY:
       result.type = kDriveConnectionTypeOffline;
       result.reason.reset(new std::string(kDriveConnectionReasonNotReady));
       break;
     case drive::util::DRIVE_CONNECTED_METERED:
       result.type = kDriveConnectionTypeMetered;
       break;
     case drive::util::DRIVE_CONNECTED:
       result.type = kDriveConnectionTypeOnline;
       break;
   }
 
-  results_ = api::file_browser_private::GetDriveConnectionState::Results::
+  results_ = api::file_manager_private::GetDriveConnectionState::Results::
       Create(result);
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger)
     logger->Log(logging::LOG_INFO, "%s succeeded.", name().c_str());
   return true;
 }
 
-bool FileBrowserPrivateRequestAccessTokenFunction::RunAsync() {
-  using extensions::api::file_browser_private::RequestAccessToken::Params;
+bool FileManagerPrivateRequestAccessTokenFunction::RunAsync() {
+  using extensions::api::file_manager_private::RequestAccessToken::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::DriveServiceInterface* const drive_service =
       drive::util::GetDriveServiceByProfile(GetProfile());
 
   if (!drive_service) {
     // DriveService is not available.
     SetResult(new base::StringValue(""));
     SendResponse(true);
     return true;
   }
 
   // If refreshing is requested, then clear the token to refetch it.
   if (params->refresh)
     drive_service->ClearAccessToken();
 
   // Retrieve the cached auth token (if available), otherwise the AuthService
   // instance will try to refetch it.
   drive_service->RequestAccessToken(
-      base::Bind(&FileBrowserPrivateRequestAccessTokenFunction::
+      base::Bind(&FileManagerPrivateRequestAccessTokenFunction::
                       OnAccessTokenFetched, this));
   return true;
 }
 
-void FileBrowserPrivateRequestAccessTokenFunction::OnAccessTokenFetched(
+void FileManagerPrivateRequestAccessTokenFunction::OnAccessTokenFetched(
     google_apis::GDataErrorCode code,
     const std::string& access_token) {
   SetResult(new base::StringValue(access_token));
   SendResponse(true);
 }
 
-bool FileBrowserPrivateGetShareUrlFunction::RunAsync() {
-  using extensions::api::file_browser_private::GetShareUrl::Params;
+bool FileManagerPrivateGetShareUrlFunction::RunAsync() {
+  using extensions::api::file_manager_private::GetShareUrl::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), GetProfile(), GURL(params->url));
   DCHECK(drive::util::IsUnderDriveMountPoint(path));
 
   const base::FilePath drive_path = drive::util::ExtractDrivePath(path);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled.
     return false;
   }
 
   file_system->GetShareUrl(
       drive_path,
       GURL("chrome-extension://" + extension_id()),  // embed origin
-      base::Bind(&FileBrowserPrivateGetShareUrlFunction::OnGetShareUrl, this));
+      base::Bind(&FileManagerPrivateGetShareUrlFunction::OnGetShareUrl, this));
   return true;
 }
 
-void FileBrowserPrivateGetShareUrlFunction::OnGetShareUrl(
+void FileManagerPrivateGetShareUrlFunction::OnGetShareUrl(
     drive::FileError error,
     const GURL& share_url) {
   if (error != drive::FILE_ERROR_OK) {
     SetError("Share Url for this item is not available.");
     SendResponse(false);
     return;
   }
 
   SetResult(new base::StringValue(share_url.spec()));
   SendResponse(true);
 }
 
-bool FileBrowserPrivateRequestDriveShareFunction::RunAsync() {
-  using extensions::api::file_browser_private::RequestDriveShare::Params;
+bool FileManagerPrivateRequestDriveShareFunction::RunAsync() {
+  using extensions::api::file_manager_private::RequestDriveShare::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), GetProfile(), GURL(params->url));
   const base::FilePath drive_path = drive::util::ExtractDrivePath(path);
   Profile* const owner_profile = drive::util::ExtractProfileFromPath(path);
 
   if (!owner_profile)
     return false;
 
   drive::FileSystemInterface* const owner_file_system =
       drive::util::GetFileSystemByProfile(owner_profile);
   if (!owner_file_system)
     return false;
 
   const user_manager::User* const user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(GetProfile());
   if (!user || !user->is_logged_in())
     return false;
 
   google_apis::drive::PermissionRole role =
       google_apis::drive::PERMISSION_ROLE_READER;
   switch (params->share_type) {
-    case api::file_browser_private::DRIVE_SHARE_TYPE_NONE:
+    case api::file_manager_private::DRIVE_SHARE_TYPE_NONE:
       NOTREACHED();
       return false;
-    case api::file_browser_private::DRIVE_SHARE_TYPE_CAN_EDIT:
+    case api::file_manager_private::DRIVE_SHARE_TYPE_CAN_EDIT:
       role = google_apis::drive::PERMISSION_ROLE_WRITER;
       break;
-    case api::file_browser_private::DRIVE_SHARE_TYPE_CAN_COMMENT:
+    case api::file_manager_private::DRIVE_SHARE_TYPE_CAN_COMMENT:
       role = google_apis::drive::PERMISSION_ROLE_COMMENTER;
       break;
-    case api::file_browser_private::DRIVE_SHARE_TYPE_CAN_VIEW:
+    case api::file_manager_private::DRIVE_SHARE_TYPE_CAN_VIEW:
       role = google_apis::drive::PERMISSION_ROLE_READER;
       break;
   }
 
   // Share |drive_path| in |owner_file_system| to |user->email()|.
   owner_file_system->AddPermission(
       drive_path,
       user->email(),
       role,
-      base::Bind(&FileBrowserPrivateRequestDriveShareFunction::OnAddPermission,
+      base::Bind(&FileManagerPrivateRequestDriveShareFunction::OnAddPermission,
                  this));
   return true;
 }
 
-void FileBrowserPrivateRequestDriveShareFunction::OnAddPermission(
+void FileManagerPrivateRequestDriveShareFunction::OnAddPermission(
     drive::FileError error) {
   SendResponse(error == drive::FILE_ERROR_OK);
 }
 
-FileBrowserPrivateGetDownloadUrlFunction::
-    FileBrowserPrivateGetDownloadUrlFunction() {
+FileManagerPrivateGetDownloadUrlFunction::
+    FileManagerPrivateGetDownloadUrlFunction() {
 }
 
-FileBrowserPrivateGetDownloadUrlFunction::
-    ~FileBrowserPrivateGetDownloadUrlFunction() {
+FileManagerPrivateGetDownloadUrlFunction::
+    ~FileManagerPrivateGetDownloadUrlFunction() {
 }
 
-bool FileBrowserPrivateGetDownloadUrlFunction::RunAsync() {
-  using extensions::api::file_browser_private::GetShareUrl::Params;
+bool FileManagerPrivateGetDownloadUrlFunction::RunAsync() {
+  using extensions::api::file_manager_private::GetShareUrl::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Start getting the file info.
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled or not mounted.
     SetError("Drive is disabled or not mounted.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     return false;
   }
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), GetProfile(), GURL(params->url));
   if (!drive::util::IsUnderDriveMountPoint(path)) {
     SetError("The given file is not in Drive.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     return false;
   }
   base::FilePath file_path = drive::util::ExtractDrivePath(path);
 
   file_system->GetResourceEntry(
       file_path,
-      base::Bind(&FileBrowserPrivateGetDownloadUrlFunction::OnGetResourceEntry,
+      base::Bind(&FileManagerPrivateGetDownloadUrlFunction::OnGetResourceEntry,
                  this));
   return true;
 }
 
-void FileBrowserPrivateGetDownloadUrlFunction::OnGetResourceEntry(
+void FileManagerPrivateGetDownloadUrlFunction::OnGetResourceEntry(
     drive::FileError error,
     scoped_ptr<drive::ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != drive::FILE_ERROR_OK) {
     SetError("Download Url for this item is not available.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     SendResponse(false);
     return;
   }
 
   download_url_ =
       google_apis::DriveApiUrlGenerator::kBaseDownloadUrlForProduction +
       entry->resource_id();
 
   ProfileOAuth2TokenService* oauth2_token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(GetProfile());
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(GetProfile());
   const std::string& account_id = signin_manager->GetAuthenticatedAccountId();
   std::vector<std::string> scopes;
   scopes.push_back("https://www.googleapis.com/auth/drive.readonly");
 
   auth_service_.reset(
       new google_apis::AuthService(oauth2_token_service,
                                    account_id,
                                    GetProfile()->GetRequestContext(),
                                    scopes));
   auth_service_->StartAuthentication(base::Bind(
-      &FileBrowserPrivateGetDownloadUrlFunction::OnTokenFetched, this));
+      &FileManagerPrivateGetDownloadUrlFunction::OnTokenFetched, this));
 }
 
-void FileBrowserPrivateGetDownloadUrlFunction::OnTokenFetched(
+void FileManagerPrivateGetDownloadUrlFunction::OnTokenFetched(
     google_apis::GDataErrorCode code,
     const std::string& access_token) {
   if (code != google_apis::HTTP_SUCCESS) {
     SetError("Not able to fetch the token.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     SendResponse(false);
     return;
   }
 
   const std::string url = download_url_ + "?access_token=" + access_token;
   SetResult(new base::StringValue(url));
 
   SendResponse(true);
 }
 
 }  // namespace extensions