Handle termination/crashes of an extension hosted in the ExtensionDialog.

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/extensions/extension_file_browser_private_api.h"
 #include "chrome/browser/extensions/extension_host.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/file_manager_util.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/views/extensions/extension_dialog.h"
 #include "chrome/browser/ui/views/window.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 63 matching lines @@
 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_window_(0),
+      owner_browser_(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::ExtensionDialogClosing(
     ExtensionDialog* dialog) {
+  owner_browser_ = 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::ExtensionDialogTerminated(

[Aaron Boodman, 2012/02/09 20:23:23]

Why do we need this bit? From looking at the current code, it looks like the
extension will get reloaded (assuming ExtensionService actually knows how to
reload component extensions, which it does with your other changes) the first
time anyone tries to navigate a view to a corresponding chrome-extension:// URL.

[rkc, 2012/02/10 00:35:42]

So we need to at least close the dialog window, which otherwise remains open
with no content in it :)

I tested this with removing the explicit reload code (the posted task) and the
extension doesn't reload. With this code removed, the crashed extension
notification does come up, clicking the "reload" option on which does reload the
extension and allows the select file dialog to come up again, but not otherwise.

[Yoyo Zhou, 2012/02/10 00:45:28]

Does it work without using PostTask? This seems somewhat suspect. If we need to
wait for the extension to get Unloaded, it seems like we should wait for that
event (EXTENSION_UNLOADED) instead of EXTENSION_TERMINATED.

+    ExtensionDialog* dialog) {
+  LOG(ERROR) << "Select File Dialog Extension crashed.";
+
+  // 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.
+  if (owner_browser_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &ExtensionService::ReloadExtension,
+            base::Unretained(owner_browser_->profile()->
+                             GetExtensionService()),
+            extension_id));
+  }
+
+  dialog->Close();
+}
+
 // static
 void SelectFileDialogExtension::OnFileSelected(
     int32 tab_id, const FilePath& path, int index) {
   scoped_refptr<SelectFileDialogExtension> dialog =
       PendingDialog::GetInstance()->Find(tab_id);
   if (!dialog)
     return;
   dialog->selection_type_ = SINGLE_FILE;
   dialog->selection_files_.clear();
   dialog->selection_files_.push_back(path);
@@ skipping 68 matching lines @@
     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.
-  Browser* owner_browser = (owner_window ?
+  owner_browser_ = (owner_window ?
       BrowserList::FindBrowserWithWindow(owner_window) :
       BrowserList::GetLastActive());
-  if (!owner_browser) {
+  if (!owner_browser_) {
     NOTREACHED() << "Can't find owning browser";
     return;
   }
 
-  TabContentsWrapper* tab = owner_browser->GetSelectedTabContentsWrapper();
+  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)) {
     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)) {
+          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;
 
   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(),
+      owner_browser_, tab->web_contents(),
       kFileManagerWidth, kFileManagerHeight,
 #if defined(USE_AURA)
       file_manager_util::GetTitleFromType(type),
 #else
       // HTML-based header used.
       string16(),
 #endif
       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;
 }