cros: Defer file selection callback until the window closes.

chrome/browser/ui/views/select_file_dialog_extension.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/ui/views/select_file_dialog_extension.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "chrome/browser/extensions/extension_file_browser_private_api.h"
@@ skipping 16 matching lines @@
 const int kFileManagerWidth = 720;  // pixels
 const int kFileManagerHeight = 580;  // pixels
 
 // Holds references to file manager dialogs that have callbacks pending
 // to their listeners.
 class PendingDialog {
  public:
   static PendingDialog* GetInstance();
   void Add(int32 tab_id, scoped_refptr<SelectFileDialogExtension> dialog);
   void Remove(int32 tab_id);
-  // Returns scoped_refptr because in some cases, when the listener receives
-  // the callback, it deletes itself and the reference to the dialog, and
-  // otherwise we end up calling Close on a deleted dialog.
   scoped_refptr<SelectFileDialogExtension> Find(int32 tab_id);
 
  private:
   friend struct DefaultSingletonTraits<PendingDialog>;
   typedef std::map<int32, scoped_refptr<SelectFileDialogExtension> > Map;
   Map map_;
 };
 
 // static
 PendingDialog* PendingDialog::GetInstance() {
   return Singleton<PendingDialog>::get();
 }
 
 void PendingDialog::Add(int32 tab_id,
                          scoped_refptr<SelectFileDialogExtension> dialog) {
   DCHECK(dialog);
   if (map_.find(tab_id) == map_.end())
     map_.insert(std::make_pair(tab_id, dialog));
   else
-    LOG(WARNING) << "Duplicate pending dialog " << tab_id;
+    DLOG(WARNING) << "Duplicate pending dialog " << tab_id;
 }
 
 void PendingDialog::Remove(int32 tab_id) {
   map_.erase(tab_id);
 }
 
 scoped_refptr<SelectFileDialogExtension> PendingDialog::Find(int32 tab_id) {
   Map::const_iterator it = map_.find(tab_id);
-  if (it == map_.end()) {
-    LOG(WARNING) << "Pending dialog not found " << tab_id;
+  if (it == map_.end())
     return NULL;
-  }
   return it->second;
 }
 
 }  // namespace
 
 // Linking this implementation of SelectFileDialog::Create into the target
 // selects FileManagerDialog as the dialog of choice.
 // TODO(jamescook): Move this into a new file shell_dialogs_chromeos.cc
 // TODO(jamescook): Change all instances of SelectFileDialog::Create to return
 // scoped_refptr<SelectFileDialog> as object is ref-counted.
 // static
 SelectFileDialog* SelectFileDialog::Create(Listener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return SelectFileDialogExtension::Create(listener);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 // static
 SelectFileDialogExtension* SelectFileDialogExtension::Create(
     Listener* listener) {
   return new SelectFileDialogExtension(listener);
 }
 
 SelectFileDialogExtension::SelectFileDialogExtension(Listener* listener)
     : SelectFileDialog(listener),
       has_multiple_file_type_choices_(false),
-      params_(NULL),
       tab_id_(0),
-      owner_window_(0) {
+      owner_window_(0),
+      selection_type_(CANCEL),
+      selection_index_(0),
+      params_(NULL) {
 }
 
 SelectFileDialogExtension::~SelectFileDialogExtension() {
   if (extension_dialog_)
     extension_dialog_->ObserverDestroyed();
 }
 
 bool SelectFileDialogExtension::IsRunning(
     gfx::NativeWindow owner_window) const {
   return owner_window_ == owner_window;
 }
 
 void SelectFileDialogExtension::ListenerDestroyed() {
   listener_ = NULL;
   params_ = NULL;
   PendingDialog::GetInstance()->Remove(tab_id_);
 }
 
-void SelectFileDialogExtension::ExtensionDialogIsClosing(
+void SelectFileDialogExtension::ExtensionDialogClosing(
     ExtensionDialog* dialog) {
   owner_window_ = NULL;
   // Release our reference to the dialog to allow it to close.
   extension_dialog_ = NULL;
   PendingDialog::GetInstance()->Remove(tab_id_);
-}
-
-void SelectFileDialogExtension::Close() {
-  if (extension_dialog_)
-    extension_dialog_->Close();
-  PendingDialog::GetInstance()->Remove(tab_id_);
+  // Actually invoke the appropriate callback on our listener.
+  NotifyListener();
 }
 
 // static
 void SelectFileDialogExtension::OnFileSelected(
     int32 tab_id, const FilePath& path, int index) {
   scoped_refptr<SelectFileDialogExtension> dialog =
       PendingDialog::GetInstance()->Find(tab_id);
-  if (dialog) {
-    DCHECK(dialog->listener_);
-    dialog->listener_->FileSelected(path, index, dialog->params_);
-    dialog->Close();
-  }
+  if (!dialog)
+    return;
+  dialog->selection_type_ = SINGLE_FILE;
+  dialog->selection_files_.clear();
+  dialog->selection_files_.push_back(path);
+  dialog->selection_index_ = index;
 }
 
 // static
 void SelectFileDialogExtension::OnMultiFilesSelected(
     int32 tab_id, const std::vector<FilePath>& files) {
   scoped_refptr<SelectFileDialogExtension> dialog =
       PendingDialog::GetInstance()->Find(tab_id);
-  if (dialog) {
-    DCHECK(dialog->listener_);
-    dialog->listener_->MultiFilesSelected(files, dialog->params_);
-    dialog->Close();
-  }
+  if (!dialog)
+    return;
+  dialog->selection_type_ = MULTIPLE_FILES;
+  dialog->selection_files_ = files;
+  dialog->selection_index_ = 0;
 }
 
 // static
 void SelectFileDialogExtension::OnFileSelectionCanceled(int32 tab_id) {
   scoped_refptr<SelectFileDialogExtension> dialog =
       PendingDialog::GetInstance()->Find(tab_id);
-  if (dialog) {
-    DCHECK(dialog->listener_);
-    dialog->listener_->FileSelectionCanceled(dialog->params_);
-    dialog->Close();
-  }
+  if (!dialog)
+    return;
+  dialog->selection_type_ = CANCEL;
+  dialog->selection_files_.clear();
+  dialog->selection_index_ = 0;
 }
 
 RenderViewHost* SelectFileDialogExtension::GetRenderViewHost() {
   if (extension_dialog_)
     return extension_dialog_->host()->render_view_host();
   return NULL;
 }
 
+void SelectFileDialogExtension::NotifyListener() {
+  if (!listener_)
+    return;
+  switch (selection_type_) {
+    case CANCEL:
+      listener_->FileSelectionCanceled(params_);
+      break;
+    case SINGLE_FILE:
+      listener_->FileSelected(selection_files_[0], selection_index_, params_);
+      break;
+    case MULTIPLE_FILES:
+      listener_->MultiFilesSelected(selection_files_, params_);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
 void SelectFileDialogExtension::AddPending(int32 tab_id) {
   PendingDialog::GetInstance()->Add(tab_id, this);
 }
 
 // static
 bool SelectFileDialogExtension::PendingExists(int32 tab_id) {
   return PendingDialog::GetInstance()->Find(tab_id) != NULL;
 }
 
 bool SelectFileDialogExtension::HasMultipleFileTypeChoicesImpl() {
@@ skipping 20 matching lines @@
   if (!owner_browser) {
     NOTREACHED() << "Can't find owning browser";
     return;
   }
 
   TabContentsWrapper* tab = owner_browser->GetSelectedTabContentsWrapper();
 
   // Check if we have another dialog opened in the tab. It's unlikely, but
   // possible.
   int32 tab_id = tab ? tab->restore_tab_helper()->session_id().id() : 0;
-  if (PendingExists(tab_id))
+  if (PendingExists(tab_id)) {
+    DLOG(WARNING) << "Pending dialog exists with id " << tab_id;
     return;
+  }
 
   FilePath virtual_path;
   if (!file_manager_util::ConvertFileToRelativeFileSystemPath(
           owner_browser->profile(), default_path, &virtual_path)) {
     virtual_path = default_path.BaseName();
   }
 
   has_multiple_file_type_choices_ =
       file_types ? file_types->extensions.size() > 1 : true;
 
@@ skipping 11 matching lines @@
   }
 
   // Connect our listener to FileDialogFunction's per-tab callbacks.
   AddPending(tab_id);
 
   extension_dialog_ = dialog;
   params_ = params;
   tab_id_ = tab_id;
   owner_window_ = owner_window;
 }