Disable delegation to picker controller once it is deleted.

chrome/browser/ui/views/web_intent_picker_views.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 <algorithm>
 #include <vector>
 
 #include "base/memory/scoped_vector.h"
 #include "base/time.h"
 #include "base/timer.h"
@@ skipping 911 matching lines @@
   // LinkListener implementation.
   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE;
 
   // WebIntentPicker implementation.
   virtual void Close() OVERRIDE;
   virtual void SetActionString(const string16& action) OVERRIDE;
   virtual void OnExtensionInstallSuccess(const std::string& id) OVERRIDE;
   virtual void OnExtensionInstallFailure(const std::string& id) OVERRIDE;
   virtual void OnInlineDispositionAutoResize(const gfx::Size& size) OVERRIDE;
   virtual void OnPendingAsyncCompleted() OVERRIDE;
+  virtual void InvalidateDelegate() OVERRIDE;
   virtual void OnInlineDispositionWebContentsLoaded(
       content::WebContents* web_contents) OVERRIDE;
 
   // WebIntentPickerModelObserver implementation.
   virtual void OnModelChanged(WebIntentPickerModel* model) OVERRIDE;
   virtual void OnFaviconChanged(WebIntentPickerModel* model,
                                 size_t index) OVERRIDE;
   virtual void OnExtensionIconChanged(WebIntentPickerModel* model,
                                       const std::string& extension_id) OVERRIDE;
   virtual void OnInlineDisposition(const string16& title,
@@ skipping 159 matching lines @@
   else
     UpdateContents();
 }
 
 WebIntentPickerViews::~WebIntentPickerViews() {
   model_->set_observer(NULL);
 }
 
 void WebIntentPickerViews::ButtonPressed(views::Button* sender,
                                          const ui::Event& event) {
+  DCHECK(delegate_);
   delegate_->OnUserCancelledPickerDialog();
 }
 
 void WebIntentPickerViews::WindowClosing() {
-  delegate_->OnClosing();
+  if (delegate_)
+    delegate_->OnClosing();
 }
 
 void WebIntentPickerViews::DeleteDelegate() {
   delete this;
 }
 
 views::Widget* WebIntentPickerViews::GetWidget() {
   return contents_->GetWidget();
 }
 
 const views::Widget* WebIntentPickerViews::GetWidget() const {
   return contents_->GetWidget();
 }
 
 views::View* WebIntentPickerViews::GetContentsView() {
   return contents_;
 }
 
 void WebIntentPickerViews::LinkClicked(views::Link* source, int event_flags) {
+  DCHECK(delegate_);
   if (source == more_suggestions_link_) {
     delegate_->OnSuggestionsLinkClicked(
         chrome::DispositionFromEventFlags(event_flags));
   } else if (source == choose_another_service_link_) {
     // Signal cancellation of inline disposition.
     delegate_->OnChooseAnotherService();
     ResetContents();
   } else {
     NOTREACHED();
   }
@@ skipping 31 matching lines @@
     const gfx::Size& size) {
   webview_->SetPreferredSize(size);
   contents_->Layout();
   SizeToContents();
 }
 
 void WebIntentPickerViews::OnPendingAsyncCompleted() {
   UpdateContents();
 }
 
+void WebIntentPickerViews::InvalidateDelegate() {
+  delegate_ = NULL;
+}
+
 void WebIntentPickerViews::ShowNoServicesMessage() {
   if (state_ == NO_SERVICES)
     return;
   state_ = NO_SERVICES;
 
   ClearContents();
   views::GridLayout* layout = new views::GridLayout(contents_);
   layout->set_minimum_size(gfx::Size(WebIntentPicker::kWindowMinWidth, 0));
   const int kContentBuiltinBottomPadding = 3;
   layout->SetInsets(ConstrainedWindowConstants::kCloseButtonPadding,
@@ skipping 164 matching lines @@
 }
 
 void WebIntentPickerViews::OnExtensionIconChanged(
     WebIntentPickerModel* model,
     const std::string& extension_id) {
   OnFaviconChanged(model, -1);
 }
 
 void WebIntentPickerViews::OnInlineDisposition(
     const string16&, const GURL& url) {
+  DCHECK(delegate_);
   if (!webview_)
     webview_ = new views::WebView(tab_contents_->profile());
 
   inline_web_contents_.reset(delegate_->CreateWebContentsForInlineDisposition(
       tab_contents_->profile(), url));
+
   // Does not take ownership, so we keep a scoped_ptr
   // for the WebContents locally.
   webview_->SetWebContents(inline_web_contents_.get());
   Browser* browser = browser::FindBrowserWithWebContents(
       tab_contents_->web_contents());
   inline_disposition_delegate_.reset(
       new WebIntentInlineDispositionDelegate(this, inline_web_contents_.get(),
                                              browser));
 
   inline_web_contents_->GetController().LoadURL(
       url,
       content::Referrer(),
       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
       std::string());
 
   // Disable all buttons.
   // TODO(groby): Add throbber for inline dispo - see http://crbug.com/142519.
   if (extensions_)
     extensions_->SetEnabled(false);
   if (more_suggestions_link_)
     more_suggestions_link_->SetEnabled(false);
   contents_->Layout();
 }
 
 void WebIntentPickerViews::OnExtensionInstallClicked(
     const std::string& extension_id) {
+  DCHECK(delegate_);
   can_close_ = false;
   extensions_->StartThrobber(extension_id);
   more_suggestions_link_->SetEnabled(false);
   contents_->Layout();
   delegate_->OnExtensionInstallRequested(extension_id);
 }
 
 void WebIntentPickerViews::OnExtensionLinkClicked(
     const std::string& extension_id,
     WindowOpenDisposition disposition) {
+  DCHECK(delegate_);
   delegate_->OnExtensionLinkClicked(extension_id, disposition);
 }
 
 void WebIntentPickerViews::OnActionButtonClicked(
     IntentRowView::ActionType type, size_t tag) {
+  DCHECK(delegate_);
   DCHECK_EQ(IntentRowView::ACTION_INVOKE, type);
   const WebIntentPickerModel::InstalledService& service =
       model_->GetInstalledServiceAt(tag);
   delegate_->OnServiceChosen(service.url, service.disposition,
                              WebIntentPickerDelegate::kEnableDefaults);
 }
 
 void WebIntentPickerViews::UpdateContents() {
   if (model_ && model_->IsInlineDisposition())
     return;
@@ skipping 158 matching lines @@
   if (inline_service)
     inline_service_icon_->SetImage(inline_service->favicon.ToImageSkia());
 }
 
 void WebIntentPickerViews::RefreshExtensions() {
   DCHECK(extensions_);
   extensions_->Update();
   contents_->Layout();
   SizeToContents();
 }