Add a path for a web page to request the enumeration of a directory. This, t...

chrome/browser/file_select_helper.cc

 // Copyright (c) 2011 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 "base/file_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "content/browser/child_process_security_policy.h"
+#include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 #include "content/common/view_messages.h"
 #include "grit/generated_resources.h"
 #include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
+namespace {
+
+// There is only one file-selection happening at any given time,
+// so we allocate an enumeration ID for that purpose.  All IDs from
+// the renderer must start at 0 and increase.
+static const int kFileSelectEnumerationId = -1;
+}
+
 FileSelectHelper::FileSelectHelper(Profile* profile)
     : profile_(profile),
       render_view_host_(NULL),
       select_file_dialog_(),
       dialog_type_(SelectFileDialog::SELECT_OPEN_FILE) {
 }
 
 FileSelectHelper::~FileSelectHelper() {
   // There may be pending file dialogs, we need to tell them that we've gone
   // away so they don't try and call back to us.
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 
-  // Stop any pending directory enumeration and prevent a callback.
-  if (directory_lister_.get()) {
-    directory_lister_->set_delegate(NULL);
-    directory_lister_->Cancel();
+  // Stop any pending directory enumeration, prevent a callback, and free
+  // allocated memory.
+  std::map<int, ActiveDirectoryEnumeration*>::iterator iter;
+  for (iter = directory_enumerations_.begin();
+       iter != directory_enumerations_.end();
+       ++iter) {
+    if (iter->second->lister_.get()) {
+      iter->second->lister_->set_delegate(NULL);
+      iter->second->lister_->Cancel();
+    }
+    delete iter->second;
   }
 }
 
 void FileSelectHelper::FileSelected(const FilePath& path,
                                     int index, void* params) {
   if (!render_view_host_)
     return;
 
   profile_->set_last_selected_directory(path.DirName());
 
   if (dialog_type_ == SelectFileDialog::SELECT_FOLDER) {
-    DirectorySelected(path);
+    StartNewEnumeration(path, kFileSelectEnumerationId, render_view_host_);
     return;
   }
 
   std::vector<FilePath> files;
   files.push_back(path);
   render_view_host_->FilesSelectedInChooser(files);
   // We are done with this showing of the dialog.
   render_view_host_ = NULL;
 }
 
@@ skipping 14 matching lines @@
     return;
 
   // If the user cancels choosing a file to upload we pass back an
   // empty vector.
   render_view_host_->FilesSelectedInChooser(std::vector<FilePath>());
 
   // We are done with this showing of the dialog.
   render_view_host_ = NULL;
 }
 
-void FileSelectHelper::DirectorySelected(const FilePath& path) {
-  directory_lister_ = new net::DirectoryLister(path,
-                                               true,
-                                               net::DirectoryLister::NO_SORT,
-                                               this);
-  if (!directory_lister_->Start())
-    FileSelectionCanceled(NULL);
+void FileSelectHelper::StartNewEnumeration(const 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_ = new net::DirectoryLister(path,
+                                            true,
+                                            net::DirectoryLister::NO_SORT,
+                                            entry->delegate_.get());
+  if (!entry->lister_->Start()) {
+    if (request_id == kFileSelectEnumerationId)
+      FileSelectionCanceled(NULL);
+    else
+      render_view_host->DirectoryEnumerationFinished(request_id,
+                                                     entry->results_);
+  } else {
+    directory_enumerations_[request_id] = entry.release();
+  }
 }
 
 void FileSelectHelper::OnListFile(
+    int id,
     const net::DirectoryLister::DirectoryListerData& data) {
+  ActiveDirectoryEnumeration* entry = directory_enumerations_[id];
+
   // Directory upload returns directories via a "." file, so that
   // empty directories are included.  This util call just checks
   // the flags in the structure; there's no file I/O going on.
   if (file_util::FileEnumerator::IsDirectory(data.info))
-    directory_lister_results_.push_back(
-        data.path.Append(FILE_PATH_LITERAL(".")));
+    entry->results_.push_back(data.path.Append(FILE_PATH_LITERAL(".")));
   else
-    directory_lister_results_.push_back(data.path);
+    entry->results_.push_back(data.path);
 }
 
-void FileSelectHelper::OnListDone(int error) {
-  if (!render_view_host_)
+void FileSelectHelper::OnListDone(int id, int error) {
+  // This entry needs to be cleaned up when this function is done.
+  scoped_ptr<ActiveDirectoryEnumeration> entry(directory_enumerations_[id]);
+  directory_enumerations_.erase(id);
+  if (!entry->rvh_)
     return;
-
   if (error) {
     FileSelectionCanceled(NULL);
     return;
   }
-
-  render_view_host_->FilesSelectedInChooser(directory_lister_results_);
-  render_view_host_ = NULL;
-  directory_lister_ = NULL;
-  directory_lister_results_.clear();
+  if (id == kFileSelectEnumerationId)
+    entry->rvh_->FilesSelectedInChooser(entry->results_);
+  else
+    entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
 }
 
 SelectFileDialog::FileTypeInfo* FileSelectHelper::GetFileTypesFromAcceptType(
     const string16& accept_types) {
   if (accept_types.empty())
     return NULL;
 
   // Split the accept-type string on commas.
   std::vector<string16> mime_types;
   base::SplitStringUsingSubstr(accept_types, ASCIIToUTF16(","), &mime_types);
@@ skipping 100 matching lines @@
   select_file_dialog_->SelectFile(dialog_type_,
                                   params.title,
                                   default_file_name,
                                   file_types.get(),
                                   file_types.get() ? 1 : 0,  // 1-based index.
                                   FILE_PATH_LITERAL(""),
                                   owning_window,
                                   NULL);
 }
 
+void FileSelectHelper::EnumerateDirectory(int request_id,
+                                          RenderViewHost* render_view_host,
+                                          const FilePath& path) {
+  DCHECK_NE(kFileSelectEnumerationId, request_id);
+  StartNewEnumeration(path, request_id, render_view_host);
+}
+
 void FileSelectHelper::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   DCHECK(type == NotificationType::RENDER_WIDGET_HOST_DESTROYED);
   DCHECK(Details<RenderViewHost>(details).ptr() == render_view_host_);
   render_view_host_ = NULL;
 }
 
 FileSelectObserver::FileSelectObserver(TabContents* tab_contents)
     : TabContentsObserver(tab_contents) {
 }
 
 FileSelectObserver::~FileSelectObserver() {
 }
 
 bool FileSelectObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(FileSelectObserver, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RunFileChooser, OnRunFileChooser)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_EnumerateDirectory, OnEnumerateDirectory)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void FileSelectObserver::OnRunFileChooser(
     const ViewHostMsg_RunFileChooser_Params& params) {
   if (!file_select_helper_.get())
     file_select_helper_.reset(new FileSelectHelper(tab_contents()->profile()));
   file_select_helper_->RunFileChooser(tab_contents()->render_view_host(),
                                       params);
 }
+
+void FileSelectObserver::OnEnumerateDirectory(int request_id,
+                                              const FilePath& path) {
+  ChildProcessSecurityPolicy* policy =
+      ChildProcessSecurityPolicy::GetInstance();
+  if (!policy->CanReadDirectory(
+          tab_contents()->render_view_host()->process()->id(),
+          path)) {
+    return;
+  }
+
+  if (!file_select_helper_.get())
+    file_select_helper_.reset(new FileSelectHelper(tab_contents()->profile()));
+  file_select_helper_->EnumerateDirectory(request_id,
+                                          tab_contents()->render_view_host(),
+                                          path);
+}