Files.app: Rename the FileBrowserPrivateAPI's functions.

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/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
@@ skipping 47 matching lines @@
 
   property_dict->SetString("thumbnailUrl", file_specific_info.thumbnail_url());
   property_dict->SetBoolean("isHosted",
                             file_specific_info.is_hosted_document());
   property_dict->SetString("contentMimeType",
                            file_specific_info.content_mime_type());
 }
 
 }  // namespace
 
-GetDriveEntryPropertiesFunction::GetDriveEntryPropertiesFunction() {
+FileBrowserPrivateGetDriveEntryPropertiesFunction::
+    FileBrowserPrivateGetDriveEntryPropertiesFunction() {
 }
 
-GetDriveEntryPropertiesFunction::~GetDriveEntryPropertiesFunction() {
+FileBrowserPrivateGetDriveEntryPropertiesFunction::
+    ~FileBrowserPrivateGetDriveEntryPropertiesFunction() {
 }
 
-bool GetDriveEntryPropertiesFunction::RunImpl() {
+bool FileBrowserPrivateGetDriveEntryPropertiesFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string file_url_str;
   if (args_->GetSize() != 1 || !args_->GetString(0, &file_url_str))
     return false;
 
   GURL file_url = GURL(file_url_str);
   file_path_ = drive::util::ExtractDrivePath(
       file_manager::util::GetLocalPathFromURL(
           render_view_host(), profile(), file_url));
 
   properties_.reset(new base::DictionaryValue);
   properties_->SetString("fileUrl", file_url.spec());
 
   // Start getting the file info.
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service) {
     CompleteGetFileProperties(drive::FILE_ERROR_FAILED);
     return true;
   }
 
   integration_service->file_system()->GetResourceEntryByPath(
       file_path_,
-      base::Bind(&GetDriveEntryPropertiesFunction::OnGetFileInfo, this));
+      base::Bind(&FileBrowserPrivateGetDriveEntryPropertiesFunction::
+                     OnGetFileInfo, this));
   return true;
 }
 
-void GetDriveEntryPropertiesFunction::OnGetFileInfo(
+void FileBrowserPrivateGetDriveEntryPropertiesFunction::OnGetFileInfo(
     drive::FileError error,
     scoped_ptr<drive::ResourceEntry> entry) {
   DCHECK(properties_);
 
   if (error != drive::FILE_ERROR_OK) {
     CompleteGetFileProperties(error);
     return;
   }
   DCHECK(entry);
 
@@ skipping 38 matching lines @@
         const GURL doc_icon =
             drive::util::FindPreferredIcon(app_info->document_icons,
                                            drive::util::kPreferredIconSize);
         properties_->SetString("customIconUrl", doc_icon.spec());
       }
     }
   }
 
   integration_service->file_system()->GetCacheEntryByPath(
       file_path_,
-      base::Bind(&GetDriveEntryPropertiesFunction::CacheStateReceived, this));
+      base::Bind(&FileBrowserPrivateGetDriveEntryPropertiesFunction::
+                     CacheStateReceived, this));
 }
 
-void GetDriveEntryPropertiesFunction::CacheStateReceived(
+void FileBrowserPrivateGetDriveEntryPropertiesFunction::CacheStateReceived(
     bool /* success */,
     const drive::FileCacheEntry& cache_entry) {
   // In case of an error (i.e. success is false), cache_entry.is_*() all
   // returns false.
   properties_->SetBoolean("isPinned", cache_entry.is_pinned());
   properties_->SetBoolean("isPresent", cache_entry.is_present());
   properties_->SetBoolean("isDirty", cache_entry.is_dirty());
 
   CompleteGetFileProperties(drive::FILE_ERROR_OK);
 }
 
-void GetDriveEntryPropertiesFunction::CompleteGetFileProperties(
-    drive::FileError error) {
+void FileBrowserPrivateGetDriveEntryPropertiesFunction::
+    CompleteGetFileProperties(drive::FileError error) {
   if (error != drive::FILE_ERROR_OK)
     properties_->SetInteger("errorCode", error);
   SetResult(properties_.release());
   SendResponse(true);
 }
 
-PinDriveFileFunction::PinDriveFileFunction() {
+FileBrowserPrivatePinDriveFileFunction::
+    FileBrowserPrivatePinDriveFileFunction() {
 }
 
-PinDriveFileFunction::~PinDriveFileFunction() {
+FileBrowserPrivatePinDriveFileFunction::
+    ~FileBrowserPrivatePinDriveFileFunction() {
 }
 
-bool PinDriveFileFunction::RunImpl() {
+bool FileBrowserPrivatePinDriveFileFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string url;
   bool set_pin = false;
   if (args_->GetSize() != 2 ||
       !args_->GetString(0, &url) ||
       !args_->GetBoolean(1, &set_pin))
     return false;
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   drive::FileSystemInterface* file_system =
       integration_service ? integration_service->file_system() : NULL;
   if (!file_system)  // |file_system| is NULL if Drive is disabled.
     return false;
 
   base::FilePath drive_path =
       drive::util::ExtractDrivePath(file_manager::util::GetLocalPathFromURL(
           render_view_host(), profile(), GURL(url)));
   if (set_pin) {
     file_system->Pin(drive_path,
-                     base::Bind(&PinDriveFileFunction::OnPinStateSet, this));
+                     base::Bind(&FileBrowserPrivatePinDriveFileFunction::
+                                    OnPinStateSet, this));
   } else {
     file_system->Unpin(drive_path,
-                       base::Bind(&PinDriveFileFunction::OnPinStateSet, this));
+                       base::Bind(&FileBrowserPrivatePinDriveFileFunction::
+                                      OnPinStateSet, this));
   }
   return true;
 }
 
-void PinDriveFileFunction::OnPinStateSet(drive::FileError error) {
+void FileBrowserPrivatePinDriveFileFunction::
+    OnPinStateSet(drive::FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == drive::FILE_ERROR_OK) {
     SendResponse(true);
   } else {
     error_ = drive::FileErrorToString(error);
     SendResponse(false);
   }
 }
 
-GetDriveFilesFunction::GetDriveFilesFunction()
-    : local_paths_(NULL) {
+FileBrowserPrivateGetDriveFilesFunction::
+    FileBrowserPrivateGetDriveFilesFunction() : local_paths_(NULL) {
 }
 
-GetDriveFilesFunction::~GetDriveFilesFunction() {
+FileBrowserPrivateGetDriveFilesFunction::
+    ~FileBrowserPrivateGetDriveFilesFunction() {
 }
 
-bool GetDriveFilesFunction::RunImpl() {
+bool FileBrowserPrivateGetDriveFilesFunction::RunImpl() {
   ListValue* file_urls_as_strings = NULL;
   if (!args_->GetList(0, &file_urls_as_strings))
     return false;
 
   // Convert the list of strings to a list of GURLs.
   for (size_t i = 0; i < file_urls_as_strings->GetSize(); ++i) {
     std::string file_url_as_string;
     if (!file_urls_as_strings->GetString(i, &file_url_as_string))
       return false;
     const base::FilePath path = file_manager::util::GetLocalPathFromURL(
         render_view_host(), profile(), GURL(file_url_as_string));
     DCHECK(drive::util::IsUnderDriveMountPoint(path));
     base::FilePath drive_path = drive::util::ExtractDrivePath(path);
     remaining_drive_paths_.push(drive_path);
   }
 
   local_paths_ = new ListValue;
   GetFileOrSendResponse();
   return true;
 }
 
-void GetDriveFilesFunction::GetFileOrSendResponse() {
+void FileBrowserPrivateGetDriveFilesFunction::GetFileOrSendResponse() {
   // Send the response if all files are obtained.
   if (remaining_drive_paths_.empty()) {
     SetResult(local_paths_);
     SendResponse(true);
     return;
   }
 
   // Get the file on the top of the queue.
   base::FilePath drive_path = remaining_drive_paths_.front();
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service) {
     OnFileReady(drive::FILE_ERROR_FAILED, drive_path,
                 scoped_ptr<drive::ResourceEntry>());
     return;
   }
 
   integration_service->file_system()->GetFileByPath(
       drive_path,
-      base::Bind(&GetDriveFilesFunction::OnFileReady, this));
+      base::Bind(&FileBrowserPrivateGetDriveFilesFunction::OnFileReady, this));
 }
 
 
-void GetDriveFilesFunction::OnFileReady(
+void FileBrowserPrivateGetDriveFilesFunction::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_->Append(new base::StringValue(local_path.value()));
     DVLOG(1) << "Got " << drive_path.value() << " as " << local_path.value();
 
     // TODO(benchan): If the file is a hosted document, a temporary JSON file
     // is created to represent the document. The JSON file is not cached and
     // should be deleted after use. We need to somehow communicate with
     // file_manager.js to manage the lifetime of the temporary file.
     // See crosbug.com/28058.
   } else {
     local_paths_->Append(new base::StringValue(""));
     DVLOG(1) << "Failed to get " << drive_path.value()
              << " with error code: " << error;
   }
 
   remaining_drive_paths_.pop();
 
   // Start getting the next file.
   GetFileOrSendResponse();
 }
 
-CancelFileTransfersFunction::CancelFileTransfersFunction() {
+FileBrowserPrivateCancelFileTransfersFunction::
+    FileBrowserPrivateCancelFileTransfersFunction() {
 }
 
-CancelFileTransfersFunction::~CancelFileTransfersFunction() {
+FileBrowserPrivateCancelFileTransfersFunction::
+    ~FileBrowserPrivateCancelFileTransfersFunction() {
 }
 
-bool CancelFileTransfersFunction::RunImpl() {
+bool FileBrowserPrivateCancelFileTransfersFunction::RunImpl() {
   ListValue* url_list = NULL;
   if (!args_->GetList(0, &url_list))
     return false;
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service)
     return false;
 
@@ skipping 34 matching lines @@
     // TODO(kinaba): simplify cancelFileTransfer() to take single URL each time,
     // and eliminate this field; it is just returning a copy of the argument.
     result->SetString("fileUrl", url_as_string);
     responses->Append(result.release());
   }
   SetResult(responses.release());
   SendResponse(true);
   return true;
 }
 
-SearchDriveFunction::SearchDriveFunction() {
+FileBrowserPrivateSearchDriveFunction::
+    FileBrowserPrivateSearchDriveFunction() {
 }
 
-SearchDriveFunction::~SearchDriveFunction() {
+FileBrowserPrivateSearchDriveFunction::
+    ~FileBrowserPrivateSearchDriveFunction() {
 }
 
-bool SearchDriveFunction::RunImpl() {
+bool FileBrowserPrivateSearchDriveFunction::RunImpl() {
   DictionaryValue* search_params;
   if (!args_->GetDictionary(0, &search_params))
     return false;
 
   std::string query;
   if (!search_params->GetString("query", &query))
     return false;
 
   std::string next_feed;
   if (!search_params->GetString("nextFeed", &next_feed))
     return false;
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service || !integration_service->file_system())
     return false;
 
   integration_service->file_system()->Search(
       query, next_feed,
-      base::Bind(&SearchDriveFunction::OnSearch, this));
+      base::Bind(&FileBrowserPrivateSearchDriveFunction::OnSearch, this));
   return true;
 }
 
-void SearchDriveFunction::OnSearch(
+void FileBrowserPrivateSearchDriveFunction::OnSearch(
     drive::FileError error,
     const std::string& next_feed,
     scoped_ptr<std::vector<drive::SearchResultInfo> > results) {
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   DCHECK(results.get());
 
@@ skipping 17 matching lines @@
   }
 
   base::DictionaryValue* result = new DictionaryValue();
   result->Set("entries", entries);
   result->SetString("nextFeed", next_feed);
 
   SetResult(result);
   SendResponse(true);
 }
 
-SearchDriveMetadataFunction::SearchDriveMetadataFunction() {
+FileBrowserPrivateSearchDriveMetadataFunction::
+    FileBrowserPrivateSearchDriveMetadataFunction() {
 }
 
-SearchDriveMetadataFunction::~SearchDriveMetadataFunction() {
+FileBrowserPrivateSearchDriveMetadataFunction::
+    ~FileBrowserPrivateSearchDriveMetadataFunction() {
 }
 
-bool SearchDriveMetadataFunction::RunImpl() {
+bool FileBrowserPrivateSearchDriveMetadataFunction::RunImpl() {
   DictionaryValue* search_params;
   if (!args_->GetDictionary(0, &search_params))
     return false;
 
   std::string query;
   if (!search_params->GetString("query", &query))
     return false;
 
   std::string types;
   if (!search_params->GetString("types", &types))
@@ skipping 25 matching lines @@
     options = drive::SEARCH_METADATA_SHARED_WITH_ME;
   else if (types == "OFFLINE")
     options = drive::SEARCH_METADATA_OFFLINE;
   else
     DCHECK_EQ("ALL", types);
 
   integration_service->file_system()->SearchMetadata(
       query,
       options,
       max_results,
-      base::Bind(&SearchDriveMetadataFunction::OnSearchMetadata, this));
+      base::Bind(&FileBrowserPrivateSearchDriveMetadataFunction::
+                     OnSearchMetadata, this));
   return true;
 }
 
-void SearchDriveMetadataFunction::OnSearchMetadata(
+void FileBrowserPrivateSearchDriveMetadataFunction::OnSearchMetadata(
     drive::FileError error,
     scoped_ptr<drive::MetadataSearchResultVector> results) {
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   DCHECK(results.get());
 
   base::ListValue* results_list = new ListValue();
@@ skipping 22 matching lines @@
     result_dict->Set("entry", entry);
     result_dict->SetString("highlightedBaseName",
                            results->at(i).highlighted_base_name);
     results_list->Append(result_dict);
   }
 
   SetResult(results_list);
   SendResponse(true);
 }
 
-ClearDriveCacheFunction::ClearDriveCacheFunction() {
+FileBrowserPrivateClearDriveCacheFunction::
+    FileBrowserPrivateClearDriveCacheFunction() {
 }
 
-ClearDriveCacheFunction::~ClearDriveCacheFunction() {
+FileBrowserPrivateClearDriveCacheFunction::
+    ~FileBrowserPrivateClearDriveCacheFunction() {
 }
 
-bool ClearDriveCacheFunction::RunImpl() {
+bool FileBrowserPrivateClearDriveCacheFunction::RunImpl() {
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service || !integration_service->file_system())
     return false;
 
   // TODO(yoshiki): Receive a callback from JS-side and pass it to
   // ClearCacheAndRemountFileSystem(). http://crbug.com/140511
   integration_service->ClearCacheAndRemountFileSystem(
       base::Bind(&DoNothingWithBool));
 
   SendResponse(true);
   return true;
 }
 
-GetDriveConnectionStateFunction::GetDriveConnectionStateFunction() {
+FileBrowserPrivateGetDriveConnectionStateFunction::
+    FileBrowserPrivateGetDriveConnectionStateFunction() {
 }
 
-GetDriveConnectionStateFunction::~GetDriveConnectionStateFunction() {
+FileBrowserPrivateGetDriveConnectionStateFunction::
+    ~FileBrowserPrivateGetDriveConnectionStateFunction() {
 }
 
-bool GetDriveConnectionStateFunction::RunImpl() {
+bool FileBrowserPrivateGetDriveConnectionStateFunction::RunImpl() {
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
   scoped_ptr<ListValue> reasons(new ListValue());
 
   std::string type_string;
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
 
   bool ready = integration_service &&
       integration_service->drive_service()->CanSendRequest();
   bool is_connection_cellular =
@@ skipping 17 matching lines @@
   }
 
   value->SetString("type", type_string);
   value->Set("reasons", reasons.release());
   SetResult(value.release());
 
   drive::util::Log(logging::LOG_INFO, "%s succeeded.", name().c_str());
   return true;
 }
 
-RequestAccessTokenFunction::RequestAccessTokenFunction() {
+FileBrowserPrivateRequestAccessTokenFunction::
+    FileBrowserPrivateRequestAccessTokenFunction() {
 }
 
-RequestAccessTokenFunction::~RequestAccessTokenFunction() {
+FileBrowserPrivateRequestAccessTokenFunction::
+    ~FileBrowserPrivateRequestAccessTokenFunction() {
 }
 
-bool RequestAccessTokenFunction::RunImpl() {
+bool FileBrowserPrivateRequestAccessTokenFunction::RunImpl() {
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   bool refresh;
   args_->GetBoolean(0, &refresh);
 
   if (!integration_service) {
     SetResult(new base::StringValue(""));
     SendResponse(true);
     return true;
   }
 
   // If refreshing is requested, then clear the token to refetch it.
   if (refresh)
     integration_service->drive_service()->ClearAccessToken();
 
   // Retrieve the cached auth token (if available), otherwise the AuthService
   // instance will try to refetch it.
   integration_service->drive_service()->RequestAccessToken(
-      base::Bind(&RequestAccessTokenFunction::OnAccessTokenFetched, this));
+      base::Bind(&FileBrowserPrivateRequestAccessTokenFunction::
+                      OnAccessTokenFetched, this));
   return true;
 }
 
-void RequestAccessTokenFunction::OnAccessTokenFetched(
-    google_apis::GDataErrorCode code, const std::string& access_token) {
+void FileBrowserPrivateRequestAccessTokenFunction::OnAccessTokenFetched(
+    google_apis::GDataErrorCode code,
+    const std::string& access_token) {
   SetResult(new base::StringValue(access_token));
   SendResponse(true);
 }
 
-GetShareUrlFunction::GetShareUrlFunction() {
+FileBrowserPrivateGetShareUrlFunction::FileBrowserPrivateGetShareUrlFunction() {
 }
 
-GetShareUrlFunction::~GetShareUrlFunction() {
+FileBrowserPrivateGetShareUrlFunction::
+    ~FileBrowserPrivateGetShareUrlFunction() {
 }
 
-bool GetShareUrlFunction::RunImpl() {
+bool FileBrowserPrivateGetShareUrlFunction::RunImpl() {
   std::string file_url;
   if (!args_->GetString(0, &file_url))
     return false;
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(file_url));
   DCHECK(drive::util::IsUnderDriveMountPoint(path));
 
   base::FilePath drive_path = drive::util::ExtractDrivePath(path);
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service)
     return false;
 
   integration_service->file_system()->GetShareUrl(
       drive_path,
       file_manager::util::GetFileManagerBaseUrl(),  // embed origin
-      base::Bind(&GetShareUrlFunction::OnGetShareUrl, this));
+      base::Bind(&FileBrowserPrivateGetShareUrlFunction::OnGetShareUrl, this));
   return true;
 }
 
 
-void GetShareUrlFunction::OnGetShareUrl(drive::FileError error,
-                                        const GURL& share_url) {
+void FileBrowserPrivateGetShareUrlFunction::OnGetShareUrl(
+    drive::FileError error,
+    const GURL& share_url) {
   if (error != drive::FILE_ERROR_OK) {
     error_ = "Share Url for this item is not available.";
     SendResponse(false);
     return;
   }
 
   SetResult(new base::StringValue(share_url.spec()));
   SendResponse(true);
 }
 
 }  // namespace extensions