Fix up the Windows omnibox after the recent endcap removal. This fixes most ...

chrome/browser/views/location_bar/location_bar_view.cc

 // Copyright (c) 2010 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/location_bar/location_bar_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 10 matching lines @@
 #include "chrome/browser/views/location_bar/content_setting_image_view.h"
 #include "chrome/browser/views/location_bar/ev_bubble_view.h"
 #include "chrome/browser/views/location_bar/keyword_hint_view.h"
 #include "chrome/browser/views/location_bar/location_icon_view.h"
 #include "chrome/browser/views/location_bar/page_action_image_view.h"
 #include "chrome/browser/views/location_bar/page_action_with_badge_view.h"
 #include "chrome/browser/views/location_bar/selected_keyword_view.h"
 #include "chrome/browser/views/location_bar/star_view.h"
 #include "gfx/canvas.h"
 #include "gfx/color_utils.h"
+#include "gfx/skia_util.h"
 #include "grit/theme_resources.h"
 #include "views/drag_utils.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/views/first_run_bubble.h"
 #endif
 
 using views::View;
 
 // static
 const int LocationBarView::kVertMargin = 2;
+const int LocationBarView::kEdgeThickness = 2;
+const int LocationBarView::kItemPadding = 3;
 
-// Padding between items in the location bar.
-static const int kViewPadding = 3;
+// Convenience: Total space at the edges of the bar.
+const int kEdgePadding =
+    LocationBarView::kEdgeThickness + LocationBarView::kItemPadding;
 
 // Padding before the start of a bubble.
-static const int kBubblePadding = kViewPadding - 1;
+static const int kBubblePadding = kEdgePadding - 1;
 
 // Padding between the location icon and the edit, if they're adjacent.
-static const int kLocationIconEditPadding = kViewPadding - 1;
+static const int kLocationIconEditPadding = LocationBarView::kItemPadding - 1;
+
+// Padding after the star.
+static const int kStarPadding = kEdgePadding + 1;
 
 static const int kEVBubbleBackgroundImages[] = {
   IDR_OMNIBOX_EV_BUBBLE_BACKGROUND_L,
   IDR_OMNIBOX_EV_BUBBLE_BACKGROUND_C,
   IDR_OMNIBOX_EV_BUBBLE_BACKGROUND_R,
 };
 
 static const int kSelectedKeywordBackgroundImages[] = {
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_L,
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_C,
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_R,
 };
 
-static const SkBitmap* kBackground = NULL;
-
-static const SkBitmap* kPopupBackground = NULL;
+static const int kNormalModeBackgroundImages[] = {
+  IDR_LOCATIONBG_L,
+  IDR_LOCATIONBG_C,
+  IDR_LOCATIONBG_R,
+};
 
 // LocationBarView -----------------------------------------------------------
 
 LocationBarView::LocationBarView(Profile* profile,
                                  CommandUpdater* command_updater,
                                  ToolbarModel* model,
                                  Delegate* delegate,
                                  Mode mode)
     : profile_(profile),
       command_updater_(command_updater),
       model_(model),
       delegate_(delegate),
       disposition_(CURRENT_TAB),
       location_icon_view_(NULL),
       ev_bubble_view_(NULL),
       location_entry_view_(NULL),
       selected_keyword_view_(NULL),
       keyword_hint_view_(NULL),
       star_view_(NULL),
       mode_(mode),
       force_hidden_count_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(first_run_bubble_(this)) {
   DCHECK(profile_);
   SetID(VIEW_ID_LOCATION_BAR);
   SetFocusable(true);
 
-  if (!kBackground) {
-    ResourceBundle &rb = ResourceBundle::GetSharedInstance();
-    kBackground = rb.GetBitmapNamed(IDR_LOCATIONBG);
-    kPopupBackground = rb.GetBitmapNamed(IDR_LOCATIONBG_POPUPMODE_CENTER);
-  }
+  if (mode_ == NORMAL)
+    painter_.reset(new views::HorizontalPainter(kNormalModeBackgroundImages));
 }
 
 LocationBarView::~LocationBarView() {
 }
 
 void LocationBarView::Init() {
   if (mode_ == POPUP) {
     font_ = ResourceBundle::GetSharedInstance().GetFont(
         ResourceBundle::BaseFont);
   } else {
@@ skipping 243 matching lines @@
   // Compensate for some built-in padding in the Star image.
   screen_bounds.Inset(1, 1, 1, 2);
   gfx::Point origin(screen_bounds.origin());
   views::View::ConvertPointToScreen(star_view_, &origin);
   screen_bounds.set_origin(origin);
   browser::ShowBookmarkBubbleView(GetWindow(), screen_bounds, star_view_,
                                   profile_, url, newly_bookmarked);
 }
 
 gfx::Size LocationBarView::GetPreferredSize() {
-  return gfx::Size(0,
-      (mode_ == POPUP ? kPopupBackground : kBackground)->height());
+  return gfx::Size(0, GetThemeProvider()->GetBitmapNamed(mode_ == POPUP ?
+      IDR_LOCATIONBG_POPUPMODE_CENTER : IDR_LOCATIONBG_C)->height());
 }
 
 void LocationBarView::Layout() {
   if (!location_entry_.get())
     return;
 
-  int entry_width = width() - kViewPadding;
+  int entry_width = width() - (star_view_ ? kStarPadding : kEdgePadding);
 
   // |location_icon_view_| is visible except when |ev_bubble_view_| or
   // |selected_keyword_view_| are visible.
   int location_icon_width = 0;
   int ev_bubble_width = 0;
   location_icon_view_->SetVisible(false);
   ev_bubble_view_->SetVisible(false);
   const std::wstring keyword(location_entry_->model()->keyword());
   const bool is_keyword_hint(location_entry_->model()->is_keyword_hint());
   const bool show_selected_keyword = !keyword.empty() && !is_keyword_hint;
   if (show_selected_keyword) {
-    entry_width -= kViewPadding;  // Assume the keyword might be hidden.
+    entry_width -= kEdgePadding;  // Assume the keyword might be hidden.
   } else if (model_->GetSecurityLevel() == ToolbarModel::EV_SECURE) {
     ev_bubble_view_->SetVisible(true);
     ev_bubble_view_->SetLabel(model_->GetEVCertName());
     ev_bubble_width = ev_bubble_view_->GetPreferredSize().width();
     // We'll adjust this width and take it out of |entry_width| below.
   } else {
     location_icon_view_->SetVisible(true);
     location_icon_width = location_icon_view_->GetPreferredSize().width();
     entry_width -=
-        kViewPadding + location_icon_width + kLocationIconEditPadding;
+        kEdgePadding + location_icon_width + kLocationIconEditPadding;
   }
 
   if (star_view_)
-    entry_width -= star_view_->GetPreferredSize().width() + kViewPadding;
+    entry_width -= star_view_->GetPreferredSize().width() + kItemPadding;
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
     if ((*i)->IsVisible())
-      entry_width -= (*i)->GetPreferredSize().width() + kViewPadding;
+      entry_width -= (*i)->GetPreferredSize().width() + kItemPadding;
   }
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
     if ((*i)->IsVisible())
-      entry_width -= (*i)->GetPreferredSize().width() + kViewPadding;
+      entry_width -= (*i)->GetPreferredSize().width() + kItemPadding;
   }
 
   // Size the EV bubble.  We do this after taking the star/page actions/content
   // settings out of |entry_width| so we won't take too much space.
   if (ev_bubble_width) {
     // Try to elide the bubble to be no larger than half the total available
     // space, but never elide it any smaller than 150 px.
     static const int kMinElidedBubbleWidth = 150;
     static const double kMaxBubbleFraction = 0.5;
     ev_bubble_width = std::min(ev_bubble_width, std::max(kMinElidedBubbleWidth,
-        static_cast<int>((entry_width - kBubblePadding - kViewPadding) *
+        static_cast<int>((entry_width - kBubblePadding - kItemPadding) *
         kMaxBubbleFraction)));
 
-    entry_width -= kBubblePadding + ev_bubble_width + kViewPadding;
+    entry_width -= kBubblePadding + ev_bubble_width + kItemPadding;
   }
 
 #if defined(OS_WIN)
   RECT formatting_rect;
   location_entry_->GetRect(&formatting_rect);
   RECT edit_bounds;
   location_entry_->GetClientRect(&edit_bounds);
   int max_edit_width = entry_width - formatting_rect.left -
                        (edit_bounds.right - formatting_rect.right);
 #else
@@ skipping 13 matching lines @@
   } else if (show_keyword_hint) {
     if (keyword_hint_view_->keyword() != keyword)
       keyword_hint_view_->SetKeyword(keyword);
   }
 
   // TODO(sky): baseline layout.
   int location_y = TopMargin();
   int location_height = std::max(height() - location_y - kVertMargin, 0);
 
   // Lay out items to the right of the edit field.
-  int offset = width() - kViewPadding;
+  int offset = width();
   if (star_view_) {
+    offset -= kStarPadding;
     int star_width = star_view_->GetPreferredSize().width();
     offset -= star_width;
     star_view_->SetBounds(offset, location_y, star_width, location_height);
-    offset -= kViewPadding;
+    offset -= kItemPadding;
+  } else {
+    offset -= kEdgePadding;
   }
 
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
     if ((*i)->IsVisible()) {
       int page_action_width = (*i)->GetPreferredSize().width();
       offset -= page_action_width;
       (*i)->SetBounds(offset, location_y, page_action_width, location_height);
-      offset -= kViewPadding;
+      offset -= kItemPadding;
     }
   }
   // We use a reverse_iterator here because we're laying out the views from
   // right to left but in the vector they're ordered left to right.
   for (ContentSettingViews::const_reverse_iterator
        i(content_setting_views_.rbegin()); i != content_setting_views_.rend();
        ++i) {
     if ((*i)->IsVisible()) {
       int content_blocked_width = (*i)->GetPreferredSize().width();
       offset -= content_blocked_width;
       (*i)->SetBounds(offset, location_y, content_blocked_width,
                       location_height);
-      offset -= kViewPadding;
+      offset -= kItemPadding;
     }
   }
 
   // Now lay out items to the left of the edit field.
   if (location_icon_view_->IsVisible()) {
-    location_icon_view_->SetBounds(kViewPadding, location_y,
+    location_icon_view_->SetBounds(kEdgePadding, location_y,
                                    location_icon_width, location_height);
     offset = location_icon_view_->bounds().right() + kLocationIconEditPadding;
   } else if (ev_bubble_view_->IsVisible()) {
     ev_bubble_view_->SetBounds(kBubblePadding, location_y, ev_bubble_width,
                                location_height);
-    offset = ev_bubble_view_->bounds().right() + kViewPadding;
+    offset = ev_bubble_view_->bounds().right() + kItemPadding;
   } else {
-    offset = show_selected_keyword ? kBubblePadding : kViewPadding;
+    offset = show_selected_keyword ? kBubblePadding : kEdgePadding;
   }
 
   // Now lay out the edit field and views that autocollapse to give it more
   // room.
   gfx::Rect location_bounds(offset, location_y, entry_width, location_height);
   if (show_selected_keyword) {
     LayoutView(true, selected_keyword_view_, available_width, &location_bounds);
     if (!selected_keyword_view_->IsVisible()) {
       location_bounds.set_x(
-          location_bounds.x() + kViewPadding - kBubblePadding);
+          location_bounds.x() + kEdgePadding - kBubblePadding);
     }
   } else if (show_keyword_hint) {
     LayoutView(false, keyword_hint_view_, available_width, &location_bounds);
   }
 
   location_entry_view_->SetBounds(location_bounds);
 }
 
 void LocationBarView::Paint(gfx::Canvas* canvas) {
   View::Paint(canvas);
+
+  if (painter_.get()) {
+    painter_->Paint(width(), height(), canvas);
+  } else if (mode_ == POPUP) {
+    canvas->TileImageInt(*GetThemeProvider()->GetBitmapNamed(
+        IDR_LOCATIONBG_POPUPMODE_CENTER), 0, 0, 0, 0, width(), height());
+  }
   // When used in the app launcher, don't draw a border, the LocationBarView has
   // its own views::Border.
-  if (mode_ != APP_LAUNCHER) {
-    const SkBitmap* background =
-        mode_ == POPUP ?
-            kPopupBackground :
-            GetThemeProvider()->GetBitmapNamed(IDR_LOCATIONBG);
 
-    canvas->TileImageInt(*background, 0, 0, 0, 0, width(), height());
+  // Draw the background color so that the graphical elements at the edges
+  // appear over the correct color.  (The edit draws its own background, so this
+  // isn't important for that.)
+  // TODO(pkasting): We need images that are transparent in the middle, so we
+  // can draw the border images over the background color instead of the
+  // reverse; this antialiases better (see comments in
+  // AutocompletePopupContentsView::Paint()).
+  gfx::Rect bounds(GetLocalBounds(false));
+  bounds.Inset(0, TopMargin(), 0, kVertMargin);
+  SkColor color(GetColor(ToolbarModel::NONE, BACKGROUND));
+  if (mode_ == NORMAL) {
+    SkPaint paint;
+    paint.setColor(color);
+    paint.setStyle(SkPaint::kFill_Style);
+    paint.setAntiAlias(true);
+    // The round corners of the omnibox match the round corners of the dropdown
+    // below, and all our other bubbles.
+    static const SkScalar radius(

[sky, 2010/06/14 20:20:51]

Is it really worth making this static?

[Peter Kasting, 2010/06/14 20:22:16]

Oops, I didn't mean to do that.

+        SkIntToScalar(BubbleBorder::GetCornerRadius()));
+    bounds.Inset(kEdgeThickness, 0);
+    canvas->drawRoundRect(gfx::RectToSkRect(bounds), radius, radius, paint);
+  } else {
+    canvas->FillRectInt(color, bounds.x(), bounds.y(), bounds.width(),
+                        bounds.height());
   }
-  gfx::Rect bounds = GetLocalBounds(false);
-  int top_margin = TopMargin();
-  canvas->FillRectInt(GetColor(ToolbarModel::NONE, BACKGROUND), bounds.x(),
-                      top_margin, bounds.width(),
-                      std::max(height() - top_margin - kVertMargin, 0));
 }
 
 void LocationBarView::VisibleBoundsInRootChanged() {
   location_entry_->ClosePopup();
 }
 
 #if defined(OS_WIN)
 bool LocationBarView::OnMousePressed(const views::MouseEvent& event) {
   UINT msg;
   if (event.IsLeftMouseButton()) {
@@ skipping 119 matching lines @@
   // apparently buggy. In both LTR UI and RTL UI with left-to-right layout,
   // PosFromChar(i) might return 0 when i is greater than 1.
   return std::max(
       location_bar_width - font_.GetStringWidth(location_entry_->GetText()), 0);
 #else
   return location_bar_width - location_entry_->TextWidth();
 #endif
 }
 
 bool LocationBarView::UsePref(int pref_width, int available_width) {
-  return (pref_width + kViewPadding <= available_width);
+  return (pref_width + kItemPadding <= available_width);
 }
 
 void LocationBarView::LayoutView(bool leading,
                                  views::View* view,
                                  int available_width,
                                  gfx::Rect* bounds) {
   DCHECK(view && bounds);
   gfx::Size view_size = view->GetPreferredSize();
   if (!UsePref(view_size.width(), available_width))
     view_size = view->GetMinimumSize();
-  if (view_size.width() + kViewPadding >= bounds->width()) {
+  if (view_size.width() + kItemPadding >= bounds->width()) {
     view->SetVisible(false);
     return;
   }
   if (leading) {
     view->SetBounds(bounds->x(), bounds->y(), view_size.width(),
                     bounds->height());
-    bounds->Offset(view_size.width() + kViewPadding, 0);
+    bounds->Offset(view_size.width() + kItemPadding, 0);
   } else {
     view->SetBounds(bounds->right() - view_size.width(), bounds->y(),
                     view_size.width(), bounds->height());
   }
-  bounds->set_width(bounds->width() - view_size.width() - kViewPadding);
+  bounds->set_width(bounds->width() - view_size.width() - kItemPadding);
   view->SetVisible(true);
 }
 
 void LocationBarView::RefreshContentSettingViews() {
   const TabContents* tab_contents = delegate_->GetTabContents();
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
     (*i)->UpdateFromTabContents(
         model_->input_in_progress() ? NULL : tab_contents);
   }
@@ skipping 272 matching lines @@
         page_action_views_[i]->image_view()->ExecuteAction(kLeftMouseButton,
             false);  // inspect_with_devtools
         return;
       }
       ++current;
     }
   }
 
   NOTREACHED();
 }