Files.app: Let the file browser private filesystem APIs use the auto-generated helper classes.

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 279 matching lines @@
     scoped_refptr<fileapi::FileSystemContext> file_system_context,
     fileapi::FileSystemOperationRunner::OperationID operation_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_context->operation_runner()->Cancel(
       operation_id, base::Bind(&OnCopyCancelled));
 }
 
 }  // namespace
 
-FileBrowserPrivateRequestFileSystemFunction::
-    FileBrowserPrivateRequestFileSystemFunction() {
-}
-
-FileBrowserPrivateRequestFileSystemFunction::
-    ~FileBrowserPrivateRequestFileSystemFunction() {
-}
-
 void FileBrowserPrivateRequestFileSystemFunction::DidOpenFileSystem(
     scoped_refptr<fileapi::FileSystemContext> file_system_context,
     base::PlatformFileError result,
     const std::string& name,
     const GURL& root_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (result != base::PLATFORM_FILE_OK) {
     DidFail(result);
     return;
@@ skipping 98 matching lines @@
       origin_url,
       fileapi::kFileSystemTypeExternal,
       fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
       base::Bind(&FileBrowserPrivateRequestFileSystemFunction::
                      DidOpenFileSystem,
                  this,
                  file_system_context));
   return true;
 }
 
-FileWatchFunctionBase::FileWatchFunctionBase() {
-}
-
-FileWatchFunctionBase::~FileWatchFunctionBase() {
-}
-
 void FileWatchFunctionBase::Respond(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetResult(Value::CreateBooleanValue(success));
   SendResponse(success);
 }
 
 bool FileWatchFunctionBase::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 14 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;
 }
 
-FileBrowserPrivateAddFileWatchFunction::
-    FileBrowserPrivateAddFileWatchFunction() {
-}
-
-FileBrowserPrivateAddFileWatchFunction::
-    ~FileBrowserPrivateAddFileWatchFunction() {
-}
-
 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(&FileBrowserPrivateAddFileWatchFunction::Respond, this));
 }
 
-FileBrowserPrivateRemoveFileWatchFunction::
-    FileBrowserPrivateRemoveFileWatchFunction() {
-}
-
-FileBrowserPrivateRemoveFileWatchFunction::
-    ~FileBrowserPrivateRemoveFileWatchFunction() {
-}
-
 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);
 }
 
-FileBrowserPrivateSetLastModifiedFunction::
-    FileBrowserPrivateSetLastModifiedFunction() {
-}
-
-FileBrowserPrivateSetLastModifiedFunction::
-    ~FileBrowserPrivateSetLastModifiedFunction() {
-}
-
 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;
+  using extensions::api::file_browser_private::SetLastModified::Params;
+  const scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
 
   base::FilePath local_path = file_manager::util::GetLocalPathFromURL(
-      render_view_host(), profile(), GURL(file_url));
+      render_view_host(), profile(), GURL(params->file_url));
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&SetLastModifiedOnBlockingPool,
                  local_path,
-                 strtoul(timestamp.c_str(), NULL, 0)),
+                 strtoul(params->last_modified.c_str(), NULL, 0)),
       base::Bind(&FileBrowserPrivateSetLastModifiedFunction::SendResponse,
                  this));
   return true;
 }
 
-FileBrowserPrivateGetSizeStatsFunction::
-    FileBrowserPrivateGetSizeStatsFunction() {
-}
-
-FileBrowserPrivateGetSizeStatsFunction::
-    ~FileBrowserPrivateGetSizeStatsFunction() {
-}
-
 bool FileBrowserPrivateGetSizeStatsFunction::RunImpl() {
-  if (args_->GetSize() != 1) {
-    return false;
-  }
-
-  std::string mount_url;
-  if (!args_->GetString(0, &mount_url))
-    return false;
+  using extensions::api::file_browser_private::GetSizeStats::Params;
+  const scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
 
   base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
-      render_view_host(), profile(), GURL(mount_url));
+      render_view_host(), profile(), GURL(params->mount_path));
   if (file_path.empty())
     return false;
 
   if (file_path == drive::util::GetDriveMountPointPath()) {
     drive::FileSystemInterface* file_system =
         drive::util::GetFileSystemByProfile(profile());
     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().
@@ skipping 43 matching lines @@
     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);
 }
 
-FileBrowserPrivateGetVolumeMetadataFunction::
-    FileBrowserPrivateGetVolumeMetadataFunction() {
-}
-
-FileBrowserPrivateGetVolumeMetadataFunction::
-    ~FileBrowserPrivateGetVolumeMetadataFunction() {
-}
-
 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;
-  }
+  using extensions::api::file_browser_private::GetVolumeMetadata::Params;
+  const scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
 
   base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
-      render_view_host(), profile(), GURL(volume_mount_url));
+      render_view_host(), profile(), GURL(params->mount_url));
   if (file_path.empty()) {
     error_ = "Invalid mount path.";
     return false;
   }
 
   results_.reset();
 
   base::FilePath home_path;
   // TODO(hidehiko): Return the volume info for Drive File System.
   if (PathService::Get(base::DIR_HOME, &home_path) &&
       file_path == home_path.AppendASCII("Downloads")) {
     // Return simple (fake) volume metadata for Downloads volume.
     SetResult(CreateDownloadsVolumeMetadata());
   } else {
     const DiskMountManager::Disk* volume = GetVolumeAsDisk(file_path.value());
     if (volume)
       SetResult(CreateValueFromDisk(profile_, extension_->id(), volume));
   }
 
   SendResponse(true);
   return true;
 }
 
-FileBrowserPrivateValidatePathNameLengthFunction::
-    FileBrowserPrivateValidatePathNameLengthFunction() {
-}
-
-FileBrowserPrivateValidatePathNameLengthFunction::
-    ~FileBrowserPrivateValidatePathNameLengthFunction() {
-}
-
 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;
+  using extensions::api::file_browser_private::ValidatePathNameLength::Params;
+  const scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
 
   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)));
+      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() == 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(&FileBrowserPrivateValidatePathNameLengthFunction::
                      OnFilePathLimitRetrieved,
-                 this, name.size()));
+                 this, params->name.size()));
   return true;
 }
 
 void FileBrowserPrivateValidatePathNameLengthFunction::OnFilePathLimitRetrieved(
     size_t current_length,
     size_t max_length) {
   SetResult(new base::FundamentalValue(current_length <= max_length));
   SendResponse(true);
 }
 
-FileBrowserPrivateFormatDeviceFunction::
-    FileBrowserPrivateFormatDeviceFunction() {
-}
-
-FileBrowserPrivateFormatDeviceFunction::
-    ~FileBrowserPrivateFormatDeviceFunction() {
-}
-
 bool FileBrowserPrivateFormatDeviceFunction::RunImpl() {
-  if (args_->GetSize() != 1) {
-    return false;
-  }
-
-  std::string volume_file_url;
-  if (!args_->GetString(0, &volume_file_url)) {
-    NOTREACHED();
-    return false;
-  }
+  using extensions::api::file_browser_private::FormatDevice::Params;
+  const scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
 
   base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
-      render_view_host(), profile(), GURL(volume_file_url));
+      render_view_host(), profile(), GURL(params->mount_path));
   if (file_path.empty())
     return false;
 
   DiskMountManager::GetInstance()->FormatMountedDevice(file_path.value());
   SendResponse(true);
   return true;
 }
 
-FileBrowserPrivateStartCopyFunction::FileBrowserPrivateStartCopyFunction() {
-}
-
-FileBrowserPrivateStartCopyFunction::~FileBrowserPrivateStartCopyFunction() {
-}
-
 bool FileBrowserPrivateStartCopyFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   using  extensions::api::file_browser_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_ = base::IntToString(fileapi::PlatformFileErrorToWebFileError(
@@ skipping 26 matching lines @@
 }
 
 void FileBrowserPrivateStartCopyFunction::RunAfterStartCopy(
     int operation_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetResult(Value::CreateIntegerValue(operation_id));
   SendResponse(true);
 }
 
-FileBrowserPrivateCancelCopyFunction::FileBrowserPrivateCancelCopyFunction() {
-}
-
-FileBrowserPrivateCancelCopyFunction::~FileBrowserPrivateCancelCopyFunction() {
-}
-
 bool FileBrowserPrivateCancelCopyFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   using  extensions::api::file_browser_private::CancelCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), 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;
 }
 
 }  // namespace extensions