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/utf_string_conversions.h"
@@ skipping 357 matching lines @@
     views::View* child = host->child_at(i);
     if (!child->visible())
       continue;
     gfx::Size size(child->GetPreferredSize());
     gfx::Rect child_bounds(x, y, size.width(), child_area.height());
     if (i == host->child_count() - 1) {
       // Last child (the install button) should be right aligned.
       child_bounds.set_x(std::max(child_area.width() - size.width(), x));
     } else if (i == 1) {
       // Label is considered fixed width, to align ratings widget.
-      DCHECK_LE(size.width(), WebIntentPicker::kTitleLinkMaxWidth);
       x += WebIntentPicker::kTitleLinkMaxWidth +
           views::kRelatedControlHorizontalSpacing;
     } else {
       x += size.width() + views::kRelatedControlHorizontalSpacing;
     }
     // Clamp child view bounds to |child_area|.
     child->SetBoundsRect(child_bounds.Intersect(child_area));
   }
 }
 
@@ skipping 398 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 143 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_;
 }
 
 int WebIntentPickerViews::GetDialogButtons() const {
   return ui::DIALOG_BUTTON_NONE;
 }
 
 bool WebIntentPickerViews::Cancel() {
   return can_close_;
 }
 
 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 30 matching lines @@
     const gfx::Size& size) {
   webview_->SetPreferredSize(size);
   contents_->Layout();
   SizeToContents();
 }
 
 void WebIntentPickerViews::OnPendingAsyncCompleted() {
   UpdateContents();
 }
 
+void WebIntentPickerViews::InvalidateDelegate() {
+  delegate_ = NULL;
+}
+
 void WebIntentPickerViews::ShowNoServicesMessage() {
   ClearContents();
 
   views::GridLayout* grid_layout = new views::GridLayout(contents_);
   contents_->SetLayoutManager(grid_layout);
 
   grid_layout->SetInsets(kContentAreaBorder, kContentAreaBorder,
                          kContentAreaBorder, kContentAreaBorder);
   views::ColumnSet* main_cs = grid_layout->AddColumnSet(0);
   main_cs->AddColumn(GridLayout::FILL, GridLayout::LEADING, 1,
@@ skipping 118 matching lines @@
     const std::string& extension_id) {
   if (extensions_)
     extensions_->Update();
 
   contents_->Layout();
   SizeToContents();
 }
 
 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 141 matching lines @@
   // we do not set our weak pointers to NULL, then they will continue to point
   // to where the deleted objects used to be, i.e. unitialized memory. This
   // would cause hard-to-explain crashes.
   contents_->RemoveAllChildViews(true);
   action_label_ = NULL;
   suggestions_label_ = NULL;
   extensions_ = NULL;
   more_suggestions_link_ = NULL;
   choose_another_service_link_ = NULL;
 }