Rebase ExtensionInstalledBubble on the new views bubble.

chrome/browser/ui/views/extensions/extension_installed_bubble.cc

 // Copyright (c) 2011 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/extensions/extension_installed_bubble.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/ui/views/toolbar_view.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "views/controls/button/image_button.h"
 #include "views/controls/image_view.h"
 #include "views/controls/label.h"
 #include "views/controls/link.h"
 #include "views/controls/link_listener.h"
 #include "views/view.h"
 
 namespace {
 
@@ skipping 41 matching lines @@
 // InstalledBubbleContent is the content view which is placed in the
 // ExtensionInstalledBubble. It displays the install icon and explanatory
 // text about the installed extension.
 class InstalledBubbleContent : public views::View,
                                public views::ButtonListener,
                                public views::LinkListener {
  public:
   InstalledBubbleContent(Browser* browser,
                          const Extension* extension,
                          ExtensionInstalledBubble::BubbleType type,
-                         SkBitmap* icon)
+                         SkBitmap* icon,
+                         ExtensionInstalledBubble* bubble)
       : browser_(browser),
         extension_id_(extension->id()),
-        bubble_(NULL),
+        bubble_(bubble),
         type_(type),
         info_(NULL) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     const gfx::Font& font = rb.GetFont(ResourceBundle::BaseFont);
 
     // Scale down to 43x43, but allow smaller icons (don't scale up).
     gfx::Size size(icon->width(), icon->height());
     if (size.width() > kIconSize || size.height() > kIconSize)
       size = gfx::Size(kIconSize, kIconSize);
     icon_ = new views::ImageView();
@@ skipping 58 matching lines @@
     close_button_ = new views::ImageButton(this);
     close_button_->SetImage(views::CustomButton::BS_NORMAL,
         rb.GetBitmapNamed(IDR_CLOSE_BAR));
     close_button_->SetImage(views::CustomButton::BS_HOT,
         rb.GetBitmapNamed(IDR_CLOSE_BAR_H));
     close_button_->SetImage(views::CustomButton::BS_PUSHED,
         rb.GetBitmapNamed(IDR_CLOSE_BAR_P));
     AddChildView(close_button_);
   }
 
-  void set_bubble(Bubble* bubble) { bubble_ = bubble; }
-
-  virtual void ButtonPressed(
-      views::Button* sender,
-      const views::Event& event) {
-    if (sender == close_button_) {
-      bubble_->set_fade_away_on_close(true);
-      GetWidget()->Close();
-    } else {
+  virtual void ButtonPressed(views::Button* sender, const views::Event& event) {
+    if (sender == close_button_)
+      bubble_->StartFade(false);
+    else
       NOTREACHED() << "Unknown view";
-    }
   }
 
   // Implements the views::LinkListener interface.
   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE {
     GetWidget()->Close();
     ExtensionInstallUI::OpenAppInstalledNTP(browser_, extension_id_);
   }
 
  private:
   virtual gfx::Size GetPreferredSize() {
@@ skipping 55 matching lines @@
     // title text and bubble arrow.
     close_button_->SetBounds(x - 1, y - 1, sz.width(), sz.height());
   }
 
   // The browser we're associated with.
   Browser* browser_;
 
   // The id of the extension just installed.
   const std::string extension_id_;
 
-  // The Bubble showing us.
-  Bubble* bubble_;
+  // The ExtensionInstalledBubble showing us.
+  ExtensionInstalledBubble* bubble_;
 
   ExtensionInstalledBubble::BubbleType type_;
   views::ImageView* icon_;
   views::Label* heading_;
   views::Label* info_;
   views::Label* manage_;
   views::ImageButton* close_button_;
 
   DISALLOW_COPY_AND_ASSIGN(InstalledBubbleContent);
 };
 
 void ExtensionInstalledBubble::Show(const Extension* extension,
                                     Browser *browser,
                                     const SkBitmap& icon) {
   new ExtensionInstalledBubble(extension, browser, icon);
 }
 
 ExtensionInstalledBubble::ExtensionInstalledBubble(const Extension* extension,
                                                    Browser *browser,
                                                    const SkBitmap& icon)
     : extension_(extension),
       browser_(browser),
       icon_(icon),
       animation_wait_retries_(0) {
-  AddRef();  // Balanced in BubbleClosing.
-
   if (extension->is_app()) {
     type_ = APP;
   } else if (!extension_->omnibox_keyword().empty()) {
     type_ = OMNIBOX_KEYWORD;
   } else if (extension_->browser_action()) {
     type_ = BROWSER_ACTION;
   } else if (extension->page_action() &&
              !extension->page_action()->default_icon_path().empty()) {
     type_ = PAGE_ACTION;
   } else {
@@ skipping 18 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSION_LOADED) {
     const Extension* extension =
         content::Details<const Extension>(details).ptr();
     if (extension == extension_) {
       animation_wait_retries_ = 0;
       // PostTask to ourself to allow all EXTENSION_LOADED Observers to run.
       MessageLoopForUI::current()->PostTask(
           FROM_HERE,
-          base::Bind(&ExtensionInstalledBubble::ShowInternal, this));
+          base::Bind(&ExtensionInstalledBubble::ShowInternal,
+                     base::Unretained(this)));
     }
   } else if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     const Extension* extension =
         content::Details<UnloadedExtensionInfo>(details)->extension;
     if (extension == extension_)
       extension_ = NULL;
   } else {
     NOTREACHED() << L"Received unexpected notification";
   }
 }
 
 void ExtensionInstalledBubble::ShowInternal() {
   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
 
-  const views::View* reference_view = NULL;
+  views::View* reference_view = NULL;
   if (type_ == APP) {
     if (browser_view->IsTabStripVisible()) {
       AbstractTabStripView* tabstrip = browser_view->tabstrip();
       views::View* ntp_button = tabstrip->GetNewTabButton();
       if (ntp_button && ntp_button->IsVisibleInRootView()) {
         reference_view = ntp_button;
       } else {
         // Just have the bubble point at the tab strip.
         reference_view = tabstrip;
       }
     }
   } else if (type_ == BROWSER_ACTION) {
     BrowserActionsContainer* container =
         browser_view->GetToolbarView()->browser_actions();
     if (container->animating() &&
         animation_wait_retries_++ < kAnimationWaitMaxRetry) {
       // We don't know where the view will be until the container has stopped
       // animating, so check back in a little while.
       MessageLoopForUI::current()->PostDelayedTask(
           FROM_HERE,
-          base::Bind(&ExtensionInstalledBubble::ShowInternal, this),
+          base::Bind(&ExtensionInstalledBubble::ShowInternal,
+                     base::Unretained(this)),
           kAnimationWaitTime);
       return;
     }
     reference_view = container->GetBrowserActionView(
         extension_->browser_action());
     // If the view is not visible then it is in the chevron, so point the
     // install bubble to the chevron instead. If this is an incognito window,
     // both could be invisible.
     if (!reference_view || !reference_view->IsVisible()) {
       reference_view = container->chevron();
       if (!reference_view || !reference_view->IsVisible())
         reference_view = NULL;  // fall back to app menu below.
     }
   } else if (type_ == PAGE_ACTION) {
     LocationBarView* location_bar_view = browser_view->GetLocationBarView();
     location_bar_view->SetPreviewEnabledPageAction(extension_->page_action(),
                                                    true);  // preview_enabled
     reference_view = location_bar_view->GetPageActionView(
         extension_->page_action());
     DCHECK(reference_view);
   } else if (type_ == OMNIBOX_KEYWORD) {
     LocationBarView* location_bar_view = browser_view->GetLocationBarView();
     reference_view = location_bar_view;
     DCHECK(reference_view);
   }
 
   // Default case.
   if (reference_view == NULL)
     reference_view = browser_view->GetToolbarView()->app_menu();
+  set_anchor_view(reference_view);
 
-  gfx::Point origin;
-  views::View::ConvertPointToScreen(reference_view, &origin);
-  gfx::Rect bounds = reference_view->bounds();
-  bounds.set_origin(origin);
-  views::BubbleBorder::ArrowLocation arrow_location =
-      views::BubbleBorder::TOP_RIGHT;
+  SetLayoutManager(new views::FillLayout());
+  AddChildView(
+      new InstalledBubbleContent(browser_, extension_, type_, &icon_, this));
+  views::BubbleDelegateView::CreateBubble(this);
+  StartFade(true);
+}
 
+gfx::Point ExtensionInstalledBubble::GetAnchorPoint() {
   // For omnibox keyword bubbles, move the arrow to point to the left edge
   // of the omnibox, just to the right of the icon.
   if (type_ == OMNIBOX_KEYWORD) {
-    bounds.set_origin(
-        browser_view->GetLocationBarView()->GetLocationEntryOrigin());
-    bounds.set_width(0);
-    arrow_location = views::BubbleBorder::TOP_LEFT;
+    LocationBarView* location_bar_view =
+        BrowserView::GetBrowserViewForBrowser(browser_)->GetLocationBarView();
+    return location_bar_view->GetLocationEntryOrigin().Add(
+        gfx::Point(0, location_bar_view->location_entry_view()->height()));
   }
-
-  bubble_content_ = new InstalledBubbleContent(
-      browser_, extension_, type_, &icon_);
-  Bubble* bubble = Bubble::Show(browser_view->GetWidget(), bounds,
-                                arrow_location,
-                                views::BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
-                                bubble_content_, this);
-  bubble_content_->set_bubble(bubble);
+  return views::BubbleDelegateView::GetAnchorPoint();
 }
 
-// BubbleDelegate
-void ExtensionInstalledBubble::BubbleClosing(Bubble* bubble,
-                                             bool closed_by_escape) {
+views::BubbleBorder::ArrowLocation
+    ExtensionInstalledBubble::GetArrowLocation() const {
+  return type_ == OMNIBOX_KEYWORD ? views::BubbleBorder::TOP_LEFT :
+                                    views::BubbleBorder::TOP_RIGHT;
+}
+
+void ExtensionInstalledBubble::WindowClosing() {
   if (extension_ && type_ == PAGE_ACTION) {
     BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
     browser_view->GetLocationBarView()->SetPreviewEnabledPageAction(
         extension_->page_action(),
         false);  // preview_enabled
   }
-
-  Release();  // Balanced in ctor.
 }
-
-bool ExtensionInstalledBubble::CloseOnEscape() {
-  return true;
-}
-
-bool ExtensionInstalledBubble::FadeInOnShow() {
-  return true;
-}