Theme support for the extension shelf

chrome/browser/views/extensions/extension_shelf.cc

 // Copyright (c) 2009 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/views/extensions/extension_shelf.h"
 
 #include <algorithm>
 
 #include "app/resource_bundle.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/views/extensions/extension_view.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "skia/ext/skia_utils.h"
 #include "views/controls/label.h"
 #include "views/screen.h"
 #include "views/widget/root_view.h"
 
 namespace {
 
 // Margins around the content.
 static const int kTopMargin = 2;
 static const int kBottomMargin = 2;
 static const int kLeftMargin = 0;
 static const int kRightMargin = 0;
 
 // Padding on left and right side of an extension toolstrip.
 static const int kToolstripPadding = 2;
 
 // Width of the toolstrip divider.
 static const int kToolstripDividerWidth = 2;
 
 // Preferred height of the ExtensionShelf.
 static const int kShelfHeight = 29;
 
 // Preferred height of the Extension shelf when only shown on the new tab page.
-const int kNewtabShelfHeight = 57;
+const int kNewtabShelfHeight = 58;
 
 // How inset the extension shelf is when displayed on the new tab page. This is
 // in addition to the margins above.
 static const int kNewtabHorizontalPadding = 8;
 static const int kNewtabVerticalPadding = 12;
 
 // We need an extra margin to the left of all the toolstrips in detached mode,
 // so that the first toolstrip doesn't look so squished against the rounded
 // corners of the extension shelf.
 static const int kNewtabExtraHorMargin = 2;
 static const int kNewtabExtraVerMargin = 2;
 
-// How round the 'new tab' style extension shelf is.
-static const int kNewtabBarRoundness = 5;
-
 // Height of the toolstrip within the shelf.
 static const int kToolstripHeight = kShelfHeight - (kTopMargin + kBottomMargin);
 
 // Colors for the ExtensionShelf.
-static const SkColor kBackgroundColor = SkColorSetRGB(230, 237, 244);
-static const SkColor kBorderColor = SkColorSetRGB(201, 212, 225);
 static const SkColor kDividerHighlightColor = SkColorSetRGB(247, 250, 253);
 
-// Text colors for the handle.
-static const SkColor kHandleTextColor = SkColorSetRGB(6, 45, 117);
-static const SkColor kHandleTextHighlightColor =
-    SkColorSetARGB(200, 255, 255, 255);
-
 // Handle padding.
 static const int kHandlePadding = 4;
 
-// TODO(erikkay) convert back to a gradient when Glen figures out the
-// specs.
-// static const SkColor kBackgroundColor = SkColorSetRGB(237, 244, 252);
-// static const SkColor kTopGradientColor = SkColorSetRGB(222, 234, 248);
-
 // Delays for showing and hiding the shelf handle.
-static const int kHideDelayMs = 500;
+static const int kShowDelayMs = 500;
+static const int kHideDelayMs = 300;
 
 }  // namespace
 
 
 // A view that holds the place for a toolstrip in the shelf while the toolstrip
 // is being dragged or moved.
 // TODO(erikkay) this should draw a dimmed out version of the toolstrip.
 class ExtensionShelf::PlaceholderView : public views::View {
  public:
   PlaceholderView() {}
@@ skipping 18 matching lines @@
                                   public BrowserBubble::Delegate,
                                   public AnimationDelegate {
  public:
   Toolstrip(ExtensionShelf* shelf, ExtensionHost* host,
             const Extension::ToolstripInfo& info);
   virtual ~Toolstrip();
 
   // Convenience to calculate just the size of the handle.
   gfx::Size GetHandlePreferredSize();
 
-  // View
+  // View methods:
   virtual void Paint(gfx::Canvas* canvas);
   virtual gfx::Size GetPreferredSize();
   virtual void Layout();
   virtual void OnMouseEntered(const views::MouseEvent& event);
   virtual void OnMouseExited(const views::MouseEvent& event);
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual bool OnMouseDragged(const views::MouseEvent& event);
   virtual void OnMouseReleased(const views::MouseEvent& event, bool canceled);
   virtual bool IsFocusable() const { return true; }
   virtual void ChildPreferredSizeChanged(View* child);
@@ skipping 112 matching lines @@
   SetParentOwned(false);
 
   mole_animation_.reset(new SlideAnimation(this));
 
   std::wstring name = UTF8ToWide(host_->extension()->name());
   // |title_| isn't actually put in the view hierarchy.  We just use it
   // to draw in place.  The reason for this is so that we can properly handle
   // the various mouse events necessary for hovering and dragging.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   title_.reset(new views::Label(name, rb.GetFont(ResourceBundle::BaseFont)));
-  title_->SetColor(kHandleTextColor);
-  title_->SetDrawHighlighted(true);
-  title_->SetHighlightColor(kHandleTextHighlightColor);
   title_->SetBounds(kHandlePadding, kHandlePadding, 100, 100);
   title_->SizeToPreferredSize();
 
   SizeToPreferredSize();
 }
 
 ExtensionShelf::Toolstrip::~Toolstrip() {
   if (handle_.get() && handle_->attached())
     handle_->DetachFromBrowser();
 }
 
 void ExtensionShelf::Toolstrip::Paint(gfx::Canvas* canvas) {
-  canvas->FillRectInt(kBackgroundColor, 0, 0, width(), height());
-  canvas->FillRectInt(kBorderColor, 0, 0, width(), 1);
-  canvas->FillRectInt(kBorderColor, 0, 0, 1, height() - 1);
-  canvas->FillRectInt(kBorderColor, width() - 1, 0, 1, height() - 1);
+  // Paints the handle for the toolstrip (only called on mouse-hover).
+  SkColor theme_toolbar_color =
+      shelf_->GetThemeProvider()->GetColor(BrowserThemeProvider::COLOR_TOOLBAR);
+  canvas->FillRectInt(theme_toolbar_color, 0, 0, width(), height());
+
+  SkColor border_color = ResourceBundle::toolbar_separator_color;
+  canvas->FillRectInt(border_color, 0, 0, width(), 1);
+  canvas->FillRectInt(border_color, 0, 0, 1, height() - 1);
+  canvas->FillRectInt(border_color, width() - 1, 0, 1, height() - 1);
   int ext_width = view()->width() + kToolstripPadding +
       kToolstripDividerWidth;
   if (ext_width < width()) {
-    canvas->FillRectInt(kBorderColor, ext_width, height() - 1,
+    canvas->FillRectInt(border_color, ext_width, height() - 1,
                         width() - ext_width, 1);
   }
 
   // Draw the title using a Label as a stamp.
   // See constructor for comment about this.
   title_->ProcessPaint(canvas);
 
   if (dragging_) {
-    // when we're dragging, draw the bottom border.
-    canvas->FillRectInt(kBorderColor, 0, height() - 1, width(), 1);
+    // When we're dragging, draw the bottom border.
+    canvas->FillRectInt(border_color, 0, height() - 1, width(), 1);
   }
 }
 
 gfx::Size ExtensionShelf::Toolstrip::GetHandlePreferredSize() {
   gfx::Size sz = title_->GetPreferredSize();
   sz.set_width(std::max(view()->width(), sz.width()));
   if (!expanded_)
     sz.Enlarge(2 + kHandlePadding * 2, kHandlePadding * 2);
   return sz;
 }
@@ skipping 211 matching lines @@
   placeholder_view_ = NULL;
 
   SizeToPreferredSize();
   Layout();
   shelf_->Layout();
 }
 
 void ExtensionShelf::Toolstrip::DoShowShelfHandle() {
   GetHandle();
   if (!handle_->visible()) {
+    // Make sure the text color for the title matches the theme colors.
+    title_->SetColor(
+        shelf_->GetThemeProvider()->GetColor(
+            BrowserThemeProvider::COLOR_BOOKMARK_TEXT));
+
     LayoutHandle();
     handle_->Show();
   }
 }
 
 void ExtensionShelf::Toolstrip::DoHideShelfHandle() {
   if (!handle_visible())
     return;
   handle_->Hide();
   if (handle_->attached())
@@ skipping 57 matching lines @@
   }
 }
 
 void ExtensionShelf::Toolstrip::ShowShelfHandle() {
   StopHandleTimer();
   if (handle_visible())
     return;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       timer_factory_.NewRunnableMethod(
           &ExtensionShelf::Toolstrip::DoShowShelfHandle),
-      1000);
+      kShowDelayMs);
 }
 
 void ExtensionShelf::Toolstrip::HideShelfHandle(int delay_ms) {
   StopHandleTimer();
   if (!handle_visible() || dragging_ || expanded_ ||
       mole_animation_->IsAnimating()) {
     return;
   }
   if (delay_ms) {
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         timer_factory_.NewRunnableMethod(
             &ExtensionShelf::Toolstrip::DoHideShelfHandle),
         delay_ms);
   } else {
     DoHideShelfHandle();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionShelf::ExtensionShelf(Browser* browser)
-    : browser_(browser),
+    : background_for_detached_(false),
+      browser_(browser),
+      background_needs_repaint_(true),
       model_(browser->extension_shelf_model()) {
   model_->AddObserver(this);
   LoadFromModel();
   EnableCanvasFlippingForRTLUI(true);
   registrar_.Add(this,
                  NotificationType::EXTENSION_SHELF_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
 
   size_animation_.reset(new SlideAnimation(this));
   if (IsAlwaysShown())
     size_animation_->Reset(1);
   else
     size_animation_->Reset(0);
 }
 
 ExtensionShelf::~ExtensionShelf() {
   if (model_) {
     int count = model_->count();
     for (int i = 0; i < count; ++i) {
       delete ToolstripAtIndex(i);
       model_->SetToolstripDataAt(i, NULL);
     }
     model_->RemoveObserver(this);
   }
 }
 
-void ExtensionShelf::Paint(gfx::Canvas* canvas) {
-  if (IsDetachedStyle()) {
-    // Draw the background to match the new tab page.
-    ThemeProvider* tp = GetThemeProvider();
-    canvas->FillRectInt(
-        tp->GetColor(BrowserThemeProvider::COLOR_NTP_BACKGROUND),
-        0, 0, width(), height());
-
-    // As 'hidden' according to the animation is the full in-tab state,
-    // we invert the value - when current_state is at '0', we expect the
-    // shelf to be docked.
-    double current_state = 1 - size_animation_->GetCurrentValue();
-
-    // The 0.5 is to correct for Skia's "draw on pixel boundaries"ness.
-    double h_padding = static_cast<double>
-        (kNewtabHorizontalPadding) * current_state;
-    double v_padding = static_cast<double>
-        (kNewtabVerticalPadding) * current_state;
-    SkRect rect;
-    rect.set(SkDoubleToScalar(h_padding - 0.5),
-             SkDoubleToScalar(v_padding - 0.5),
-             SkDoubleToScalar(width() - h_padding - 0.5),
-             SkDoubleToScalar(height() - v_padding - 0.5));
-
-    double roundness = static_cast<double>
-        (kNewtabBarRoundness) * current_state;
-
-    // Draw the background behind the toolstrips.
-    SkPaint paint;
-    paint.setAntiAlias(true);
-    paint.setColor(kBackgroundColor);
-
-    canvas->drawRoundRect(rect,
-                          SkDoubleToScalar(roundness),
-                          SkDoubleToScalar(roundness), paint);
-
-    SkRect background_rect = {
-        SkIntToScalar(h_padding),
-        SkIntToScalar(v_padding + 2),
-        SkIntToScalar(h_padding + 1),
-        SkIntToScalar(v_padding + kToolstripHeight - 3)};
-    InitBackground(canvas, background_rect);
-
-    // Draw the border around the toolstrips in the extension shelf.
-    SkPaint border_paint;
-    border_paint.setColor(
-        GetThemeProvider()->GetColor(BrowserThemeProvider::COLOR_NTP_HEADER));
-    border_paint.setStyle(SkPaint::kStroke_Style);
-    border_paint.setAlpha(96);
-    border_paint.setAntiAlias(true);
-    canvas->drawRoundRect(rect,
-        SkDoubleToScalar(roundness),
-        SkDoubleToScalar(roundness), border_paint);
-  } else {
-#if 0
-    // TODO(erikkay) Re-enable when Glen has the gradient values worked out.
-    SkPaint paint;
-    paint.setShader(skia::CreateGradientShader(0,
-                                               height(),
-                                               kTopGradientColor,
-                                               kBackgroundColor))->safeUnref();
-    canvas->FillRectInt(0, 0, width(), height(), paint);
-#else
-    canvas->FillRectInt(kBackgroundColor, 0, 0, width(), height());
-#endif
-
-    SkRect background_rect = {
-        SkIntToScalar(0),
-        SkIntToScalar(0),
-        SkIntToScalar(1),
-        SkIntToScalar(height())
-    };
-    InitBackground(canvas, background_rect);
-
-    // Draw border around shelf in attached mode. If we are in detached mode
-    // we've already drawn the borders.
-    canvas->FillRectInt(kBorderColor, 0, 0, width(), 1);
-    canvas->FillRectInt(kBorderColor, 0, height() - 1, width(), 1);
-  }
+void ExtensionShelf::PaintChildren(gfx::Canvas* canvas) {
+  // Capture a background bitmap to give to the toolstrips.
+  SkRect background_rect = {
+      SkIntToScalar(0),
+      SkIntToScalar(0),
+      SkIntToScalar(width()),
+      SkIntToScalar(height())
+  };
+  InitBackground(canvas, background_rect);
 
   // Draw vertical dividers between Toolstrip items in the Extension shelf.
   int count = GetChildViewCount();
   for (int i = 0; i < count; ++i) {
     int right = GetChildViewAt(i)->bounds().right() + kToolstripPadding;
-    int y = IsDetachedStyle() ? kNewtabVerticalPadding : 1;
-    int h = IsDetachedStyle() ? height() - (2 * kNewtabVerticalPadding) - 1:
-                                height() - 2;
-    canvas->FillRectInt(kBorderColor, right, y, 1, h);
-    canvas->FillRectInt(kDividerHighlightColor, right + 1, y, 1, h);
+    int vertical_padding = IsDetached() ? (height() - kShelfHeight) / 2 : 1;
+
+    DetachableToolbarView::PaintVerticalDivider(
+        canvas, right, height(), vertical_padding,
+        SK_ColorWHITE,
+        kDividerHighlightColor,
+        GetThemeProvider()->GetColor(BrowserThemeProvider::COLOR_TOOLBAR));
   }
 }
 
 // static
 void ExtensionShelf::ToggleWhenExtensionShelfVisible(Profile* profile) {
   PrefService* prefs = profile->GetPrefs();
   const bool always_show = !prefs->GetBoolean(prefs::kShowExtensionShelf);
 
   // The user changed when the Extension Shelf is shown, update the
   // preferences.
@@ skipping 17 matching lines @@
   if (!toolstrip)
     return;
 
   PreferredSizeChanged();
 }
 
 void ExtensionShelf::Layout() {
   LayoutItems(false);
 }
 
-
 void ExtensionShelf::OnMouseEntered(const views::MouseEvent& event) {
 }
 
 void ExtensionShelf::OnMouseExited(const views::MouseEvent& event) {
 }
 
 bool ExtensionShelf::GetAccessibleRole(AccessibilityTypes::Role* role) {
   DCHECK(role);
 
   *role = AccessibilityTypes::ROLE_TOOLBAR;
   return true;
 }
 
 bool ExtensionShelf::GetAccessibleName(std::wstring* name) {
   DCHECK(name);
 
   if (!accessible_name_.empty()) {
     name->assign(accessible_name_);
     return true;
   }
   return false;
 }
 
 void ExtensionShelf::SetAccessibleName(const std::wstring& name) {
   accessible_name_.assign(name);
 }
 
+void ExtensionShelf::ThemeChanged() {
+  background_needs_repaint_ = true;
+
+  // Refresh the CSS to update toolstrip text colors from theme.
+  int count = model_->count();
+  for (int i = 0; i < count; ++i)
+    ToolstripAtIndex(i)->view()->host()->InsertCssIfToolstrip();
+
+  Layout();
+}
+
 void ExtensionShelf::ToolstripInsertedAt(ExtensionHost* host,
                                          int index) {
   model_->SetToolstripDataAt(index,
       new Toolstrip(this, host, model_->ToolstripAt(index).info));
 
   bool had_views = GetChildViewCount() > 0;
   ExtensionView* view = host->view();
-  if (!background_.empty())
-    view->SetBackground(background_);
+  background_needs_repaint_ = true;
   AddChildView(view);
   view->SetContainer(this);
   if (!had_views)
     PreferredSizeChanged();
   Layout();
 }
 
 void ExtensionShelf::ToolstripRemovingAt(ExtensionHost* host, int index) {
   // Delete the Toolstrip view and remove it from the model.
   Toolstrip* toolstrip = ToolstripAtIndex(index);
@@ skipping 48 matching lines @@
 
 void ExtensionShelf::AnimationProgressed(const Animation* animation) {
   if (browser_)
     browser_->ExtensionShelfSizeChanged();
 }
 
 void ExtensionShelf::AnimationEnded(const Animation* animation) {
   if (browser_)
     browser_->ExtensionShelfSizeChanged();
 
-  SchedulePaint();
+  background_needs_repaint_ = true;
+  Layout();
 }
 
 void ExtensionShelf::Observe(NotificationType type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_SHELF_VISIBILITY_PREF_CHANGED: {
       if (IsAlwaysShown())
         size_animation_->Show();
       else
@@ skipping 39 matching lines @@
                                      int height) {
   ExtensionShelfModel::iterator toolstrip = model_->ToolstripForHost(host);
   model_->ExpandToolstrip(toolstrip, url, height);
 }
 
 void ExtensionShelf::CollapseToolstrip(ExtensionHost* host, const GURL& url) {
   ExtensionShelfModel::iterator toolstrip = model_->ToolstripForHost(host);
   model_->CollapseToolstrip(toolstrip, url);
 }
 
-void ExtensionShelf::InitBackground(gfx::Canvas* canvas, const SkRect& subset) {
-  if (!background_.empty())
+void ExtensionShelf::InitBackground(
+    gfx::Canvas* canvas, const SkRect& subset) {
+  bool detached = IsDetached();
+  if (!background_needs_repaint_ && background_for_detached_ == detached)

[Aaron Boodman, 2009/09/17 19:42:38]

Seems like you could consolidate these two cases by listening for the detach
command and resetting the background_needs_repaint_ flag there.

[Finnur, 2009/09/17 22:23:07]

Yeah, in my upcoming changelist this flag (background_for_detached_) is no
longer there.

On 2009/09/17 19:42:38, Aaron Boodman wrote:

     return;
 
-  const SkBitmap& background = canvas->getDevice()->accessBitmap(false);
-
-  // Extract the correct subset of the toolstrip background into a bitmap. We
-  // must use a temporary here because extractSubset() returns a bitmap that
-  // references pixels in the original one and we want to actually make a copy
-  // that will have a long lifetime.
-  SkBitmap temp;
-  temp.setConfig(background.config(),
-                 static_cast<int>(subset.width()),
-                 static_cast<int>(subset.height()));
-
-  SkRect mapped_subset = subset;
-  bool result = canvas->getTotalMatrix().mapRect(&mapped_subset);
-  DCHECK(result);
-
-  SkIRect isubset;
-  mapped_subset.round(&isubset);
-  result = background.extractSubset(&temp, isubset);
-  if (!result)
-    return;
-
-  temp.copyTo(&background_, temp.config());
-  DCHECK(background_.readyToDraw());
+  background_for_detached_ = detached;
 
   // Tell all extension views about the new background
   int count = model_->count();
-  for (int i = 0; i < count; ++i)
-    ToolstripAtIndex(i)->view()->SetBackground(background_);
+  for (int i = 0; i < count; ++i) {
+    ExtensionView* view = ToolstripAtIndex(i)->view();
+
+    const SkBitmap& background = canvas->getDevice()->accessBitmap(false);
+
+    // Extract the correct subset of the toolstrip background into a bitmap. We
+    // must use a temporary here because extractSubset() returns a bitmap that
+    // references pixels in the original one and we want to actually make a copy
+    // that will have a long lifetime.
+    SkBitmap temp;
+    temp.setConfig(background.config(),
+                   static_cast<int>(subset.width()),
+                   static_cast<int>(subset.height()));
+
+    SkRect mapped_subset = subset;
+    gfx::Rect view_bounds = view->bounds();
+    mapped_subset.offset(SkIntToScalar(view_bounds.x()),
+                         SkIntToScalar(view_bounds.y()));
+    bool result = canvas->getTotalMatrix().mapRect(&mapped_subset);
+    DCHECK(result);
+
+    SkIRect isubset;
+    mapped_subset.round(&isubset);
+    result = background.extractSubset(&temp, isubset);
+    if (!result)
+      return;
+
+    DCHECK(temp.readyToDraw());
+
+    view->SetBackground(temp);
+  }
+
+  background_needs_repaint_ = false;
 }
 
 ExtensionShelf::Toolstrip* ExtensionShelf::ToolstripAtX(int x) {
   int count = model_->count();
   if (count == 0)
     return NULL;
 
   if (x < 0)
     return NULL;
 
@@ skipping 44 matching lines @@
     x += static_cast<int>(static_cast<double>
         (kNewtabHorizontalPadding + kNewtabExtraHorMargin) * current_state);
     y += static_cast<int>(static_cast<double>
         (kNewtabVerticalPadding + kNewtabExtraVerMargin) * current_state);
     max_x -= static_cast<int>(static_cast<double>
         (kNewtabHorizontalPadding) * current_state);
   }
 
   int count = model_->count();
   for (int i = 0; i < count; ++i) {
-    x += kToolstripPadding;  // left padding
+    x += kToolstripPadding;  // Left padding.
     Toolstrip* toolstrip = ToolstripAtIndex(i);
-    if (!toolstrip)  // can be NULL while in the process of removing
+    if (!toolstrip)  // Can be NULL while in the process of removing.
       continue;
     View* view = toolstrip->GetShelfView();
     gfx::Size pref = view->GetPreferredSize();
-    int next_x = x + pref.width() + kToolstripPadding;  // right padding
+    int next_x = x + pref.width() + kToolstripPadding;  // Right padding.
     if (!compute_bounds_only) {
       if (view == toolstrip->view())
         toolstrip->view()->set_is_clipped(next_x >= max_x);
       view->SetBounds(x, y, pref.width(), content_height);
       view->Layout();
       if (toolstrip->handle_visible())
         toolstrip->LayoutHandle();
     }
     x = next_x + kToolstripDividerWidth;
   }
@@ skipping 11 matching lines @@
                               size_animation_->GetCurrentValue()));
     }
 
     x += kRightMargin;
     prefsize.set_width(x);
   }
 
   return prefsize;
 }
 
-bool ExtensionShelf::IsDetachedStyle() {
+bool ExtensionShelf::IsOnTop() const {
+  static bool is_on_top = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kShowExtensionsOnTop);
+  return is_on_top;
+}
+
+bool ExtensionShelf::IsDetached() const {
   return OnNewTabPage() && (size_animation_->GetCurrentValue() != 1);
 }
 
-bool ExtensionShelf::IsAlwaysShown() {
+bool ExtensionShelf::IsAlwaysShown() const {
   Profile* profile = browser_->profile();
   return profile->GetPrefs()->GetBoolean(prefs::kShowExtensionShelf);
 }
 
-bool ExtensionShelf::OnNewTabPage() {
+bool ExtensionShelf::OnNewTabPage() const {
   return (browser_ && browser_->GetSelectedTabContents() &&
       browser_->GetSelectedTabContents()->IsExtensionShelfAlwaysVisible());
 }