Allow ChromeOS file selection dialog to be shown from shell windows.

chrome/browser/ui/views/select_file_dialog_extension.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/ui/views/select_file_dialog_extension.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/extensions/file_browser_private_api.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/shell_window_registry.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/views/extensions/extension_dialog.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/selected_file_info.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const int kFileManagerWidth = 954;  // pixels
@@ skipping 57 matching lines @@
 // static
 SelectFileDialogExtension* SelectFileDialogExtension::Create(
     Listener* listener) {
   return new SelectFileDialogExtension(listener);
 }
 
 SelectFileDialogExtension::SelectFileDialogExtension(Listener* listener)
     : SelectFileDialog(listener),
       has_multiple_file_type_choices_(false),
       tab_id_(0),
-      owner_browser_(NULL),
+      profile_(NULL),
       owner_window_(NULL),
       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::ExtensionDialogClosing(
     ExtensionDialog* dialog) {
-  owner_browser_ = NULL;
+  profile_ = NULL;
   owner_window_ = NULL;
   // Release our reference to the dialog to allow it to close.
   extension_dialog_ = NULL;
   PendingDialog::GetInstance()->Remove(tab_id_);
   // Actually invoke the appropriate callback on our listener.
   NotifyListener();
 }
 
 void SelectFileDialogExtension::ExtensionTerminated(
     ExtensionDialog* dialog) {
   // The extension would have been unloaded because of the termination,
   // reload it.
   std::string extension_id = dialog->host()->extension()->id();
   // Reload the extension after a bit; the extension may not have been unloaded
   // yet. We don't want to try to reload the extension only to have the Unload
   // code execute after us and re-unload the extension.
   //
   // TODO(rkc): This is ugly. The ideal solution is that we shouldn't need to
   // reload the extension at all - when we try to open the extension the next
   // time, the extension subsystem would automatically reload it for us. At
   // this time though this is broken because of some faulty wiring in
   // ExtensionProcessManager::CreateViewHost. Once that is fixed, remove this.
-  if (owner_browser_) {
+  if (profile_) {
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&ExtensionService::ReloadExtension,
-            base::Unretained(owner_browser_->profile()->GetExtensionService()),
+            base::Unretained(profile_->GetExtensionService()),
         extension_id));
   }
 
   dialog->Close();
 }
 
 // static
 void SelectFileDialogExtension::OnFileSelected(
     int32 tab_id,
     const content::SelectedFileInfo& file,
@@ skipping 78 matching lines @@
     const FilePath& default_path,
     const FileTypeInfo* file_types,
     int file_type_index,
     const FilePath::StringType& default_extension,
     gfx::NativeWindow owner_window,
     void* params) {
   if (owner_window_) {
     LOG(ERROR) << "File dialog already in use!";
     return;
   }
-  // Extension background pages may not supply an owner_window.
-  owner_browser_ = (owner_window ?
+
+  // The tab contents to associate the dialog with. If this is not set
+  // by the time the dialog is created, it means the dialog should be shown
+  // full screen and not associated with any tab contents.
+  TabContents* tab = NULL;
+
+  // Extension background pages may not supply an owner_window, in which

[Mihai Parparita -not on Chrome, 2012/06/20 05:21:06]

In cases where the the file picker is triggered from a platform app's background
page and there are no browser windows open, will you end up hitting the
NOTREACHED on line 297?

[benwells, 2012/06/20 05:41:32]

No, as that will fail in the file system API code which already checks that
there is a ShellWindow associated with the calling RenderViewHost. (See
FileSystemPickerFunction::ShowPicker in file_system_api.cc, conventiently also
modified in this change).

+  // case we use the last active browser window.
+  Browser* owner_browser = (owner_window ?
       browser::FindBrowserWithWindow(owner_window) :
       BrowserList::GetLastActive());
-  if (!owner_browser_) {
-    NOTREACHED() << "Can't find owning browser";
+  if (owner_browser) {

[Mihai Parparita -not on Chrome, 2012/06/20 05:21:06]

In the scenario where you have a shell window and a browser open, it seems like
the dialog will end up being attached to the browser window, even if the shell
window is the one that triggered this. It seems like you should always do the
GetShellWindowForNativeWindow(owner_window) check.

[benwells, 2012/06/20 05:41:32]

As owner_window will be set it will call FindBrowserWithWindow, which will
return NULL, so I think it will work.

The logic was pretty convoluted though. Hopefully it's clearer now.

+    tab = owner_browser->GetActiveTabContents();
+    DCHECK(tab);
+    profile_ = tab->profile();
+  } else if (owner_window) {
+    // If there is no browser associated with owner_window, it could be for
+    // a shell window, so check this here.
+    // TODO(benwells): Find a better way to get a shell window from a native
+    // window.
+    // At the moment shell windows are misunderstood, with most of the system
+    // only understanding Browser objects as top level windows. Until shell
+    // windows are better understood we will show the dialog full screen,
+    // and only allow one dialog to be shown like this at a time.
+    // TODO(benwells): Allow ExtensionDialogs to also be shown on shell windows
+    // as they are for Browsers (centered in the window and associated with
+    // the window's tab contents).
+    std::vector<Profile*> profiles =
+        g_browser_process->profile_manager()->GetLoadedProfiles();
+    for (std::vector<Profile*>::const_iterator iter = profiles.begin();
+        iter < profiles.end(); iter++) {
+      ShellWindowRegistry* registry = ShellWindowRegistry::Get(*iter);
+      DCHECK(registry);
+      ShellWindow* shell_window = registry->GetShellWindowForNativeWindow(
+          owner_window);
+      if (shell_window) {
+        profile_ = *iter;
+        break;
+      }
+    }
+  }
+
+  // If we still have no profile something has gone wrong.
+  if (!profile_) {
+    NOTREACHED() << "Can't find profile of owning window.";
     return;
   }
 
-  TabContents* tab = owner_browser_->GetActiveTabContents();
-
   // Check if we have another dialog opened in the tab. It's unlikely, but
-  // possible.
+  // possible. If there is no tab contents use a tab_id of 0. A dialog without
+  // an associated tab contents will be shown fully screen; only one at a time
+  // is allowed in this state.
   int32 tab_id = tab ? tab->restore_tab_helper()->session_id().id() : 0;
   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)) {
+          profile_, default_path, &virtual_path)) {
     virtual_path = default_path.BaseName();
   }
 
   has_multiple_file_type_choices_ =
       file_types ? file_types->extensions.size() > 1 : true;
 
   GURL file_browser_url = file_manager_util::GetFileBrowserUrlWithParams(
       type, title, virtual_path, file_types, file_type_index,
       default_extension);
 
-  ExtensionDialog* dialog = ExtensionDialog::Show(file_browser_url,
-      owner_browser_, tab->web_contents(),
-      kFileManagerWidth, kFileManagerHeight,
 #if defined(USE_AURA)
-      file_manager_util::GetTitleFromType(type),
+  string16 dialog_title = file_manager_util::GetTitleFromType(type);
 #else
-      // HTML-based header used.
-      string16(),
+  // HTML-based header used.
+  string16 dialog_title;
 #endif
-      this /* ExtensionDialog::Observer */);
+
+  // At this point either both owner_browser and tab should be set,
+  // or neither.
+  ExtensionDialog* dialog;
+  if (owner_browser) {
+    dialog = ExtensionDialog::Show(file_browser_url,
+        owner_browser, tab->web_contents(), kFileManagerWidth,
+        kFileManagerHeight, dialog_title, this /* ExtensionDialog::Observer */);
+  } else {
+    dialog = ExtensionDialog::ShowFullscreen(file_browser_url,
+        profile_, dialog_title, this /* ExtensionDialog::Observer */);
+  }
   if (!dialog) {
     LOG(ERROR) << "Unable to create extension dialog";
     return;
   }
 
   // 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;
 }