Add a flag that lets the webstore show a different UI on app install.

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 "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/views/browser_actions_container.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
+#include "chrome/browser/ui/views/tabs/tab_strip.h"
 #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/common/notification_details.h"
 #include "content/common/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 "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/layout/layout_constants.h"
 #include "views/view.h"
 
 namespace {
 
 const int kIconSize = 43;
 
 const int kRightColumnWidth = 285;
 
 // The Bubble uses a BubbleBorder which adds about 6 pixels of whitespace
@@ skipping 30 matching lines @@
     Profile* profile) {
   ExtensionInstalledBubble::Show(extension, browser, icon);
 }
 
 } // namespace browser
 
 // 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::ButtonListener,
+                               public views::LinkListener {
  public:
-  InstalledBubbleContent(const Extension* extension,
+  InstalledBubbleContent(Browser* browser,
+                         const Extension* extension,
                          ExtensionInstalledBubble::BubbleType type,
                          SkBitmap* icon)
-      : bubble_(NULL),
+      : browser_(browser),
+        extension_id_(extension->id()),
+        bubble_(NULL),
         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();
     icon_->SetImageSize(size);
     icon_->SetImage(*icon);
     AddChildView(icon_);
 
     string16 extension_name = UTF8ToUTF16(extension->name());
     base::i18n::AdjustStringForLocaleDirection(&extension_name);
     heading_ = new views::Label(UTF16ToWide(
         l10n_util::GetStringFUTF16(IDS_EXTENSION_INSTALLED_HEADING,
                                    extension_name)));
     heading_->SetFont(rb.GetFont(ResourceBundle::MediumFont));
     heading_->SetMultiLine(true);
     heading_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
     AddChildView(heading_);
 
-    if (type_ == ExtensionInstalledBubble::PAGE_ACTION) {
-      info_ = new views::Label(UTF16ToWide(l10n_util::GetStringUTF16(
-          IDS_EXTENSION_INSTALLED_PAGE_ACTION_INFO)));
-      info_->SetFont(font);
-      info_->SetMultiLine(true);
-      info_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
-      AddChildView(info_);
+    switch (type_) {
+      case ExtensionInstalledBubble::PAGE_ACTION: {
+        info_ = new views::Label(UTF16ToWide(l10n_util::GetStringUTF16(
+            IDS_EXTENSION_INSTALLED_PAGE_ACTION_INFO)));
+        info_->SetFont(font);
+        info_->SetMultiLine(true);
+        info_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+        AddChildView(info_);
+        break;
+      }
+      case ExtensionInstalledBubble::OMNIBOX_KEYWORD: {
+        info_ = new views::Label(UTF16ToWide(l10n_util::GetStringFUTF16(
+            IDS_EXTENSION_INSTALLED_OMNIBOX_KEYWORD_INFO,
+            UTF8ToUTF16(extension->omnibox_keyword()))));
+        info_->SetFont(font);
+        info_->SetMultiLine(true);
+        info_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+        AddChildView(info_);
+        break;
+      }
+      case ExtensionInstalledBubble::APP: {
+        views::Link* link = new views::Link(UTF16ToWide(
+            l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALLED_APP_INFO)));
+        link->set_listener(this);
+        manage_ = link;
+        manage_->SetFont(font);
+        manage_->SetMultiLine(true);
+        manage_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+        AddChildView(manage_);
+        break;
+      }
+      default:
+        break;
     }
 
-    if (type_ == ExtensionInstalledBubble::OMNIBOX_KEYWORD) {
-      info_ = new views::Label(UTF16ToWide(l10n_util::GetStringFUTF16(
-          IDS_EXTENSION_INSTALLED_OMNIBOX_KEYWORD_INFO,
-          UTF8ToUTF16(extension->omnibox_keyword()))));
-      info_->SetFont(font);
-      info_->SetMultiLine(true);
-      info_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
-      AddChildView(info_);
+    if (type_ != ExtensionInstalledBubble::APP) {
+      manage_ = new views::Label(UTF16ToWide(
+          l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALLED_MANAGE_INFO)));
+      manage_->SetFont(font);
+      manage_->SetMultiLine(true);
+      manage_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+      AddChildView(manage_);
     }
 
-    manage_ = new views::Label(UTF16ToWide(
-        l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALLED_MANAGE_INFO)));
-    manage_->SetFont(font);
-    manage_->SetMultiLine(true);
-    manage_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
-    AddChildView(manage_);
-
     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 {
       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() {
     int width = kHorizOuterMargin;
     width += kIconSize;
     width += views::kPanelHorizMargin;
     width += kRightColumnWidth;
     width += 2 * views::kPanelHorizMargin;
     width += kHorizOuterMargin;
 
     int height = kVertOuterMargin;
     height += heading_->GetHeightForWidth(kRightColumnWidth);
     height += kVertInnerMargin;
-    if (type_ == ExtensionInstalledBubble::PAGE_ACTION ||
-        type_ == ExtensionInstalledBubble::OMNIBOX_KEYWORD) {
+    if (info_) {
       height += info_->GetHeightForWidth(kRightColumnWidth);
       height += kVertInnerMargin;
     }
     height += manage_->GetHeightForWidth(kRightColumnWidth);
     height += kVertOuterMargin;
 
     return gfx::Size(width, std::max(height, kIconSize + 2 * kVertOuterMargin));
   }
 
   virtual void Layout() {
     int x = kHorizOuterMargin;
     int y = kVertOuterMargin;
 
     icon_->SetBounds(x, y, kIconSize, kIconSize);
     x += kIconSize;
     x += views::kPanelHorizMargin;
 
     y += kRightcolumnVerticalShift;
     heading_->SizeToFit(kRightColumnWidth);
     heading_->SetX(x);
     heading_->SetY(y);
     y += heading_->height();
     y += kVertInnerMargin;
 
-    if (type_ == ExtensionInstalledBubble::PAGE_ACTION ||
-        type_ == ExtensionInstalledBubble::OMNIBOX_KEYWORD) {
+    if (info_) {
       info_->SizeToFit(kRightColumnWidth);
       info_->SetX(x);
       info_->SetY(y);
       y += info_->height();
       y += kVertInnerMargin;
     }
 
     manage_->SizeToFit(kRightColumnWidth);
     manage_->SetX(x);
     manage_->SetY(y);
     y += manage_->height();
     y += kVertInnerMargin;
 
     gfx::Size sz;
     x += kRightColumnWidth + 2 * views::kPanelHorizMargin + kHorizOuterMargin -
         close_button_->GetPreferredSize().width();
     y = kVertOuterMargin;
     sz = close_button_->GetPreferredSize();
     // x-1 & y-1 is just slop to get the close button visually aligned with the
     // 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_;
 
   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_->omnibox_keyword().empty()) {
+  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 {
     type_ = GENERIC;
   }
 
@@ skipping 29 matching lines @@
   } else {
     NOTREACHED() << L"Received unexpected notification";
   }
 }
 
 void ExtensionInstalledBubble::ShowInternal() {
   BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(
       browser_->window()->GetNativeHandle());
 
   const views::View* reference_view = NULL;
-  if (type_ == BROWSER_ACTION) {
+  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, NewRunnableMethod(this,
           &ExtensionInstalledBubble::ShowInternal), kAnimationWaitTime);
       return;
@@ skipping 33 matching lines @@
 
   // 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 = BubbleBorder::TOP_LEFT;
   }
 
-  bubble_content_ = new InstalledBubbleContent(extension_, type_, &icon_);
+  bubble_content_ = new InstalledBubbleContent(
+      browser_, extension_, type_, &icon_);
   Bubble* bubble = Bubble::Show(browser_view->GetWidget(), bounds,
                                 arrow_location, bubble_content_, this);
   bubble_content_->set_bubble(bubble);
 }
 
 // BubbleDelegate
 void ExtensionInstalledBubble::BubbleClosing(Bubble* bubble,
                                              bool closed_by_escape) {
   if (extension_ && type_ == PAGE_ACTION) {
     BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(
         browser_->window()->GetNativeHandle());
     browser_view->GetLocationBarView()->SetPreviewEnabledPageAction(
         extension_->page_action(),
         false);  // preview_enabled
   }
 
   Release();  // Balanced in ctor.
 }
 
 bool ExtensionInstalledBubble::CloseOnEscape() {
   return true;
 }
 
 bool ExtensionInstalledBubble::FadeInOnShow() {
   return true;
 }