Theme support for the extension shelf

chrome/browser/views/frame/browser_view.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/frame/browser_view.h"
 
 #include "app/drag_drop_types.h"
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
@@ skipping 106 matching lines @@
 // Returned from BrowserView::GetClassName.
 static const char kBrowserViewClassName[] = "browser/views/BrowserView";
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // BookmarkExtensionBackground, private:
 // This object serves as the views::Background object which is used to layout
 // and paint the bookmark bar.
 class BookmarkExtensionBackground : public views::Background {
  public:
-  explicit BookmarkExtensionBackground(BrowserView* browser_view);
+  explicit BookmarkExtensionBackground(BrowserView* browser_view,
+                                       DetachableToolbarView* host_view);
 
   // View methods overridden from views:Background.
   virtual void Paint(gfx::Canvas* canvas, views::View* view) const;
 
  private:
-  // Paint the theme background with the proper alignment.
-  void PaintThemeBackgroundTopAligned(gfx::Canvas* canvas,
-      SkBitmap* ntp_background, int tiling, int alignment) const;
-  void PaintThemeBackgroundBottomAligned(gfx::Canvas* canvas,
-      SkBitmap* ntp_background, int tiling, int alignment) const;
+  BrowserView* browser_view_;
 
-  BrowserView* browser_view_;
+  // The view hosting this background.
+  DetachableToolbarView* host_view_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkExtensionBackground);
 };
 
 BookmarkExtensionBackground::BookmarkExtensionBackground(
-    BrowserView* browser_view)
-    : browser_view_(browser_view) {
+    BrowserView* browser_view,
+    DetachableToolbarView* host_view)
+    : browser_view_(browser_view),
+      host_view_(host_view) {
 }
 
 void BookmarkExtensionBackground::Paint(gfx::Canvas* canvas,
-                                       views::View* view) const {
-  // Paint the bookmark bar.
-  BookmarkBarView* bookmark_bar_view = browser_view_->GetBookmarkBarView();
-  if (bookmark_bar_view->IsDetachedStyle()) {
+                                        views::View* view) const {
+  ThemeProvider* tp = host_view_->GetThemeProvider();
+  if (host_view_->IsDetached()) {
     // Draw the background to match the new tab page.
-    ThemeProvider* tp = bookmark_bar_view->GetThemeProvider();
-    canvas->FillRectInt(
-        tp->GetColor(BrowserThemeProvider::COLOR_NTP_BACKGROUND),
-        0, 0, bookmark_bar_view->width(), bookmark_bar_view->height());
-
-    if (tp->HasCustomImage(IDR_THEME_NTP_BACKGROUND)) {
-      int tiling = BrowserThemeProvider::NO_REPEAT;
-      tp->GetDisplayProperty(BrowserThemeProvider::NTP_BACKGROUND_TILING,
-                             &tiling);
-      int alignment;
-      if (tp->GetDisplayProperty(BrowserThemeProvider::NTP_BACKGROUND_ALIGNMENT,
-                                 &alignment)) {
-        SkBitmap* ntp_background = tp->GetBitmapNamed(
-            IDR_THEME_NTP_BACKGROUND);
-
-        if (alignment & BrowserThemeProvider::ALIGN_TOP) {
-          PaintThemeBackgroundTopAligned(canvas, ntp_background, tiling,
-              alignment);
-        } else {
-          PaintThemeBackgroundBottomAligned(canvas, ntp_background, tiling,
-              alignment);
-        }
-      }
-    }
-
-    // Draw the 'bottom' of the toolbar above our bubble.
-    canvas->FillRectInt(ResourceBundle::toolbar_separator_color, 0, 0,
-        bookmark_bar_view->width(), 1);
+    DetachableToolbarView::PaintBackgroundDetachedMode(canvas, host_view_);
 
     SkRect rect;
 
     // 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
     // bar to be docked.
-    double current_state = 1 - bookmark_bar_view->GetSizeAnimationValue();
+    double current_state = 1 - host_view_->GetAnimationValue();
 
     // The 0.5 is to correct for Skia's "draw on pixel boundaries"ness.
     double h_padding = static_cast<double>
-      (BookmarkBarView::kNewtabHorizontalPadding) * current_state;
+        (BookmarkBarView::kNewtabHorizontalPadding) * current_state;
     double v_padding = static_cast<double>
-      (BookmarkBarView::kNewtabVerticalPadding) * current_state;
-    rect.set(SkDoubleToScalar(h_padding - 0.5),
-             SkDoubleToScalar(v_padding - 0.5),
-             SkDoubleToScalar(bookmark_bar_view->width() - h_padding - 0.5),
-             SkDoubleToScalar(bookmark_bar_view->height() - v_padding - 0.5));
+        (BookmarkBarView::kNewtabVerticalPadding) * current_state;
+    double roundness = 0;
 
-    double roundness = static_cast<double>
-        (kNewtabBarRoundness) * current_state;
-
-    // Draw our background.
-    SkPaint paint;
-    paint.setAntiAlias(true);
-    paint.setColor(bookmark_bar_view->GetThemeProvider()->GetColor(
-        BrowserThemeProvider::COLOR_TOOLBAR));
-
-    canvas->drawRoundRect(rect,
-                          SkDoubleToScalar(roundness),
-                          SkDoubleToScalar(roundness), paint);
-
-    // Draw border
-    SkPaint border_paint;
-    border_paint.setColor(bookmark_bar_view->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);
+    DetachableToolbarView::CalculateContentArea(current_state,
+                                                h_padding, v_padding,
+                                                &rect, &roundness, host_view_);
+    DetachableToolbarView::PaintContentAreaBackground(
+        canvas, tp, rect, roundness);
+    DetachableToolbarView::PaintContentAreaBorder(canvas, tp, rect, roundness);
+    DetachableToolbarView::PaintHorizontalBorder(canvas, host_view_);
   } else {
-    gfx::Rect bounds = bookmark_bar_view->GetBounds(views::View::
-        APPLY_MIRRORING_TRANSFORMATION);
-
-    SkColor theme_toolbar_color =
-        bookmark_bar_view->GetThemeProvider()->GetColor(BrowserThemeProvider::
-            COLOR_TOOLBAR);
-    canvas->FillRectInt(theme_toolbar_color, 0, 0,
-                        bookmark_bar_view->width(),
-                        bookmark_bar_view->height());
-
-    canvas->TileImageInt(
-        *browser_view_->GetBookmarkBarView()->GetThemeProvider()->
-            GetBitmapNamed(IDR_THEME_TOOLBAR),
-        bookmark_bar_view->GetParent()->GetBounds(views::
-            View::APPLY_MIRRORING_TRANSFORMATION).x() + bounds.x(), bounds.y(),
-            0, 0,
-            bookmark_bar_view->width(),
-            bookmark_bar_view->height());
-    canvas->FillRectInt(ResourceBundle::toolbar_separator_color,
-                        0,
-                        bookmark_bar_view->height() - 1,
-                        bookmark_bar_view->width(), 1);
-  }
-}
-
-void BookmarkExtensionBackground::PaintThemeBackgroundTopAligned(
-    gfx::Canvas* canvas, SkBitmap* ntp_background, int tiling,
-    int alignment) const {
-  BookmarkBarView* bookmark_bar_view = browser_view_->GetBookmarkBarView();
-  if (alignment & BrowserThemeProvider::ALIGN_LEFT) {
-    if (tiling == BrowserThemeProvider::REPEAT)
-      canvas->TileImageInt(*ntp_background, 0, 0,
-      bookmark_bar_view->width(), bookmark_bar_view->height());
-    else if (tiling == BrowserThemeProvider::REPEAT_X)
-      canvas->TileImageInt(*ntp_background, 0, 0,
-                           bookmark_bar_view->width(),
-                           ntp_background->height());
-    else
-      canvas->TileImageInt(*ntp_background, 0, 0,
-          ntp_background->width(), ntp_background->height());
-
-  } else if (alignment & BrowserThemeProvider::ALIGN_RIGHT) {
-    int x_pos = bookmark_bar_view->width() % ntp_background->width() -
-        ntp_background->width();
-    if (tiling == BrowserThemeProvider::REPEAT)
-      canvas->TileImageInt(*ntp_background, x_pos, 0,
-          bookmark_bar_view->width() + ntp_background->width(),
-          bookmark_bar_view->height());
-    else if (tiling == BrowserThemeProvider::REPEAT_X)
-      canvas->TileImageInt(*ntp_background, x_pos,
-          0, bookmark_bar_view->width() + ntp_background->width(),
-          ntp_background->height());
-    else
-      canvas->TileImageInt(*ntp_background,
-          bookmark_bar_view->width() - ntp_background->width(), 0,
-          ntp_background->width(), ntp_background->height());
-
-  } else {  // ALIGN == CENTER
-    int x_pos = bookmark_bar_view->width() > ntp_background->width() ?
-        ((bookmark_bar_view->width() / 2 - ntp_background->width() / 2) %
-        ntp_background->width()) - ntp_background->width() :
-        bookmark_bar_view->width() / 2 - ntp_background->width() / 2;
-    if (tiling == BrowserThemeProvider::REPEAT)
-      canvas->TileImageInt(*ntp_background, x_pos, 0,
-          bookmark_bar_view->width() + ntp_background->width(),
-          bookmark_bar_view->height());
-    else if (tiling == BrowserThemeProvider::REPEAT_X)
-      canvas->TileImageInt(*ntp_background, x_pos, 0,
-          bookmark_bar_view->width() + ntp_background->width(),
-          ntp_background->height());
-    else
-      canvas->TileImageInt(*ntp_background,
-          bookmark_bar_view->width() / 2 - ntp_background->width() / 2,
-          0, ntp_background->width(), ntp_background->height());
-  }
-}
-
-void BookmarkExtensionBackground::PaintThemeBackgroundBottomAligned(
-    gfx::Canvas* canvas, SkBitmap* ntp_background, int tiling,
-    int alignment)  const {
-  BookmarkBarView* bookmark_bar_view = browser_view_->GetBookmarkBarView();
-  int browser_height = bookmark_bar_view->GetParent()->GetBounds(
-      views::View::APPLY_MIRRORING_TRANSFORMATION).height();
-  int border_width = 5;
-  int y_pos = ((tiling == BrowserThemeProvider::REPEAT_X) ||
-               (tiling == BrowserThemeProvider::NO_REPEAT)) ?
-      browser_height - ntp_background->height() - bookmark_bar_view->height() -
-          border_width :
-      browser_height % ntp_background->height() - bookmark_bar_view->height() -
-          border_width - ntp_background->height();
-
-  if (alignment & BrowserThemeProvider::ALIGN_LEFT) {
-    if (tiling == BrowserThemeProvider::REPEAT)
-      canvas->TileImageInt(*ntp_background, 0, y_pos,
-          bookmark_bar_view->width(),
-          2 * bookmark_bar_view->height() + ntp_background->height() + 5);
-    else if (tiling == BrowserThemeProvider::REPEAT_X)
-      canvas->TileImageInt(*ntp_background, 0, y_pos,
-          bookmark_bar_view->width(), ntp_background->height());
-    else if (tiling == BrowserThemeProvider::REPEAT_Y)
-      canvas->TileImageInt(*ntp_background, 0, y_pos,
-          ntp_background->width(),
-          2 * bookmark_bar_view->height() + ntp_background->height() + 5);
-    else
-      canvas->TileImageInt(*ntp_background, 0, y_pos, ntp_background->width(),
-          ntp_background->height());
-
-  } else if (alignment & BrowserThemeProvider::ALIGN_RIGHT) {
-    int x_pos = bookmark_bar_view->width() % ntp_background->width() -
-        ntp_background->width();
-    if (tiling == BrowserThemeProvider::REPEAT)
-      canvas->TileImageInt(*ntp_background, x_pos, y_pos,
-          bookmark_bar_view->width() + ntp_background->width(),
-          2 * bookmark_bar_view->height() + ntp_background->height() + 5);
-    else if (tiling == BrowserThemeProvider::REPEAT_X)
-      canvas->TileImageInt(*ntp_background, x_pos, y_pos,
-          bookmark_bar_view->width() + ntp_background->width(),
-          ntp_background->height());
-    else if (tiling == BrowserThemeProvider::REPEAT_Y)
-      canvas->TileImageInt(*ntp_background, bookmark_bar_view->width() -
-          ntp_background->width(), y_pos, ntp_background->width(),
-          2 * bookmark_bar_view->height() + ntp_background->height() + 5);
-    else
-      canvas->TileImageInt(*ntp_background,
-          bookmark_bar_view->width() - ntp_background->width(),
-          y_pos, ntp_background->width(), ntp_background->height());
-
-  } else {  // ALIGN == CENTER
-    int x_pos = bookmark_bar_view->width() > ntp_background->width() ?
-        ((bookmark_bar_view->width() / 2 - ntp_background->width() / 2) %
-        ntp_background->width()) - ntp_background->width() :
-        bookmark_bar_view->width() / 2 - ntp_background->width() / 2;
-    if (tiling == BrowserThemeProvider::REPEAT)
-      canvas->TileImageInt(*ntp_background, x_pos, y_pos,
-          bookmark_bar_view->width() + ntp_background->width(),
-          2 * bookmark_bar_view->height() + ntp_background->height() + 5);
-    else if (tiling == BrowserThemeProvider::REPEAT_X)
-      canvas->TileImageInt(*ntp_background, x_pos, y_pos,
-          bookmark_bar_view->width() + ntp_background->width(),
-          ntp_background->height());
-    else if (tiling == BrowserThemeProvider::REPEAT_Y)
-      canvas->TileImageInt(*ntp_background,
-          bookmark_bar_view->width() / 2 - ntp_background->width() / 2,
-          y_pos, ntp_background->width(),
-          2 * bookmark_bar_view->height() + ntp_background->height() + 5);
-    else
-      canvas->TileImageInt(*ntp_background,
-          bookmark_bar_view->width() / 2 - ntp_background->width() / 2,
-          y_pos, ntp_background->width(), ntp_background->height());
+    DetachableToolbarView::PaintBackgroundAttachedMode(canvas, host_view_);
+    DetachableToolbarView::PaintHorizontalBorder(canvas, host_view_);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ResizeCorner, private:
 
 class ResizeCorner : public views::View {
  public:
   ResizeCorner() { }
 
@@ skipping 1405 matching lines @@
       GetColor(BrowserThemeProvider::COLOR_TOOLBAR);
   contents_split_->set_background(
       views::Background::CreateSolidBackground(bg_color));
   AddChildView(contents_split_);
   set_contents_view(contents_split_);
 
   status_bubble_.reset(new StatusBubbleViews(GetWidget()));
 
   if (browser_->SupportsWindowFeature(Browser::FEATURE_EXTENSIONSHELF)) {
     extension_shelf_ = new ExtensionShelf(browser_.get());
+    extension_shelf_->set_background(
+        new BookmarkExtensionBackground(this, extension_shelf_));
     extension_shelf_->
         SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_EXTENSIONS));
     AddChildView(extension_shelf_);
   }
 
 #if defined(OS_WIN)
   InitSystemMenu();
 
   // Create a custom JumpList and add it to an observer of TabRestoreService
   // so we can update the custom JumpList when a tab is added or removed.
@@ skipping 51 matching lines @@
   toolbar_->SetBounds(0, y, browser_view_width, height);
   return y + height;
 }
 
 int BrowserView::LayoutBookmarkAndInfoBars(int top) {
   find_bar_y_ = top + y() - 1;
   if (active_bookmark_bar_) {
     // If we're showing the Bookmark bar in detached style, then we need to show
     // any Info bar _above_ the Bookmark bar, since the Bookmark bar is styled
     // to look like it's part of the page.
-    if (bookmark_bar_view_->IsDetachedStyle())
+    if (bookmark_bar_view_->IsDetached())
       return LayoutTopBar(LayoutInfoBar(top));
     // Otherwise, Bookmark bar first, Info bar second.
     top = LayoutTopBar(top);
   }
   find_bar_y_ = top + y() - 1;
   return LayoutInfoBar(top);
 }
 
 int BrowserView::LayoutTopBar(int top) {
   // This method lays out the the bookmark bar, and, if required, the extension
   // shelf by its side. The bookmark bar appears on the right of the extension
   // shelf. If there are too many bookmark items and extension toolstrips to fit
   // in the single bar, some compromises are made as follows:
   // 1. The bookmark bar is shrunk till it reaches the minimum width.
   // 2. After reaching the minimum width, the bookmark bar width is kept fixed -
   //    the extension shelf bar width is reduced.
   DCHECK(active_bookmark_bar_);
   int y = top, x = 0;
   if (!IsBookmarkBarVisible()) {
     bookmark_bar_view_->SetVisible(false);
     bookmark_bar_view_->SetBounds(0, y, width(), 0);
-    if (ShowExtensionsOnTop())
+    if (extension_shelf_->IsOnTop())
       extension_shelf_->SetVisible(false);
     return y;
   }
 
   int bookmark_bar_height = bookmark_bar_view_->GetPreferredSize().height();
-  y -= kSeparationLineHeight + (bookmark_bar_view_->IsDetachedStyle() ?
+  y -= kSeparationLineHeight + (bookmark_bar_view_->IsDetached() ?
       0 : bookmark_bar_view_->GetToolbarOverlap(false));
 
-  if (ShowExtensionsOnTop()) {
-    if (!bookmark_bar_view_->IsDetachedStyle()) {
+  if (extension_shelf_->IsOnTop()) {
+    if (!bookmark_bar_view_->IsDetached()) {
       int extension_shelf_width =
           extension_shelf_->GetPreferredSize().width();
       int bookmark_bar_given_width = width() - extension_shelf_width;
       int minimum_allowed_bookmark_bar_width =
           bookmark_bar_view_->GetMinimumSize().width();
       if (bookmark_bar_given_width < minimum_allowed_bookmark_bar_width) {
         // The bookmark bar cannot compromise on its width any more. The
         // extension shelf needs to shrink now.
         extension_shelf_width =
             width() - minimum_allowed_bookmark_bar_width;
       }
       extension_shelf_->SetVisible(true);
       extension_shelf_->SetBounds(x, y, extension_shelf_width,
                                   bookmark_bar_height);
       x += extension_shelf_width;
     } else {
-      // TODO (sidchat): For detached style bookmark bar, set the extensions
+      // TODO(sidchat): For detached style bookmark bar, set the extensions
       // shelf in a better position. Issue = 20741.
       extension_shelf_->SetVisible(false);
     }
   }
 
   bookmark_bar_view_->SetVisible(true);
   bookmark_bar_view_->SetBounds(x, y, width() - x, bookmark_bar_height);
   return y + bookmark_bar_height;
 }
 
 int BrowserView::LayoutInfoBar(int top) {
   bool visible = browser_->SupportsWindowFeature(Browser::FEATURE_INFOBAR);
   int height = visible ? infobar_container_->GetPreferredSize().height() : 0;
   infobar_container_->SetVisible(visible);
   infobar_container_->SetBounds(0, top, width(), height);
   return top + height;
 }
 
 void BrowserView::LayoutTabContents(int top, int bottom) {
   contents_split_->SetBounds(0, top, width(), bottom - top);
 }
 
 int BrowserView::LayoutExtensionAndDownloadShelves() {
   // If we're showing the Bookmark bar in detached style, then we need to show
   // any Info bar _above_ the Bookmark bar, since the Bookmark bar is styled
   // to look like it's part of the page.
   int bottom = height();
   if (extension_shelf_) {
-    if (extension_shelf_->IsDetachedStyle()) {
+    if (extension_shelf_->IsDetached()) {
       bottom = LayoutDownloadShelf(bottom);
       return LayoutExtensionShelf(bottom);
     }
     // Otherwise, Extension shelf first, Download shelf second.
     bottom = LayoutExtensionShelf(bottom);
   }
   return LayoutDownloadShelf(bottom);
 }
 
 int BrowserView::LayoutDownloadShelf(int bottom) {
@@ skipping 18 matching lines @@
   // frame.
   int overlap = StatusBubbleViews::kShadowThickness +
       (IsMaximized() ? 0 : views::NonClientFrameView::kClientEdgeThickness);
   int height = status_bubble_->GetPreferredSize().height();
   gfx::Point origin(-overlap, top - height + overlap);
   ConvertPointToView(this, GetParent(), &origin);
   status_bubble_->SetBounds(origin.x(), origin.y(), width() / 3, height);
 }
 
 int BrowserView::LayoutExtensionShelf(int bottom) {
-  if (ShowExtensionsOnTop())
+  if (!extension_shelf_ || extension_shelf_->IsOnTop())
     return bottom;
 
   if (extension_shelf_) {
     bool visible = browser_->SupportsWindowFeature(
         Browser::FEATURE_EXTENSIONSHELF);
     int height =
         visible ? extension_shelf_->GetPreferredSize().height() : 0;
     extension_shelf_->SetVisible(visible);
     extension_shelf_->SetBounds(0, bottom - height, width(), height);
     extension_shelf_->Layout();
     bottom -= height;
   }
   return bottom;
 }
 
 bool BrowserView::MaybeShowBookmarkBar(TabContents* contents) {
   views::View* new_bookmark_bar_view = NULL;
   if (browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR)
       && contents) {
     if (!bookmark_bar_view_.get()) {
       bookmark_bar_view_.reset(new BookmarkBarView(contents->profile(),
                                                    browser_.get()));
       bookmark_bar_view_->SetParentOwned(false);
-      bookmark_bar_view_->set_background(new BookmarkExtensionBackground(this));
+      bookmark_bar_view_->set_background(
+          new BookmarkExtensionBackground(this, bookmark_bar_view_.get()));
     } else {
       bookmark_bar_view_->SetProfile(contents->profile());
     }
     bookmark_bar_view_->SetPageNavigator(contents);
     bookmark_bar_view_->
         SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_BOOKMARKS));
     new_bookmark_bar_view = bookmark_bar_view_.get();
   }
   return UpdateChildViewAndLayout(new_bookmark_bar_view, &active_bookmark_bar_);
 }
@@ skipping 265 matching lines @@
     ticker_.Start();
 
     pref_service->SetInteger(prefs::kPluginMessageResponseTimeout,
                              plugin_message_response_timeout);
     pref_service->SetInteger(prefs::kHungPluginDetectFrequency,
                              hung_plugin_detect_freq);
   }
 #endif
 }
 
-bool BrowserView::ShowExtensionsOnTop() {
-  return extension_shelf_ && CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kShowExtensionsOnTop);
-}
-
 // static
 void BrowserView::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_favicon_ = *rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
     initialized = true;
   }
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   // Create the view and the frame. The frame will attach itself via the view
   // so we don't need to do anything with the pointer.
   BrowserView* view = new BrowserView(browser);
   BrowserFrame::Create(view, browser->profile());
   return view;
 }
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }
 
 // static
 void BrowserList::AllBrowsersClosed() {
   views::Window::CloseAllSecondaryWindows();
 }