Make non-glass popups match new mockup from Glen....

chrome/browser/views/toolbar_view.cc

 // Copyright (c) 2006-2008 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/toolbar_view.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/path_service.h"
@@ skipping 43 matching lines @@
 static const int kControlVertOffset = 6;
 static const int kControlIndent = 3;
 static const int kStatusBubbleWidth = 480;
 
 // Separation between the location bar and the menus.
 static const int kMenuButtonOffset = 3;
 
 // Padding to the right of the location bar
 static const int kPaddingRight = 2;
 
+static const int kPopupTopSpacingNonGlass = 3;
+static const int kPopupBottomSpacingNonGlass = 2;
+static const int kPopupBottomSpacingGlass = 1;
+
+static SkBitmap* kPopupBackgroundEdge = NULL;
+
 BrowserToolbarView::BrowserToolbarView(Browser* browser)
     : EncodingMenuControllerDelegate(browser),
       model_(browser->toolbar_model()),
       back_(NULL),
       forward_(NULL),
       reload_(NULL),
       home_(NULL),
       star_(NULL),
       location_bar_(NULL),
       go_(NULL),
       profile_(NULL),
       acc_focused_view_(NULL),
       browser_(browser),
       tab_(NULL),
       profiles_helper_(new GetProfilesHelper(this)),
       profiles_menu_(NULL) {
   browser_->command_updater()->AddCommandObserver(IDC_BACK, this);
   browser_->command_updater()->AddCommandObserver(IDC_FORWARD, this);
   browser_->command_updater()->AddCommandObserver(IDC_RELOAD, this);
   browser_->command_updater()->AddCommandObserver(IDC_HOME, this);
   browser_->command_updater()->AddCommandObserver(IDC_STAR, this);
   back_menu_model_.reset(new BackForwardMenuModelWin(
       browser, BackForwardMenuModel::BACKWARD_MENU_DELEGATE));
   forward_menu_model_.reset(new BackForwardMenuModelWin(
       browser, BackForwardMenuModel::FORWARD_MENU_DELEGATE));
   if (browser->type() == Browser::TYPE_NORMAL)
     display_mode_ = DISPLAYMODE_NORMAL;
   else
     display_mode_ = DISPLAYMODE_LOCATION;
+
+  if (!kPopupBackgroundEdge) {
+    kPopupBackgroundEdge = ResourceBundle::GetSharedInstance().GetBitmapNamed(
+        IDR_LOCATIONBG_POPUPMODE_EDGE);
+  }
 }
 
 BrowserToolbarView::~BrowserToolbarView() {
   profiles_helper_->OnDelegateDeleted();
 }
 
 void BrowserToolbarView::Init(Profile* profile) {
   // Create all the individual Views in the Toolbar.
   CreateLeftSideControls();
   CreateCenterStack(profile);
@@ skipping 149 matching lines @@
   app_menu_->SetID(VIEW_ID_APP_MENU);
   AddChildView(app_menu_);
 }
 
 void BrowserToolbarView::Layout() {
   // If we have not been initialized yet just do nothing.
   if (back_ == NULL)
     return;
 
   if (!IsDisplayModeNormal()) {
-    location_bar_->SetBounds(0, 0, width(),
-                             location_bar_->GetPreferredSize().height());
+    int edge_width = (browser_->window() && browser_->window()->IsMaximized()) ?
+        0 : kPopupBackgroundEdge->width();  // See Paint().
+    location_bar_->SetBounds(edge_width, PopupTopSpacing(),
+        width() - (edge_width * 2), location_bar_->GetPreferredSize().height());
     return;
   }
 
   int child_y = std::min(kControlVertOffset, height());
   // We assume all child elements are the same height.
   int child_height =
       std::min(go_->GetPreferredSize().height(), height() - child_y);
 
   // If the window is maximized, we extend the back button to the left so that
   // clicking on the left-most pixel will activate the back button.
@@ skipping 39 matching lines @@
   go_->SetBounds(location_bar_->x() + location_bar_->width(), child_y,
                  go_button_width, child_height);
 
   page_menu_->SetBounds(go_->x() + go_->width() + kMenuButtonOffset, child_y,
                         page_menu_width, child_height);
 
   app_menu_->SetBounds(page_menu_->x() + page_menu_->width(), child_y,
                        app_menu_width, child_height);
 }
 
+void BrowserToolbarView::Paint(ChromeCanvas* canvas) {
+  View::Paint(canvas);
+
+  if (IsDisplayModeNormal())
+    return;
+
+  // In maximized mode, we don't draw the endcaps on the location bar, because
+  // when they're flush against the edge of the screen they just look glitchy.
+  if (!browser_->window() || !browser_->window()->IsMaximized()) {
+    int top_spacing = PopupTopSpacing();
+    canvas->DrawBitmapInt(*kPopupBackgroundEdge, 0, top_spacing);
+    canvas->DrawBitmapInt(*kPopupBackgroundEdge,
+                          width() - kPopupBackgroundEdge->width(), top_spacing);
+  }
+
+  // For glass, we need to draw a black line below the location bar to separate
+  // it from the content area.  For non-glass, the NonClientView draws the
+  // toolbar background below the location bar for us.
+  if (win_util::ShouldUseVistaFrame())
+    canvas->FillRectInt(SK_ColorBLACK, 0, height() - 1, width(), 1);
+}
+
 void BrowserToolbarView::DidGainFocus() {
   // Check to see if MSAA focus should be restored to previously focused button,
   // and if button is an enabled, visibled child of toolbar.
   if (!acc_focused_view() ||
       (acc_focused_view()->GetParent()->GetID() != VIEW_ID_TOOLBAR) ||
       !acc_focused_view()->IsEnabled() ||
       !acc_focused_view()->IsVisible()) {
     // Find first accessible child (-1 to start search at parent).
     int first_acc_child = GetNextAccessibleViewIndex(-1, false);
 
@@ skipping 119 matching lines @@
 gfx::Size BrowserToolbarView::GetPreferredSize() {
   if (IsDisplayModeNormal()) {
     static SkBitmap normal_background;
     if (normal_background.isNull()) {
       ResourceBundle& rb = ResourceBundle::GetSharedInstance();
       normal_background = *rb.GetBitmapNamed(IDR_CONTENT_TOP_CENTER);
     }
     return gfx::Size(0, normal_background.height());
   }
 
-  // With the non-Vista frame, we'll draw a client edge below the toolbar for
-  // non-maximized popups.
-  // Note: We make sure to return the same value in the "no browser window" case
-  // as the "not maximized" case, so that when a popup is opened at a particular
-  // requested size, we'll report the same preferred size during the initial
-  // window size calculation (when there isn't yet a browser window) as when
-  // we're actually laying things out after setting up the browser window.  This
-  // prevents the content area from being off by |kClientEdgeThickness| px.
-  int client_edge_height = win_util::ShouldUseVistaFrame() ||
-      (browser_->window() && browser_->window()->IsMaximized()) ?
-      0 : views::NonClientView::kClientEdgeThickness;
-  return gfx::Size(0,
-      location_bar_->GetPreferredSize().height() + client_edge_height);
+  int vertical_spacing = PopupTopSpacing() + (win_util::ShouldUseVistaFrame() ?
+      kPopupBottomSpacingGlass : kPopupBottomSpacingNonGlass);
+  return gfx::Size(0, location_bar_->GetPreferredSize().height() +
+      vertical_spacing);
 }
 
 void BrowserToolbarView::RunPageMenu(const CPoint& pt, HWND hwnd) {
   Menu::AnchorPoint anchor = Menu::TOPRIGHT;
   if (UILayoutIsRightToLeft())
     anchor = Menu::TOPLEFT;
 
   Menu menu(this, anchor, hwnd);
   menu.AppendMenuItemWithLabel(IDC_CREATE_SHORTCUTS,
       l10n_util::GetString(IDS_CREATE_SHORTCUTS));
@@ skipping 278 matching lines @@
       break;
   }
   if (button)
     button->SetEnabled(enabled);
 }
 
 void BrowserToolbarView::ButtonPressed(views::BaseButton* sender) {
   browser_->ExecuteCommand(sender->GetTag());
 }
 
+// static
+int BrowserToolbarView::PopupTopSpacing() {
+  return win_util::ShouldUseVistaFrame() ? 0 : kPopupTopSpacingNonGlass;
+}
+
 void BrowserToolbarView::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   if (type == NotificationType::PREF_CHANGED) {
     std::wstring* pref_name = Details<std::wstring>(details).ptr();
     if (*pref_name == prefs::kShowHomeButton) {
       Layout();
       SchedulePaint();
     }
   }
@@ skipping 12 matching lines @@
       *accel = views::Accelerator(L'C', false, true, false);
       return true;
     case IDC_PASTE:
       *accel = views::Accelerator(L'V', false, true, false);
       return true;
   }
   // Else, we retrieve the accelerator information from the frame.
   return GetWidget()->GetAccelerator(id, accel);
 }