Add a shortcut to open the Apps page from the bookmark bar.

chrome/browser/ui/views/bookmarks/bookmark_bar_view.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/ui/views/bookmarks/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 12 matching lines @@
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar_constants.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/chrome_pages.h"
+#include "chrome/browser/ui/search/search.h"
 #include "chrome/browser/ui/search/search_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_instructions_view.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_context_menu.h"
 #include "chrome/browser/ui/views/event_utils.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/webui/ntp/app_launcher_handler.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 97 matching lines @@
 // is only needed locally.
 static const int kSearchNewTabBookmarkBarHeight = 36;
 
 // TODO(kuan): change BookmarkBarView::kNewtabHorizontalPadding and
 // BookmarkBarView::kNewtabVerticalPadding to these new values when search_ntp
 // replaces ntp4; for now, while both versions exist, these new values are only
 // needed locally.
 static const int kSearchNewTabHorizontalPadding = 0;
 static const int kSearchNewTabVerticalPadding = 0;
 
+// Tag for the 'Apps Shortcut' button.
+static const int kAppsShortcutButtonTag = 2;
+
 namespace {
 
+// BookmarkButtonBase -----------------------------------------------
+
+// Base class for text buttons used on the bookmark bar.
+
+class BookmarkButtonBase : public views::TextButton {
+ public:
+  BookmarkButtonBase(views::ButtonListener* listener,
+                     const string16& title)
+      : TextButton(listener, title) {
+    show_animation_.reset(new ui::SlideAnimation(this));
+    if (bookmark_utils::IsBookmarkBarViewAnimationsDisabled()) {
+      // For some reason during testing the events generated by anima
+      // throw off the test. So, don't animate while testing.
+      show_animation_->Reset(1);
+    } else {
+      show_animation_->Show();
+    }
+  }
+
+  virtual bool IsTriggerableEvent(const ui::Event& e) OVERRIDE {
+    return e.type() == ui::ET_GESTURE_TAP ||
+           e.type() == ui::ET_GESTURE_TAP_DOWN ||
+           event_utils::IsPossibleDispositionEvent(e);
+  }
+
+ private:
+  scoped_ptr<ui::SlideAnimation> show_animation_;
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkButtonBase);
+};
+
 // BookmarkButton -------------------------------------------------------------
 
 // Buttons used for the bookmarks on the bookmark bar.
 
-class BookmarkButton : public views::TextButton {
+class BookmarkButton : public BookmarkButtonBase {
  public:
   // The internal view class name.
   static const char kViewClassName[];
 
   BookmarkButton(views::ButtonListener* listener,
                  const GURL& url,
                  const string16& title,
                  Profile* profile)
-      : TextButton(listener, title),
+      : BookmarkButtonBase(listener, title),
         url_(url),
         profile_(profile) {
-    show_animation_.reset(new ui::SlideAnimation(this));
-    if (bookmark_utils::IsBookmarkBarViewAnimationsDisabled()) {
-      // For some reason during testing the events generated by animating
-      // throw off the test. So, don't animate while testing.
-      show_animation_->Reset(1);
-    } else {
-      show_animation_->Show();
-    }
   }
 
   virtual bool GetTooltipText(const gfx::Point& p,
                               string16* tooltip) const OVERRIDE {
     gfx::Point location(p);
     ConvertPointToScreen(this, &location);
     *tooltip = BookmarkBarView::CreateToolTipForURLAndTitle(
         location, url_, text(), profile_, GetWidget()->GetNativeView());
     return !tooltip->empty();
   }
 
-  virtual bool IsTriggerableEvent(const ui::Event& e) OVERRIDE {
-    return e.type() == ui::ET_GESTURE_TAP ||
-           e.type() == ui::ET_GESTURE_TAP_DOWN ||
-           event_utils::IsPossibleDispositionEvent(e);
-  }
-
   virtual std::string GetClassName() const OVERRIDE {
     return kViewClassName;
   }
 
  private:
   const GURL& url_;
   Profile* profile_;
-  scoped_ptr<ui::SlideAnimation> show_animation_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkButton);
 };
 
 // static for BookmarkButton
 const char BookmarkButton::kViewClassName[] =
     "browser/ui/views/bookmarks/BookmarkButton";
 
+// ShortcutButton -------------------------------------------------------------
+
+// Buttons used for the shortcuts on the bookmark bar.
+
+class ShortcutButton : public BookmarkButtonBase {
+ public:
+  // The internal view class name.
+  static const char kViewClassName[];
+
+  ShortcutButton(views::ButtonListener* listener,
+                 const string16& title)
+      : BookmarkButtonBase(listener, title) {
+  }
+
+  virtual std::string GetClassName() const OVERRIDE {
+    return kViewClassName;
+  }
+
+ private:
+
+  DISALLOW_COPY_AND_ASSIGN(ShortcutButton);
+};
+
+// static for ShortcutButton
+const char ShortcutButton::kViewClassName[] =
+    "browser/ui/views/bookmarks/ShortcutButton";
+
 // BookmarkFolderButton -------------------------------------------------------
 
 // Buttons used for folders on the bookmark bar, including the 'other folders'
 // button.
 class BookmarkFolderButton : public views::MenuButton {
  public:
   BookmarkFolderButton(views::ButtonListener* listener,
                        const string16& title,
                        views::MenuButtonListener* menu_button_listener,
                        bool show_menu_marker)
@@ skipping 180 matching lines @@
   }
   return *kFolderIcon;
 }
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
     : page_navigator_(NULL),
       model_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
+      apps_page_shortcut_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(show_folder_method_factory_(this)),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       browser_view_(browser_view),
       infobar_visible_(false),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false) {
@@ skipping 201 matching lines @@
   // button, by which one can access all the Bookmark Bar items, and the "Other
   // Bookmarks" folder, along with appropriate margins and button padding.
   int width = kLeftMargin;
 
   if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     width += 2 * static_cast<int>(GetNewtabHorizontalPadding(
         browser_->search_model()->mode()) * current_state);
   }
 
-  gfx::Size other_bookmarked_pref =
-      other_bookmarked_button_->GetPreferredSize();
-  gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
-  gfx::Size bookmarks_separator_pref =
-      bookmarks_separator_view_->GetPreferredSize();
+  gfx::Size other_bookmarked_pref;
+  if (other_bookmarked_button_->visible())
+    other_bookmarked_pref = other_bookmarked_button_->GetPreferredSize();
+  gfx::Size overflow_pref;
+  if (overflow_button_->visible())
+    overflow_pref = overflow_button_->GetPreferredSize();
+  gfx::Size bookmarks_separator_pref;
+  if (bookmarks_separator_view_->visible())
+    bookmarks_separator_pref = bookmarks_separator_view_->GetPreferredSize();
 
+  gfx::Size apps_page_shortcut_pref;
+  if (apps_page_shortcut_->visible())
+    apps_page_shortcut_pref = apps_page_shortcut_->GetPreferredSize();
   width += other_bookmarked_pref.width() + kButtonPadding +
+      apps_page_shortcut_pref.width() + kButtonPadding +
       overflow_pref.width() + kButtonPadding +
       bookmarks_separator_pref.width();
 
   return gfx::Size(width, browser_defaults::kBookmarkBarHeight);
 }
 
 void BookmarkBarView::Layout() {
   LayoutItems(false);
 }
 
@@ skipping 420 matching lines @@
 
   bookmark_utils::RecordBookmarkFolderOpen(GetBookmarkLaunchLocation());
   bookmark_menu_ = new BookmarkMenuController(browser_,
       page_navigator_, GetWidget(), node, start_index);
   bookmark_menu_->set_observer(this);
   bookmark_menu_->RunMenuAt(this, false);
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender,
                                     const ui::Event& event) {
+  if (sender->tag() == kAppsShortcutButtonTag) {
+    chrome::ShowAppLauncherPage(browser_);
+    bookmark_utils::RecordAppsPageOpen(GetBookmarkLaunchLocation());
+    return;
+  }
+
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else {
     int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
     node = model_->bookmark_bar_node()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
@@ skipping 19 matching lines @@
   if (!model_->IsLoaded()) {
     // Don't do anything if the model isn't loaded.
     return;
   }
 
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarked_button_) {
     parent = model_->other_node();
     // Do this so the user can open all bookmarks. BookmarkContextMenu makes
-    // sure the user can edit/delete the node in this case.
+    // sure the user can't edit/delete the node in this case.
     nodes.push_back(parent);
-  } else if (source != this) {
+  } else if (source != this && source != apps_page_shortcut_) {
     // User clicked on one of the bookmark buttons, find which one they
-    // clicked on.
+    // clicked on, except for the apps page shortcut, which must behave as if
+    // the user clicked on the bookmark bar background.
     int bookmark_button_index = GetIndexOf(source);
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
     const BookmarkNode* node =
         model_->bookmark_bar_node()->GetChild(bookmark_button_index);
     nodes.push_back(node);
     parent = node->parent();
   } else {
     parent = model_->bookmark_bar_node();
     nodes.push_back(parent);
@@ skipping 23 matching lines @@
   // Child views are traversed in the order they are added. Make sure the order
   // they are added matches the visual order.
   overflow_button_ = CreateOverflowButton();
   AddChildView(overflow_button_);
 
   other_bookmarked_button_ = CreateOtherBookmarkedButton();
   // We'll re-enable when the model is loaded.
   other_bookmarked_button_->SetEnabled(false);
   AddChildView(other_bookmarked_button_);
 
+  apps_page_shortcut_ = CreateAppsPageShortcutButton();
+  AddChildView(apps_page_shortcut_);
+  profile_pref_registrar_.Init(browser_->profile()->GetPrefs());
+  profile_pref_registrar_.Add(
+      prefs::kShowAppsShortcutInBookmarkBar,
+      base::Bind(&BookmarkBarView::OnAppsPageShortcutVisibilityChanged,
+      base::Unretained(this)));
+  apps_page_shortcut_->SetVisible(ShouldShowAppsShortcut());
+
   bookmarks_separator_view_ = new ButtonSeparatorView();
   AddChildView(bookmarks_separator_view_);
-#if defined(USE_ASH)
-  // Ash does not paint the bookmarks separator line because it looks odd on
-  // the flat background.  We keep it present for layout, but don't draw it.
-  bookmarks_separator_view_->SetVisible(false);
-#endif
+  UpdateBookmarksSeparatorVisibility();
 
   instructions_ = new BookmarkBarInstructionsView(this);
   AddChildView(instructions_);
 
   set_context_menu_controller(this);
 
   size_animation_.reset(new ui::SlideAnimation(this));
 
   model_ = BookmarkModelFactory::GetForProfile(browser_->profile());
   if (model_) {
     model_->AddObserver(this);
     if (model_->IsLoaded())
       Loaded(model_, false);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
   // We contain four non-bookmark button views: other bookmarks, bookmarks
-  // separator, chevrons (for overflow), and the instruction label.
-  return child_count() - 4;
+  // separator, chevrons (for overflow), apps page, and the instruction label.
+  return child_count() - 5;
 }
 
 views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   return static_cast<views::TextButton*>(child_at(index));
 }
 
 bookmark_utils::BookmarkLaunchLocation
     BookmarkBarView::GetBookmarkLaunchLocation() const {
   return IsDetached() ? bookmark_utils::LAUNCH_DETACHED_BAR :
@@ skipping 49 matching lines @@
     return button;
   } else {
     views::MenuButton* button = new BookmarkFolderButton(
         this, node->GetTitle(), this, false);
     button->SetIcon(GetFolderIcon());
     ConfigureButton(node, button);
     return button;
   }
 }
 
+views::TextButton* BookmarkBarView::CreateAppsPageShortcutButton() {
+  views::TextButton* button = new ShortcutButton(
+      this, l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_APPS_SHORTCUT_NAME));
+  button->SetTooltipText(l10n_util::GetStringUTF16(
+      IDS_BOOKMARK_BAR_APPS_SHORTCUT_TOOLTIP));
+  button->set_id(VIEW_ID_BOOKMARK_BAR_ELEMENT);
+  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+  button->SetIcon(*rb.GetImageSkiaNamed(IDR_WEBSTORE_ICON_16));
+  button->set_context_menu_controller(this);
+  button->set_tag(kAppsShortcutButtonTag);
+  return button;
+}
+
 void BookmarkBarView::ConfigureButton(const BookmarkNode* node,
                                       views::TextButton* button) {
   button->SetText(node->GetTitle());
   button->SetAccessibleName(node->GetTitle());
   button->set_id(VIEW_ID_BOOKMARK_BAR_ELEMENT);
   // We don't always have a theme provider (ui tests, for example).
   if (GetThemeProvider()) {
     button->SetEnabledColor(GetThemeProvider()->GetColor(
         ThemeProperties::COLOR_BOOKMARK_TEXT));
   }
@@ skipping 294 matching lines @@
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetEnabledColor(text_color);
   other_bookmarked_button()->SetEnabledColor(text_color);
 }
 
 void BookmarkBarView::UpdateOtherBookmarksVisibility() {
   bool has_other_children = !model_->other_node()->empty();
   if (has_other_children == other_bookmarked_button_->visible())
     return;
   other_bookmarked_button_->SetVisible(has_other_children);
-#if !defined(USE_ASH)
-  bookmarks_separator_view_->SetVisible(has_other_children);
-#endif
+  UpdateBookmarksSeparatorVisibility();
   Layout();
   SchedulePaint();
 }
 
+void BookmarkBarView::UpdateBookmarksSeparatorVisibility() {
+  // Ash does not paint the bookmarks separator line because it looks odd on
+  // the flat background.  We keep it present for layout, but don't draw it.
+  bookmarks_separator_view_->SetVisible(
+      browser_->host_desktop_type() != chrome::HOST_DESKTOP_TYPE_ASH &&
+      (other_bookmarked_button_->visible() ||
+          apps_page_shortcut_->visible()));
+}
+
 gfx::Size BookmarkBarView::LayoutItems(bool compute_bounds_only) {
   gfx::Size prefsize;
   if (!parent() && !compute_bounds_only)
     return prefsize;
 
   const chrome::search::Mode& mode = browser_->search_model()->mode();
   int x = kLeftMargin;
   int top_margin = IsDetached() ?
       (mode.is_ntp() ? kSearchDetachedTopMargin : kDetachedTopMargin) : 0;
   int y = top_margin;
@@ skipping 15 matching lines @@
     // also matches how we layout infobars.
     y += View::height() - browser_defaults::kBookmarkBarHeight;
     height += browser_defaults::kBookmarkBarHeight;
   }
 
   gfx::Size other_bookmarked_pref = other_bookmarked_button_->visible() ?
       other_bookmarked_button_->GetPreferredSize() : gfx::Size();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
+  gfx::Size apps_page_shortcut_pref = apps_page_shortcut_->visible() ?
+      apps_page_shortcut_->GetPreferredSize() : gfx::Size();
 
   int max_x = width - overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width();
   if (other_bookmarked_button_->visible())
     max_x -= other_bookmarked_pref.width() + kButtonPadding;
+  if (apps_page_shortcut_->visible())
+    max_x -= apps_page_shortcut_pref.width() + kButtonPadding;
 
   // Next, layout out the buttons. Any buttons that are placed beyond the
   // visible region and made invisible.
   if (GetBookmarkButtonCount() == 0 && model_ && model_->IsLoaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
     if (!compute_bounds_only) {
       instructions_->SetBounds(
           x + kInstructionsPadding, y,
           std::min(static_cast<int>(pref.width()),
           max_x - x),
@@ skipping 48 matching lines @@
 
   // The other bookmarks button.
   if (other_bookmarked_button_->visible()) {
     if (!compute_bounds_only) {
       other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
                                           height);
     }
     x += other_bookmarked_pref.width() + kButtonPadding;
   }
 
+  // The app page shortcut button.
+  if (apps_page_shortcut_->visible()) {
+    if (!compute_bounds_only) {
+      apps_page_shortcut_->SetBounds(x, y, apps_page_shortcut_pref.width(),
+                                     height);
+    }
+    x += apps_page_shortcut_pref.width() + kButtonPadding;
+  }
+
   // Set the preferred size computed so far.
   if (compute_bounds_only) {
     x += kRightMargin;
     prefsize.set_width(x);
     if (IsDetached()) {
       x += static_cast<int>(GetNewtabHorizontalPadding(mode) *
           (1 - size_animation_->GetCurrentValue()));
       int ntp_bookmark_bar_height = mode.is_ntp() ?
           kSearchNewTabBookmarkBarHeight : chrome::kNTPBookmarkBarHeight;
       prefsize.set_height(
           browser_defaults::kBookmarkBarHeight +
           static_cast<int>(
               (ntp_bookmark_bar_height -
                browser_defaults::kBookmarkBarHeight) *
               (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(
           static_cast<int>(
               browser_defaults::kBookmarkBarHeight *
               size_animation_->GetCurrentValue()));
     }
   }
   return prefsize;
 }
+
+bool BookmarkBarView::ShouldShowAppsShortcut() const {
+  return chrome::search::IsInstantExtendedAPIEnabled(browser_->profile()) &&
+      browser_->profile()->GetPrefs()->GetBoolean(
+          prefs::kShowAppsShortcutInBookmarkBar);
+}
+
+void BookmarkBarView::OnAppsPageShortcutVisibilityChanged() {
+  DCHECK(apps_page_shortcut_);
+  apps_page_shortcut_->SetVisible(ShouldShowAppsShortcut());
+  UpdateBookmarksSeparatorVisibility();
+  Layout();
+}