git cl format chrome/browser/extensions/api/file_system/file_system_api.cc

chrome/browser/extensions/api/file_system/file_system_api.cc

 // Copyright (c) 2012 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/extensions/api/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 61 matching lines @@
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "url/url_constants.h"
 #endif
 
 using apps::SavedFileEntry;
 using apps::SavedFilesService;
 using storage::IsolatedContext;
 
-const char kInvalidCallingPage[] = "Invalid calling page. This function can't "
+const char kInvalidCallingPage[] =
+    "Invalid calling page. This function can't "

[Devlin, 2017/06/13 20:32:45]

nit: git cl format can't fix the wrapping.  Mind doing it?

[michaelpg, 2017/06/13 20:39:46]

It won't fit on one line. Wrapping before "page" might be the strict style
guideline, but how about wrapping at the sentence so grepping an error message
might be slightly less likely to fail?

[Devlin, 2017/06/13 20:42:16]

sure.  I'm fine with either logical or stylistic. :)

     "be called from a background page.";
 const char kUserCancelled[] = "User cancelled";
 const char kWritableFileErrorFormat[] = "Error opening %s";
 const char kRequiresFileSystemWriteError[] =
     "Operation requires fileSystem.write permission";
 const char kRequiresFileSystemDirectoryError[] =
     "Operation requires fileSystem.directory permission";
 const char kMultipleUnsupportedError[] =
     "acceptsMultiple: true is only supported for 'openFile'";
 const char kUnknownIdError[] = "Unknown id";
@@ skipping 83 matching lines @@
     *description = l10n_util::GetStringUTF16(description_id);
 
   return true;
 }
 
 // Key for the path of the directory of the file last chosen by the user in
 // response to a chrome.fileSystem.chooseEntry() call.
 const char kLastChooseEntryDirectory[] = "last_choose_file_directory";
 
 const int kGraylistedPaths[] = {
-  base::DIR_HOME,
+    base::DIR_HOME,
 #if defined(OS_WIN)
-  base::DIR_PROGRAM_FILES,
-  base::DIR_PROGRAM_FILESX86,
-  base::DIR_WINDOWS,
+    base::DIR_PROGRAM_FILES, base::DIR_PROGRAM_FILESX86, base::DIR_WINDOWS,
 #endif
 };
 
 typedef base::Callback<void(std::unique_ptr<base::File::Info>)>
     FileInfoOptCallback;
 
 // Passes optional file info to the UI thread depending on |result| and |info|.
 void PassFileInfoToUIThread(const FileInfoOptCallback& callback,
                             base::File::Error result,
                             const base::File::Info& info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   std::unique_ptr<base::File::Info> file_info(
       result == base::File::FILE_OK ? new base::File::Info(info) : NULL);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::BindOnce(callback, base::Passed(&file_info)));
 }
 
 // Gets a WebContents instance handle for a platform app hosted in
 // |render_frame_host|. If not found, then returns NULL.
 content::WebContents* GetWebContentsForRenderFrameHost(
     Profile* profile,
     content::RenderFrameHost* render_frame_host) {
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   // Check if there is an app window associated with the web contents; if not,
   // return null.
-  return AppWindowRegistry::Get(profile)
-                 ->GetAppWindowForWebContents(web_contents)
+  return AppWindowRegistry::Get(profile)->GetAppWindowForWebContents(
+             web_contents)
              ? web_contents
              : nullptr;
 }
 
 #if defined(OS_CHROMEOS)
 // Fills a list of volumes mounted in the system.
 void FillVolumeList(Profile* profile,
                     std::vector<api::file_system::Volume>* result) {
   file_manager::VolumeManager* const volume_manager =
       file_manager::VolumeManager::Get(profile);
@@ skipping 11 matching lines @@
 #endif
 
 }  // namespace
 
 namespace file_system_api {
 
 base::FilePath GetLastChooseEntryDirectory(const ExtensionPrefs* prefs,
                                            const std::string& extension_id) {
   base::FilePath path;
   std::string string_path;
-  if (prefs->ReadPrefAsString(extension_id,
-                              kLastChooseEntryDirectory,
+  if (prefs->ReadPrefAsString(extension_id, kLastChooseEntryDirectory,
                               &string_path)) {
     path = base::FilePath::FromUTF8Unsafe(string_path);
   }
   return path;
 }
 
 void SetLastChooseEntryDirectory(ExtensionPrefs* prefs,
                                  const std::string& extension_id,
                                  const base::FilePath& path) {
   prefs->UpdateExtensionPref(extension_id, kLastChooseEntryDirectory,
@@ skipping 90 matching lines @@
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->Set("entries", base::MakeUnique<base::ListValue>());
   result->SetBoolean("multiple", multiple_);
   return result;
 }
 
 void FileSystemEntryFunction::AddEntryToResult(const base::FilePath& path,
                                                const std::string& id_override,
                                                base::DictionaryValue* result) {
   GrantedFileEntry file_entry = app_file_handler_util::CreateFileEntry(
-      GetProfile(),
-      extension(),
-      render_frame_host()->GetProcess()->GetID(),
-      path,
-      is_directory_);
+      GetProfile(), extension(), render_frame_host()->GetProcess()->GetID(),
+      path, is_directory_);
   base::ListValue* entries;
   bool success = result->GetList("entries", &entries);
   DCHECK(success);
 
   std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue());
   entry->SetString("fileSystemId", file_entry.filesystem_id);
   entry->SetString("baseName", file_entry.registered_name);
   if (id_override.empty())
     entry->SetString("id", file_entry.id);
   else
@@ skipping 31 matching lines @@
       base::BindOnce(&FileSystemGetWritableEntryFunction::SetIsDirectoryAsync,
                      this),
       base::BindOnce(
           &FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse,
           this));
   return true;
 }
 
 void FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (is_directory_ &&
-      !extension_->permissions_data()->HasAPIPermission(
-          APIPermission::kFileSystemDirectory)) {
+  if (is_directory_ && !extension_->permissions_data()->HasAPIPermission(
+                           APIPermission::kFileSystemDirectory)) {
     error_ = kRequiresFileSystemDirectoryError;
     SendResponse(false);
   }
   std::vector<base::FilePath> paths;
   paths.push_back(path_);
   PrepareFilesForWritableApp(paths);
 }
 
 void FileSystemGetWritableEntryFunction::SetIsDirectoryAsync() {
   if (base::DirectoryExists(path_)) {
     is_directory_ = true;
   }
 }
 
 ExtensionFunction::ResponseAction FileSystemIsWritableEntryFunction::Run() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   std::string filesystem_id;
   if (!storage::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id))
     return RespondNow(Error(app_file_handler_util::kInvalidParameters));
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   int renderer_id = render_frame_host()->GetProcess()->GetID();
-  bool is_writable = policy->CanReadWriteFileSystem(renderer_id,
-                                                    filesystem_id);
+  bool is_writable = policy->CanReadWriteFileSystem(renderer_id, filesystem_id);
 
   return RespondNow(OneArgument(base::MakeUnique<base::Value>(is_writable)));
 }
 
 // Handles showing a dialog to the user to ask for the filename for a file to
 // save or open.
 class FileSystemChooseEntryFunction::FilePicker
     : public ui::SelectFileDialog::Listener {
  public:
   FilePicker(FileSystemChooseEntryFunction* function,
              content::WebContents* web_contents,
              const base::FilePath& suggested_name,
              const ui::SelectFileDialog::FileTypeInfo& file_type_info,
              ui::SelectFileDialog::Type picker_type)
       : function_(function) {
     select_file_dialog_ = ui::SelectFileDialog::Create(
         this, new ChromeSelectFilePolicy(web_contents));
-    gfx::NativeWindow owning_window = web_contents ?
-        platform_util::GetTopLevel(web_contents->GetNativeView()) :
-        NULL;
+    gfx::NativeWindow owning_window =
+        web_contents ? platform_util::GetTopLevel(web_contents->GetNativeView())
+                     : NULL;
 
     if (g_skip_picker_for_test) {
       if (g_use_suggested_path_for_test) {
         content::BrowserThread::PostTask(
             content::BrowserThread::UI, FROM_HERE,
             base::BindOnce(
                 &FileSystemChooseEntryFunction::FilePicker::FileSelected,
                 base::Unretained(this), suggested_name, 1,
                 static_cast<void*>(NULL)));
       } else if (g_path_to_be_picked_for_test) {
@@ skipping 13 matching lines @@
       } else {
         content::BrowserThread::PostTask(
             content::BrowserThread::UI, FROM_HERE,
             base::BindOnce(&FileSystemChooseEntryFunction::FilePicker::
                                FileSelectionCanceled,
                            base::Unretained(this), static_cast<void*>(NULL)));
       }
       return;
     }
 
-    select_file_dialog_->SelectFile(picker_type,
-                                    base::string16(),
-                                    suggested_name,
-                                    &file_type_info,
-                                    0,
-                                    base::FilePath::StringType(),
-                                    owning_window,
-                                    NULL);
+    select_file_dialog_->SelectFile(
+        picker_type, base::string16(), suggested_name, &file_type_info, 0,
+        base::FilePath::StringType(), owning_window, NULL);
   }
 
   ~FilePicker() override {}
 
  private:
   // ui::SelectFileDialog::Listener implementation.
   void FileSelected(const base::FilePath& path,
                     int index,
                     void* params) override {
     std::vector<base::FilePath> paths;
@@ skipping 58 matching lines @@
   if (!web_contents) {
     error_ = kInvalidCallingPage;
     SendResponse(false);
     return;
   }
 
   // The file picker will hold a reference to this function instance, preventing
   // its destruction (and subsequent sending of the function response) until the
   // user has selected a file or cancelled the picker. At that point, the picker
   // will delete itself, which will also free the function instance.
-  new FilePicker(
-      this, web_contents, initial_path_, file_type_info, picker_type);
+  new FilePicker(this, web_contents, initial_path_, file_type_info,
+                 picker_type);
 }
 
 // static
 void FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
     base::FilePath* path) {
   g_skip_picker_for_test = true;
   g_use_suggested_path_for_test = false;
   g_path_to_be_picked_for_test = path;
   g_paths_to_be_picked_for_test = NULL;
 }
@@ skipping 38 matching lines @@
   g_allow_directory_access_for_test = false;
 }
 
 // static
 void FileSystemChooseEntryFunction::StopSkippingDirectoryConfirmationForTest() {
   g_skip_directory_confirmation_for_test = false;
 }
 
 // static
 void FileSystemChooseEntryFunction::RegisterTempExternalFileSystemForTest(
-    const std::string& name, const base::FilePath& path) {
+    const std::string& name,
+    const base::FilePath& path) {
   // For testing on Chrome OS, where to deal with remote and local paths
   // smoothly, all accessed paths need to be registered in the list of
   // external mount points.
   storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
-      name,
-      storage::kFileSystemTypeNativeLocal,
-      storage::FileSystemMountOption(),
-      path);
+      name, storage::kFileSystemTypeNativeLocal,
+      storage::FileSystemMountOption(), path);
 }
 
 void FileSystemChooseEntryFunction::FilesSelected(
     const std::vector<base::FilePath>& paths) {
   DCHECK(!paths.empty());
   base::FilePath last_choose_directory;
   if (is_directory_) {
     last_choose_directory = paths[0];
   } else {
     last_choose_directory = paths[0].DirName();
   }
   file_system_api::SetLastChooseEntryDirectory(
-      ExtensionPrefs::Get(GetProfile()),
-      extension()->id(),
+      ExtensionPrefs::Get(GetProfile()), extension()->id(),
       last_choose_directory);
   if (is_directory_) {
     // Get the WebContents for the app window to be the parent window of the
     // confirmation dialog if necessary.
     content::WebContents* const web_contents =
         GetWebContentsForRenderFrameHost(GetProfile(), render_frame_host());
     if (!web_contents) {
       error_ = kInvalidCallingPage;
       SendResponse(false);
       return;
@@ skipping 88 matching lines @@
 
 void FileSystemChooseEntryFunction::BuildFileTypeInfo(
     ui::SelectFileDialog::FileTypeInfo* file_type_info,
     const base::FilePath::StringType& suggested_extension,
     const AcceptOptions* accepts,
     const bool* acceptsAllTypes) {
   file_type_info->include_all_files = true;
   if (acceptsAllTypes)
     file_type_info->include_all_files = *acceptsAllTypes;
 
-  bool need_suggestion = !file_type_info->include_all_files &&
-                         !suggested_extension.empty();
+  bool need_suggestion =
+      !file_type_info->include_all_files && !suggested_extension.empty();
 
   if (accepts) {
     for (const file_system::AcceptOption& option : *accepts) {
       base::string16 description;
       std::vector<base::FilePath::StringType> extensions;
 
       if (!GetFileTypesFromAcceptOption(option, &extensions, &description))
         continue;  // No extensions were found.
 
       file_type_info->extensions.push_back(extensions);
       file_type_info->extension_description_overrides.push_back(description);
 
       // If we still need to find suggested_extension, hunt for it inside the
       // extensions returned from GetFileTypesFromAcceptOption.
-      if (need_suggestion && std::find(extensions.begin(),
-              extensions.end(), suggested_extension) != extensions.end()) {
+      if (need_suggestion &&
+          std::find(extensions.begin(), extensions.end(),
+                    suggested_extension) != extensions.end()) {
         need_suggestion = false;
       }
     }
   }
 
   // If there's nothing in our accepted extension list or we couldn't find the
   // suggested extension required, then default to accepting all types.
   if (file_type_info->extensions.empty() || need_suggestion)
     file_type_info->include_all_files = true;
 }
 
 void FileSystemChooseEntryFunction::BuildSuggestion(
-    const std::string *opt_name,
+    const std::string* opt_name,
     base::FilePath* suggested_name,
     base::FilePath::StringType* suggested_extension) {
   if (opt_name) {
     *suggested_name = base::FilePath::FromUTF8Unsafe(*opt_name);
 
     // Don't allow any path components; shorten to the base name. This should
     // result in a relative path, but in some cases may not. Clear the
     // suggestion for safety if this is the case.
     *suggested_name = suggested_name->BaseName();
     if (suggested_name->IsAbsolute())
@@ skipping 66 matching lines @@
       }
       if (multiple_) {
         error_ = kMultipleUnsupportedError;
         return false;
       }
       picker_type = ui::SelectFileDialog::SELECT_FOLDER;
     }
 
     base::FilePath::StringType suggested_extension;
     BuildSuggestion(options->suggested_name.get(), &suggested_name,
-        &suggested_extension);
+                    &suggested_extension);
 
     BuildFileTypeInfo(&file_type_info, suggested_extension,
-        options->accepts.get(), options->accepts_all_types.get());
+                      options->accepts.get(), options->accepts_all_types.get());
   }
 
   file_type_info.allowed_paths = ui::SelectFileDialog::FileTypeInfo::ANY_PATH;
 
   base::FilePath previous_path = file_system_api::GetLastChooseEntryDirectory(
       ExtensionPrefs::Get(GetProfile()), extension()->id());
 
   if (previous_path.empty()) {
     SetInitialPathAndShowPicker(previous_path, suggested_name, file_type_info,
                                 picker_type, false);
@@ skipping 40 matching lines @@
 
     std::string filesystem_id;
     if (!storage::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id))
       return false;
 
     const GURL site = util::GetSiteForExtensionId(extension_id(), GetProfile());
     storage::FileSystemContext* const context =
         content::BrowserContext::GetStoragePartitionForSite(GetProfile(), site)
             ->GetFileSystemContext();
     const storage::FileSystemURL url = context->CreateCrackedFileSystemURL(
-        site,
-        storage::kFileSystemTypeIsolated,
+        site, storage::kFileSystemTypeIsolated,
         IsolatedContext::GetInstance()
             ->CreateVirtualRootPath(filesystem_id)
             .Append(base::FilePath::FromUTF8Unsafe(filesystem_path)));
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::BindOnce(
             base::IgnoreResult(
                 &storage::FileSystemOperationRunner::GetMetadata),
             context->operation_runner()->AsWeakPtr(), url,
@@ skipping 13 matching lines @@
 void FileSystemRetainEntryFunction::RetainFileEntry(
     const std::string& entry_id,
     const base::FilePath& path,
     std::unique_ptr<base::File::Info> file_info) {
   if (!file_info) {
     SendResponse(false);
     return;
   }
 
   SavedFilesService* saved_files_service = SavedFilesService::Get(GetProfile());
-  saved_files_service->RegisterFileEntry(
-      extension_->id(), entry_id, path, file_info->is_directory);
+  saved_files_service->RegisterFileEntry(extension_->id(), entry_id, path,
+                                         file_info->is_directory);
   saved_files_service->EnqueueFileEntry(extension_->id(), entry_id);
   SendResponse(true);
 }
 
 ExtensionFunction::ResponseAction FileSystemIsRestorableFunction::Run() {
   std::string entry_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   return RespondNow(OneArgument(base::MakeUnique<base::Value>(
       SavedFilesService::Get(Profile::FromBrowserContext(browser_context()))
           ->IsRegistered(extension_->id(), entry_id))));
 }
 
 bool FileSystemRestoreEntryFunction::RunAsync() {
   std::string entry_id;
   bool needs_new_entry;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &needs_new_entry));
-  const SavedFileEntry* file_entry = SavedFilesService::Get(
-      GetProfile())->GetFileEntry(extension_->id(), entry_id);
+  const SavedFileEntry* file_entry =
+      SavedFilesService::Get(GetProfile())
+          ->GetFileEntry(extension_->id(), entry_id);
   if (!file_entry) {
     error_ = kUnknownIdError;
     return false;
   }
 
   SavedFilesService::Get(GetProfile())
       ->EnqueueFileEntry(extension_->id(), entry_id);
 
   // Only create a new file entry if the renderer requests one.
   // |needs_new_entry| will be false if the renderer already has an Entry for
@@ skipping 33 matching lines @@
   return RespondNow(Error(kNotSupportedOnCurrentPlatformError));
 }
 
 ExtensionFunction::ResponseAction FileSystemGetVolumeListFunction::Run() {
   NOTIMPLEMENTED();
   return RespondNow(Error(kNotSupportedOnCurrentPlatformError));
 }
 #else
 
 FileSystemRequestFileSystemFunction::FileSystemRequestFileSystemFunction()
-    : chrome_details_(this) {
-}
+    : chrome_details_(this) {}
 
-FileSystemRequestFileSystemFunction::~FileSystemRequestFileSystemFunction() {
-}
+FileSystemRequestFileSystemFunction::~FileSystemRequestFileSystemFunction() {}
 
 ExtensionFunction::ResponseAction FileSystemRequestFileSystemFunction::Run() {
   using api::file_system::RequestFileSystem::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Only kiosk apps in kiosk sessions can use this API.
   // Additionally it is enabled for whitelisted component extensions and apps.
   file_system_api::ConsentProviderDelegate consent_provider_delegate(
       chrome_details_.GetProfile(), render_frame_host());
@@ skipping 17 matching lines @@
 
   base::WeakPtr<file_manager::Volume> volume =
       volume_manager->FindVolumeById(params->options.volume_id);
   if (!volume.get())
     return RespondNow(Error(kVolumeNotFoundError));
 
   const GURL site =
       util::GetSiteForExtensionId(extension_id(), chrome_details_.GetProfile());
   scoped_refptr<storage::FileSystemContext> file_system_context =
       content::BrowserContext::GetStoragePartitionForSite(
-          chrome_details_.GetProfile(), site)->GetFileSystemContext();
+          chrome_details_.GetProfile(), site)
+          ->GetFileSystemContext();
   storage::ExternalFileSystemBackend* const backend =
       file_system_context->external_backend();
   DCHECK(backend);
 
   base::FilePath virtual_path;
   if (!backend->GetVirtualPath(volume->mount_path(), &virtual_path))
     return RespondNow(Error(kSecurityError));
 
   if (writable && (volume->is_read_only()))
     return RespondNow(Error(kSecurityError));
@@ skipping 33 matching lines @@
 
   if (!volume.get()) {
     Respond(Error(kVolumeNotFoundError));
     return;
   }
 
   const GURL site =
       util::GetSiteForExtensionId(extension_id(), chrome_details_.GetProfile());
   scoped_refptr<storage::FileSystemContext> file_system_context =
       content::BrowserContext::GetStoragePartitionForSite(
-          chrome_details_.GetProfile(), site)->GetFileSystemContext();
+          chrome_details_.GetProfile(), site)
+          ->GetFileSystemContext();
   storage::ExternalFileSystemBackend* const backend =
       file_system_context->external_backend();
   DCHECK(backend);
 
   base::FilePath virtual_path;
   if (!backend->GetVirtualPath(volume->mount_path(), &virtual_path)) {
     Respond(Error(kSecurityError));
     return;
   }
 
@@ skipping 48 matching lines @@
   }
 
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("file_system_id", file_system_id);
   dict->SetString("file_system_path", register_name);
 
   Respond(OneArgument(std::move(dict)));
 }
 
 FileSystemGetVolumeListFunction::FileSystemGetVolumeListFunction()
-    : chrome_details_(this) {
-}
+    : chrome_details_(this) {}
 
-FileSystemGetVolumeListFunction::~FileSystemGetVolumeListFunction() {
-}
+FileSystemGetVolumeListFunction::~FileSystemGetVolumeListFunction() {}
 
 ExtensionFunction::ResponseAction FileSystemGetVolumeListFunction::Run() {
   // Only kiosk apps in kiosk sessions can use this API.
   // Additionally it is enabled for whitelisted component extensions and apps.
   file_system_api::ConsentProviderDelegate consent_provider_delegate(
       chrome_details_.GetProfile(), render_frame_host());
   file_system_api::ConsentProvider consent_provider(&consent_provider_delegate);
 
   if (!consent_provider.IsGrantable(*extension()))
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions