Fixing a lifetime issue for Speech Recognition Bubble

chrome/browser/ui/views/speech_recognition_bubble_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 "chrome/browser/speech/speech_recognition_bubble.h"
 
 #include <algorithm>
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 13 matching lines @@
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/link_listener.h"
 #include "ui/views/layout/layout_constants.h"
 
 using content::WebContents;
 
 namespace {
 
+class SpeechRecognitionBubbleViewLifeTimeObserver {

[msw, 2014/03/31 16:53:30]

Use the pre-existing WidgetObserver, which already has an OnWidgetDestroyed
callback, and wouldn't necessitate any changes to the
SpeechRecognitionBubbleView class.

[Tommy Widenflycht, 2014/04/01 11:29:03]

Done.

+ public:
+  virtual void BubbleViewGoingAway() = 0;
+};
+
 const int kBubbleHorizMargin = 6;
 const int kBubbleVertMargin = 4;
 const int kBubbleHeadingVertMargin = 6;
 
 // This is the SpeechRecognitionBubble content and views bubble delegate.
 class SpeechRecognitionBubbleView : public views::BubbleDelegateView,
                                     public views::ButtonListener,
                                     public views::LinkListener {
  public:
   SpeechRecognitionBubbleView(SpeechRecognitionBubbleDelegate* delegate,
                               views::View* anchor_view,
                               const gfx::Rect& element_rect,
                               WebContents* web_contents);
 
+  void SetLifeTimeObserver(
+      SpeechRecognitionBubbleViewLifeTimeObserver* life_time_observer);
+
   void UpdateLayout(SpeechRecognitionBubbleBase::DisplayMode mode,
                     const base::string16& message_text,
                     const gfx::ImageSkia& image);
   void SetImage(const gfx::ImageSkia& image);
 
   // views::BubbleDelegateView methods.
   virtual void OnWidgetActivationChanged(views::Widget* widget,
                                          bool active) OVERRIDE;
+  virtual void OnWidgetDestroyed(views::Widget* widget) OVERRIDE;
   virtual gfx::Rect GetAnchorRect() OVERRIDE;
   virtual void Init() OVERRIDE;
 
   // views::ButtonListener methods.
   virtual void ButtonPressed(views::Button* source,
                              const ui::Event& event) OVERRIDE;
 
   // views::LinkListener methods.
   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE;
 
@@ skipping 12 matching lines @@
   WebContents* web_contents_;
   bool notify_delegate_on_activation_change_;
   views::ImageView* icon_;
   views::Label* heading_;
   views::Label* message_;
   views::LabelButton* try_again_;
   views::LabelButton* cancel_;
   views::Link* mic_settings_;
   SpeechRecognitionBubbleBase::DisplayMode display_mode_;
   const int kIconLayoutMinWidth;
+  SpeechRecognitionBubbleViewLifeTimeObserver* life_time_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(SpeechRecognitionBubbleView);
 };
 
 SpeechRecognitionBubbleView::SpeechRecognitionBubbleView(
     SpeechRecognitionBubbleDelegate* delegate,
     views::View* anchor_view,
     const gfx::Rect& element_rect,
     WebContents* web_contents)
     : BubbleDelegateView(anchor_view, views::BubbleBorder::TOP_LEFT),
@@ skipping 14 matching lines @@
   // on deactivation will cause unexpected behavior.
   set_close_on_deactivate(false);
   // Prevent default behavior of bubble closure on escape key and handle
   // it in the AcceleratorPressed() to avoid an unexpected behavior.
   set_close_on_esc(false);
 
   // Update the bubble's bounds when the window's bounds changes.
   set_move_with_anchor(true);
 }
 
+void SpeechRecognitionBubbleView::SetLifeTimeObserver(
+    SpeechRecognitionBubbleViewLifeTimeObserver* life_time_observer) {
+  DCHECK((!life_time_observer_ && life_time_observer) ||
+         (life_time_observer_ && !life_time_observer));
+  life_time_observer_ = life_time_observer;
+}
+
+void SpeechRecognitionBubbleView::OnWidgetDestroyed(views::Widget* widget) {
+  BubbleDelegateView::OnWidgetDestroyed(widget);
+  if (life_time_observer_)
+    life_time_observer_->BubbleViewGoingAway();
+}
+
 void SpeechRecognitionBubbleView::OnWidgetActivationChanged(
     views::Widget* widget, bool active) {
   if (widget == GetWidget() && !active && notify_delegate_on_activation_change_)
     delegate_->InfoBubbleFocusChanged();
   BubbleDelegateView::OnWidgetActivationChanged(widget, active);
 }
 
 gfx::Rect SpeechRecognitionBubbleView::GetAnchorRect() {
   gfx::Rect container_rect;
   web_contents_->GetView()->GetContainerBounds(&container_rect);
@@ skipping 188 matching lines @@
     if (cancel_->visible()) {
       control_height = cancel_->GetPreferredSize().height();
       int width = cancel_->GetPreferredSize().width();
       cancel_->SetBounds(x + (available_width - width) / 2, y, width,
                          control_height);
     }
   }
 }
 
 // Implementation of SpeechRecognitionBubble.
-class SpeechRecognitionBubbleImpl : public SpeechRecognitionBubbleBase {
+class SpeechRecognitionBubbleImpl
+    : public SpeechRecognitionBubbleBase,
+      public SpeechRecognitionBubbleViewLifeTimeObserver {
  public:
   SpeechRecognitionBubbleImpl(int render_process_id, int render_view_id,
                               Delegate* delegate,
                               const gfx::Rect& element_rect);
   virtual ~SpeechRecognitionBubbleImpl();
 
   // SpeechRecognitionBubble methods.
   virtual void Show() OVERRIDE;
   virtual void Hide() OVERRIDE;
 
   // SpeechRecognitionBubbleBase methods.
   virtual void UpdateLayout() OVERRIDE;
   virtual void UpdateImage() OVERRIDE;
 
+  // SpeechRecognitionBubbleViewLifeTimeObserver methods.
+  virtual void BubbleViewGoingAway() OVERRIDE;
+
  private:
   Delegate* delegate_;
   SpeechRecognitionBubbleView* bubble_;
   gfx::Rect element_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(SpeechRecognitionBubbleImpl);
 };
 
 SpeechRecognitionBubbleImpl::SpeechRecognitionBubbleImpl(
     int render_process_id, int render_view_id, Delegate* delegate,
     const gfx::Rect& element_rect)
     : SpeechRecognitionBubbleBase(render_process_id, render_view_id),
       delegate_(delegate),
       bubble_(NULL),
       element_rect_(element_rect) {
 }
 
 SpeechRecognitionBubbleImpl::~SpeechRecognitionBubbleImpl() {
   if (bubble_) {
+    bubble_->SetLifeTimeObserver(NULL);
     bubble_->set_notify_delegate_on_activation_change(false);
     bubble_->GetWidget()->Close();
   }
 }
 
+void SpeechRecognitionBubbleImpl::BubbleViewGoingAway() {
+  bubble_ = NULL;
+}
+
 void SpeechRecognitionBubbleImpl::Show() {
   WebContents* web_contents = GetWebContents();
   if (!web_contents)
     return;
 
   if (!bubble_) {
     views::View* icon = NULL;
 
     // Anchor to the location bar, in case |element_rect| is offscreen.
     Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
     if (browser) {
       BrowserView* browser_view =
           BrowserView::GetBrowserViewForBrowser(browser);
       icon = browser_view->GetLocationBarView() ?
           browser_view->GetLocationBarView()->GetLocationBarAnchor() : NULL;
     }
 
     bubble_ = new SpeechRecognitionBubbleView(delegate_, icon, element_rect_,
                                               web_contents);
+    bubble_->SetLifeTimeObserver(this);
 
     if (!icon) {
       // We dont't have an icon to attach to. Manually specify the web contents
       // window as the parent.
       bubble_->set_parent_window(
           web_contents->GetView()->GetTopLevelNativeWindow());
     }
 
     views::BubbleDelegateView::CreateBubble(bubble_);
     UpdateLayout();
@@ skipping 19 matching lines @@
 }  // namespace
 
 SpeechRecognitionBubble* SpeechRecognitionBubble::CreateNativeBubble(
     int render_process_id,
     int render_view_id,
     SpeechRecognitionBubble::Delegate* delegate,
     const gfx::Rect& element_rect) {
   return new SpeechRecognitionBubbleImpl(render_process_id, render_view_id,
       delegate, element_rect);
 }