Add support for actions for multiple file selection.

chrome/browser/chromeos/extensions/file_manager/private_api_misc.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_misc.h"
 
 #include <set>
 #include <vector>
 
 #include "ash/frame/frame_util.h"
 #include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive_pref_names.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "chrome/browser/chromeos/file_manager/zip_file_creator.h"
@@ skipping 23 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_zoom.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "google_apis/drive/auth_service.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "url/gurl.h"
 
 namespace extensions {
+namespace {
 
-namespace {
 const char kCWSScope[] = "https://www.googleapis.com/auth/chromewebstore";
 
 // Obtains the current app window.
 AppWindow* GetCurrentAppWindow(ChromeSyncExtensionFunction* function) {
   content::WebContents* const contents = function->GetSenderWebContents();
   return contents ?
       AppWindowRegistry::Get(function->GetProfile())->
           GetAppWindowForWebContents(contents) : nullptr;
 }
 
@@ skipping 23 matching lines @@
     profile_info->profile_id = multi_user_util::GetUserIDFromProfile(profile);
     profile_info->display_name = UTF16ToUTF8(user->GetDisplayName());
     // TODO(hirono): Remove the property from the profile_info.
     profile_info->is_current_profile = true;
 
     result_profiles.push_back(profile_info);
   }
 
   return result_profiles;
 }
+
+// Converts a list of file system urls (as strings) to a pair of a provided file
+// system object and a set of paths on the file system. In case of an error,
+// false is returned and the error message set.
+bool ConvertURLsToProvidedInfo(
+    const scoped_refptr<storage::FileSystemContext>& file_system_context,
+    const std::vector<std::string>& urls,
+    chromeos::file_system_provider::ProvidedFileSystemInterface** file_system,
+    std::set<base::FilePath>* paths,

[fukino, 2015/07/23 04:52:18]

optional nit: Can we use vector for paths?
I'm a bit concerned about the cost to use std::set when the entry list is large.
If we need to deduplicate the paths in the API side, how about using std::vector
and std::unique?

[mtomasz, 2015/09/17 05:03:46]

Done.

+    std::string* error) {
+  DCHECK(file_system);
+  DCHECK(error);
+
+  if (!urls.size()) {
+    *error = "At least one file must be specified.";
+    return false;
+  }
+
+  *file_system = nullptr;
+  for (const auto url : urls) {
+    const storage::FileSystemURL file_system_url(
+        file_system_context->CrackURL(GURL(url)));
+
+    LOG(ERROR) << "URL: " << url;

[fukino, 2015/07/23 04:52:18]

Remaining debug log?

[mtomasz, 2015/09/17 05:03:46]

Done.

+
+    chromeos::file_system_provider::util::FileSystemURLParser parser(
+        file_system_url);
+    if (!parser.Parse()) {
+      *error = "Related provided file system not found.";
+      return false;
+    }
+
+    if (*file_system != nullptr) {
+      if (*file_system != parser.file_system()) {
+        *error = "All entries must be on the same file system.";
+        return false;
+      }
+    } else {
+      *file_system = parser.file_system();
+    }
+    paths->insert(parser.file_path());
+  }
+
+  return true;
+}
+
 }  // namespace
 
 bool FileManagerPrivateLogoutUserForReauthenticationFunction::RunSync() {
   const user_manager::User* user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(GetProfile());
   if (user) {
     user_manager::UserManager::Get()->SaveUserOAuthStatus(
         user->email(), user_manager::User::OAUTH2_TOKEN_STATUS_INVALID);
   }
 
@@ skipping 420 matching lines @@
 void FileManagerPrivateConfigureVolumeFunction::OnCompleted(
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to complete configuration."));
     return;
   }
 
   Respond(NoArguments());
 }
 
-FileManagerPrivateInternalGetEntryActionsFunction::
-    FileManagerPrivateInternalGetEntryActionsFunction()
-    : chrome_details_(this) {
-}
+FileManagerPrivateInternalGetCustomActionsFunction::
+    FileManagerPrivateInternalGetCustomActionsFunction()
+    : chrome_details_(this) {}
 
 ExtensionFunction::ResponseAction
-FileManagerPrivateInternalGetEntryActionsFunction::Run() {
-  using extensions::api::file_manager_private_internal::GetEntryActions::Params;
+FileManagerPrivateInternalGetCustomActionsFunction::Run() {
+  using extensions::api::file_manager_private_internal::GetCustomActions::
+      Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           chrome_details_.GetProfile(), render_frame_host());
 
-  const storage::FileSystemURL file_system_url(
-      file_system_context->CrackURL(GURL(params->url)));
+  std::set<base::FilePath> paths;
+  chromeos::file_system_provider::ProvidedFileSystemInterface* file_system =
+      nullptr;
+  std::string error;
 
-  chromeos::file_system_provider::util::FileSystemURLParser parser(
-      file_system_url);
-  if (!parser.Parse())
-    return RespondNow(Error("Related provided file system not found."));
+  if (!ConvertURLsToProvidedInfo(file_system_context, params->urls,
+                                 &file_system, &paths, &error)) {
+    return RespondNow(Error(error));
+  }
 
-  parser.file_system()->GetActions(
-      parser.file_path(),
+  DCHECK(file_system);
+  file_system->GetActions(
+      paths,
       base::Bind(
-          &FileManagerPrivateInternalGetEntryActionsFunction::OnCompleted,
+          &FileManagerPrivateInternalGetCustomActionsFunction::OnCompleted,
           this));
   return RespondLater();
 }
 
-void FileManagerPrivateInternalGetEntryActionsFunction::OnCompleted(
+void FileManagerPrivateInternalGetCustomActionsFunction::OnCompleted(
     const chromeos::file_system_provider::Actions& actions,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to fetch actions."));
     return;
   }
 
   using api::file_system_provider::Action;
   std::vector<linked_ptr<Action>> items;
   for (const auto& action : actions) {
     const linked_ptr<Action> item(new Action);
     item->id = action.id;
     item->title.reset(new std::string(action.title));
     items.push_back(item);
   }
 
   Respond(ArgumentList(
-      api::file_manager_private_internal::GetEntryActions::Results::Create(
+      api::file_manager_private_internal::GetCustomActions::Results::Create(
           items)));
 }
 
-FileManagerPrivateInternalExecuteEntryActionFunction::
-    FileManagerPrivateInternalExecuteEntryActionFunction()
-    : chrome_details_(this) {
-}
+FileManagerPrivateInternalExecuteCustomActionFunction::
+    FileManagerPrivateInternalExecuteCustomActionFunction()
+    : chrome_details_(this) {}
 
 ExtensionFunction::ResponseAction
-FileManagerPrivateInternalExecuteEntryActionFunction::Run() {
-  using extensions::api::file_manager_private_internal::ExecuteEntryAction::
+FileManagerPrivateInternalExecuteCustomActionFunction::Run() {
+  using extensions::api::file_manager_private_internal::ExecuteCustomAction::
       Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           chrome_details_.GetProfile(), render_frame_host());
 
-  const storage::FileSystemURL file_system_url(
-      file_system_context->CrackURL(GURL(params->url)));
+  std::set<base::FilePath> paths;
+  chromeos::file_system_provider::ProvidedFileSystemInterface* file_system =
+      nullptr;
+  std::string error;
 
-  chromeos::file_system_provider::util::FileSystemURLParser parser(
-      file_system_url);
-  if (!parser.Parse())
-    return RespondNow(Error("Related provided file system not found."));
+  if (!ConvertURLsToProvidedInfo(file_system_context, params->urls,
+                                 &file_system, &paths, &error)) {
+    return RespondNow(Error(error));
+  }
 
-  parser.file_system()->ExecuteAction(
-      parser.file_path(), params->action_id,
+  DCHECK(file_system);
+  file_system->ExecuteAction(
+      paths, params->action_id,
       base::Bind(
-          &FileManagerPrivateInternalExecuteEntryActionFunction::OnCompleted,
+          &FileManagerPrivateInternalExecuteCustomActionFunction::OnCompleted,
           this));
   return RespondLater();
 }
 
-void FileManagerPrivateInternalExecuteEntryActionFunction::OnCompleted(
+void FileManagerPrivateInternalExecuteCustomActionFunction::OnCompleted(
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to execute the action."));
     return;
   }
 
   Respond(NoArguments());
 }
 
 }  // namespace extensions