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/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"
 #include "chrome/common/chrome_switches.h"
@@ skipping 83 matching lines @@
 
 // Starting x-coordinate of the separator line within a separator.
 static const int kSeparatorStartX = 2;
 
 // Left-padding for the instructional text.
 static const int kInstructionsPadding = 6;
 
 // Tag for the 'Other bookmarks' button.
 static const int kOtherFolderButtonTag = 1;
 
+// Tag for the 'Apps Shortcut' button.
+static const int kAppsShortcutButtonTag = 2;
+
 namespace {
 
 // BookmarkButton -------------------------------------------------------------
 
 // Buttons used for the bookmarks on the bookmark bar.
 
 class BookmarkButton : public views::TextButton {
  public:
   // The internal view class name.
   static const char kViewClassName[];
@@ skipping 110 matching lines @@
     owner_->StopThrobbing(true);
     return views::MenuButton::OnMousePressed(e);
   }
 
  private:
   BookmarkBarView* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(OverFlowButton);
 };
 
+// ShortcutButton -------------------------------------------------------------
+
+// Buttons used for the shortcuts on the bookmark bar.
+
+class ShortcutButton : public views::TextButton {

[Alexei Svitkine (slow), 2013/02/25 21:13:29]

Should this implement GetTooltipText()?

[MAD, 2013/02/25 21:41:01]

No need for tooltip, the name of the shortcut is all we need.

+ public:
+  // The internal view class name.
+  static const char kViewClassName[];
+
+  ShortcutButton(views::ButtonListener* listener,
+                 const string16& title)
+      : TextButton(listener, title) {
+    show_animation_.reset(new ui::SlideAnimation(this));
+    if (bookmark_utils::IsBookmarkBarViewAnimationsDisabled()) {

[Alexei Svitkine (slow), 2013/02/25 21:13:29]

It seems most of this logic is identical to BookmarkButton.

What do you think of adding a common parent class (BookmarkButtonBase?) to avoid
the code duplication?

[MAD, 2013/02/25 21:41:01]

I thought about it, but I recently got slapped on the wrist for using
inheritance to share code like this... And I'm not sure we would gain much by
using composition here...

Though maybe this case is not quite the same as the I got slapped for... I'll
think about it some more...

+      // 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 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:
+  scoped_ptr<ui::SlideAnimation> show_animation_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShortcutButton);
+};
+
+// static for ShortcutButton
+const char ShortcutButton::kViewClassName[] =
+    "browser/ui/views/bookmarks/ShortcutButton";
+
 void RecordAppLaunch(Profile* profile, GURL url) {
   DCHECK(profile->GetExtensionService());
   if (!profile->GetExtensionService()->IsInstalledApp(url))
     return;
 
   AppLauncherHandler::RecordAppLaunchType(
       extension_misc::APP_LAUNCH_BOOKMARK_BAR);
 }
 
 }  // namespace
@@ skipping 99 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 205 matching lines @@
   if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     width += 2 * static_cast<int>(kNewtabHorizontalPadding * 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 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 400 matching lines @@
     }
   }
   return true;
 }
 
 void BookmarkBarView::OnMenuButtonClicked(views::View* view,
                                           const gfx::Point& point) {
   const BookmarkNode* node;
 
   int start_index = 0;
-  if (view == other_bookmarked_button_) {
+  if (view == other_bookmarked_button_ || view == apps_page_shortcut_) {
+    // We want the same menu for both, so use the other node since the app
+    // shortcut doesn't have a node.
     node = model_->other_node();
   } else if (view == overflow_button_) {
     node = model_->bookmark_bar_node();
     start_index = GetFirstHiddenNodeIndex();
   } else {
     int button_index = GetIndexOf(view);
     DCHECK_NE(-1, button_index);
     node = model_->bookmark_bar_node()->GetChild(button_index);
   }
 
   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_);
+    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 22 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
 
   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));
 }
 
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
@@ skipping 43 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->set_id(VIEW_ID_BOOKMARK_BAR_ELEMENT);
+  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+  button->SetIcon(*rb.GetImageSkiaNamed(IDR_PRODUCT_LOGO_16));
+  button->set_context_menu_controller(this);
+  button->set_tag(kAppsShortcutButtonTag);
+  button->SetEnabled(true);
+  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 334 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>(
           kNewtabHorizontalPadding * (1 - size_animation_->GetCurrentValue()));
       prefsize.set_height(
           browser_defaults::kBookmarkBarHeight +
           static_cast<int>(
               (chrome::kNTPBookmarkBarHeight -
                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() {
+  return chrome::search::IsInstantExtendedAPIEnabled(browser_->profile()) &&
+      browser_->profile()->GetPrefs()->GetBoolean(
+          prefs::kShowAppsShortcutInBookmarkBar);
+}
+
+void BookmarkBarView::OnAppsPageShortcutVisibilityChanged() {
+  DCHECK(apps_page_shortcut_);
+  apps_page_shortcut_->SetVisible(ShouldShowAppsShortcut());
+  Layout();
+}