mac: Zip packages when they are selected by the file opener.

chrome/browser/file_select_helper.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/file_select_helper.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 std::vector<ui::SelectedFileInfo> FilePathListToSelectedFileInfoList(
     const std::vector<base::FilePath>& paths) {
   std::vector<ui::SelectedFileInfo> selected_files;
   for (size_t i = 0; i < paths.size(); ++i) {
     selected_files.push_back(
         ui::SelectedFileInfo(paths[i], paths[i]));
   }
   return selected_files;
 }
 
+void DeleteFiles(const std::vector<base::FilePath>& paths) {
+  for (base::FilePath file_path : paths)

[Avi (use Gerrit), 2014/10/08 00:17:32]

auto& perhaps?

[erikchen, 2014/10/08 20:14:43]

Done.

+    base::DeleteFile(file_path, true);
+}
+
 }  // namespace
 
 struct FileSelectHelper::ActiveDirectoryEnumeration {
   ActiveDirectoryEnumeration() : rvh_(NULL) {}
 
   scoped_ptr<DirectoryListerDispatchDelegate> delegate_;
   scoped_ptr<net::DirectoryLister> lister_;
   RenderViewHost* rvh_;
   std::vector<base::FilePath> results_;
 };
@@ skipping 36 matching lines @@
 
 void FileSelectHelper::FileSelected(const base::FilePath& path,
                                     int index, void* params) {
   FileSelectedWithExtraInfo(ui::SelectedFileInfo(path, path), index, params);
 }
 
 void FileSelectHelper::FileSelectedWithExtraInfo(
     const ui::SelectedFileInfo& file,
     int index,
     void* params) {
-  if (!render_view_host_)
+  profile_->set_last_selected_directory(file.file_path.DirName());
+
+  if (!render_view_host_) {
+    RunFileChooserEnd();
     return;
-
-  profile_->set_last_selected_directory(file.file_path.DirName());
+  }
 
   const base::FilePath& path = file.local_path;
   if (dialog_type_ == ui::SelectFileDialog::SELECT_UPLOAD_FOLDER) {
     StartNewEnumeration(path, kFileSelectEnumerationId, render_view_host_);
     return;
   }
 
   std::vector<ui::SelectedFileInfo> files;
   files.push_back(file);
-  NotifyRenderViewHost(render_view_host_, files, dialog_mode_);
 
-  // No members should be accessed from here on.
-  RunFileChooserEnd();
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE_USER_BLOCKING,
+      FROM_HERE,
+      base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
+  return;
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+  NotifyRenderViewHostAndEnd(files);
 }
 
 void FileSelectHelper::MultiFilesSelected(
     const std::vector<base::FilePath>& files,
     void* params) {
   std::vector<ui::SelectedFileInfo> selected_files =
       FilePathListToSelectedFileInfoList(files);
 
   MultiFilesSelectedWithExtraInfo(selected_files, params);
 }
 
 void FileSelectHelper::MultiFilesSelectedWithExtraInfo(
     const std::vector<ui::SelectedFileInfo>& files,
     void* params) {
   if (!files.empty())
     profile_->set_last_selected_directory(files[0].file_path.DirName());
-  if (!render_view_host_)
-    return;
 
-  NotifyRenderViewHost(render_view_host_, files, dialog_mode_);
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE_USER_BLOCKING,
+      FROM_HERE,
+      base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
+  return;
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
-  // No members should be accessed from here on.
-  RunFileChooserEnd();
+  NotifyRenderViewHostAndEnd(files);

[Avi (use Gerrit), 2014/10/08 00:17:32]

Might as well put this into an #else.

[erikchen, 2014/10/08 20:14:43]

Done.

 }
 
 void FileSelectHelper::FileSelectionCanceled(void* params) {
-  if (!render_view_host_)
-    return;
-
-  // If the user cancels choosing a file to upload we pass back an
-  // empty vector.
-  NotifyRenderViewHost(
-      render_view_host_, std::vector<ui::SelectedFileInfo>(),
-      dialog_mode_);
-
-  // No members should be accessed from here on.
-  RunFileChooserEnd();
+  NotifyRenderViewHostAndEnd(std::vector<ui::SelectedFileInfo>());
 }
 
 void FileSelectHelper::StartNewEnumeration(const base::FilePath& path,
                                            int request_id,
                                            RenderViewHost* render_view_host) {
   scoped_ptr<ActiveDirectoryEnumeration> entry(new ActiveDirectoryEnumeration);
   entry->rvh_ = render_view_host;
   entry->delegate_.reset(new DirectoryListerDispatchDelegate(this, request_id));
   entry->lister_.reset(new net::DirectoryLister(path,
                                                 true,
@@ skipping 37 matching lines @@
       FilePathListToSelectedFileInfoList(entry->results_);
 
   if (id == kFileSelectEnumerationId)
     NotifyRenderViewHost(entry->rvh_, selected_files, dialog_mode_);
   else
     entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
 
   EnumerateDirectoryEnd();
 }
 
+void FileSelectHelper::NotifyRenderViewHostAndEnd(
+    const std::vector<ui::SelectedFileInfo>& files) {
+  if (render_view_host_)
+    NotifyRenderViewHost(render_view_host_, files, dialog_mode_);
+
+  // No members should be accessed from here on.
+  RunFileChooserEnd();
+}
+
+void FileSelectHelper::DeleteTemporaryFiles() {
+  BrowserThread::PostTask(BrowserThread::FILE,
+                          FROM_HERE,
+                          base::Bind(&DeleteFiles, temporary_files_));
+  temporary_files_.clear();
+}
+
 scoped_ptr<ui::SelectFileDialog::FileTypeInfo>
 FileSelectHelper::GetFileTypesFromAcceptType(
     const std::vector<base::string16>& accept_types) {
   scoped_ptr<ui::SelectFileDialog::FileTypeInfo> base_file_type(
       new ui::SelectFileDialog::FileTypeInfo());
   if (accept_types.empty())
     return base_file_type.Pass();
 
   // Create FileTypeInfo and pre-allocate for the first extension list.
   scoped_ptr<ui::SelectFileDialog::FileTypeInfo> file_type(
@@ skipping 176 matching lines @@
       NULL);
 #endif
 
   select_file_types_.reset();
 }
 
 // This method is called when we receive the last callback from the file
 // chooser dialog. Perform any cleanup and release the reference we added
 // in RunFileChooser().
 void FileSelectHelper::RunFileChooserEnd() {
+  // If there are temporary files, then this instance needs to stick around
+  // until web_contents_ is destroyed, so that this instance can delete the
+  // temporary files.
+  if (!temporary_files_.empty())
+    return;
+
   render_view_host_ = NULL;
   web_contents_ = NULL;
   Release();
 }
 
 void FileSelectHelper::EnumerateDirectory(int request_id,
                                           RenderViewHost* render_view_host,
                                           const base::FilePath& path) {
 
   // Because this class returns notifications to the RenderViewHost, it is
@@ skipping 19 matching lines @@
     case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
       DCHECK(content::Source<RenderWidgetHost>(source).ptr() ==
              render_view_host_);
       render_view_host_ = NULL;
       break;
     }
 
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
       DCHECK(content::Source<WebContents>(source).ptr() == web_contents_);
       web_contents_ = NULL;
+
+      if (!temporary_files_.empty()) {
+        DeleteTemporaryFiles();
+
+        // Now that the temporary files have been scheduled for deletion, there
+        // is no longer any reason to keep this instance around.
+        Release();
+      }

[Avi (use Gerrit), 2014/10/08 00:17:32]

So if there was zipping that happened, those temporary files will stick around
for as long as the tab does? Can we do better?

[erikchen, 2014/10/08 20:14:43]

Sure. In the updated CL, the notification NOTIFICATION_RENDER_VIEW_HOST_CHANGED
will also kill the temporary files.

+
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 // static
 bool FileSelectHelper::IsAcceptTypeValid(const std::string& accept_type) {
   // TODO(raymes): This only does some basic checks, extend to test more cases.
   // A 1 character accept type will always be invalid (either a "." in the case
   // of an extension or a "/" in the case of a MIME type).
   std::string unused;
   if (accept_type.length() <= 1 ||
       base::StringToLowerASCII(accept_type) != accept_type ||
       base::TrimWhitespaceASCII(accept_type, base::TRIM_ALL, &unused) !=
           base::TRIM_NONE) {
     return false;
   }
   return true;
 }