Restyle omnibox popup

chrome/browser/ui/views/omnibox/omnibox_popup_contents_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/omnibox/omnibox_popup_contents_view.h"
 
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/ui/omnibox/omnibox_popup_non_view.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
-#include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/browser/ui/views/omnibox/omnibox_result_view.h"
+#include "chrome/browser/ui/views/omnibox/omnibox_view_delegate.h"
 #include "chrome/browser/ui/views/omnibox/touch_omnibox_popup_contents_view.h"
+#include "grit/theme_resources.h"
+#include "grit/ui_resources.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/path.h"
+#include "ui/views/controls/image_view.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_AURA)
 #include "ui/views/corewm/window_animations.h"
 #endif
 
-#if defined(OS_WIN)
-#include <dwmapi.h>
-
-#include "base/win/scoped_gdi_object.h"
-#if !defined(USE_AURA)
-#include "ui/base/win/shell.h"
-#endif
-#endif
-
 namespace {
 
 const SkAlpha kGlassPopupAlpha = 240;
 const SkAlpha kOpaquePopupAlpha = 255;
 
 // The size delta between the font used for the edit and the result rows. Passed
 // to gfx::Font::DeriveFont.
 #if defined(OS_CHROMEOS)
 // Don't adjust the size on Chrome OS (http://crbug.com/61433).
 const int kEditFontAdjust = 0;
 #else
 const int kEditFontAdjust = -1;
 #endif
 
+// This is the number of pixels in the border image interior to the actual
+// border.
+const int kBorderInterior = 6;
+
 }  // namespace
 
 class OmniboxPopupContentsView::AutocompletePopupWidget
     : public views::Widget,
       public base::SupportsWeakPtr<AutocompletePopupWidget> {
  public:
   AutocompletePopupWidget() {}
   virtual ~AutocompletePopupWidget() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutocompletePopupWidget);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxPopupContentsView, public:
 
 OmniboxPopupView* OmniboxPopupContentsView::Create(
     const gfx::Font& font,
     OmniboxView* omnibox_view,
     OmniboxEditModel* edit_model,
-    views::View* location_bar) {
+    OmniboxViewDelegate* view_delegate) {
   if (chrome::IsInstantExtendedAPIEnabled())
     return new OmniboxPopupNonView(edit_model);
 
   OmniboxPopupContentsView* view = NULL;
   if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
     view = new TouchOmniboxPopupContentsView(
-        font, omnibox_view, edit_model, location_bar);
+        font, omnibox_view, edit_model, view_delegate);
   } else {
     view = new OmniboxPopupContentsView(
-        font, omnibox_view, edit_model, location_bar);
+        font, omnibox_view, edit_model, view_delegate);
   }
 
   view->Init();
   return view;
 }
 
 OmniboxPopupContentsView::OmniboxPopupContentsView(
     const gfx::Font& font,
     OmniboxView* omnibox_view,
     OmniboxEditModel* edit_model,
-    views::View* location_bar)
+    OmniboxViewDelegate* view_delegate)
     : model_(new OmniboxPopupModel(this, edit_model)),
       omnibox_view_(omnibox_view),
-      location_bar_(location_bar),
+      view_delegate_(view_delegate),
       font_(font.DeriveFont(kEditFontAdjust)),
       ignore_mouse_drag_(false),
-      size_animation_(this) {
-  bubble_border_ = new views::BubbleBorder(views::BubbleBorder::NONE,
-      views::BubbleBorder::NO_SHADOW, SK_ColorWHITE);
-  set_border(const_cast<views::BubbleBorder*>(bubble_border_));
+      size_animation_(this),
+      provider_logo_(new views::ImageView),
+      left_margin_(0),
+      right_margin_(0),
+      outside_vertical_padding_(0) {
   // The contents is owned by the LocationBarView.
   set_owned_by_client();
+
+  ui::ThemeProvider* theme = view_delegate_->GetThemeProviderForPopup();
+  provider_logo_->set_owned_by_client();

[Peter Kasting, 2013/06/06 18:52:16]

Why use set_owned_by_client() and a scoped_ptr instead of using a raw pointer
and having normal views ownership?  You'd probably want to move this block of
code to Init() but that doesn't seem like a problem.

+  provider_logo_->SetImage(theme->GetImageSkiaNamed(IDR_OMNIBOX_GOOGLE_LOGO));
+  provider_logo_->SizeToPreferredSize();
+
+  bottom_shadow_ = theme->GetImageSkiaNamed(IDR_BUBBLE_B);
 }
 
 void OmniboxPopupContentsView::Init() {
   // This can't be done in the constructor as at that point we aren't
   // necessarily our final class yet, and we may have subclasses
   // overriding CreateResultView.
   for (size_t i = 0; i < AutocompleteResult::kMaxMatches; ++i) {
     OmniboxResultView* result_view = CreateResultView(this, i, font_);
     result_view->SetVisible(false);
     AddChildViewAt(result_view, static_cast<int>(i));
   }
+  AddChildView(provider_logo_.get());
 }
 
 OmniboxPopupContentsView::~OmniboxPopupContentsView() {
   // We don't need to do anything with |popup_| here.  The OS either has already
   // closed the window, in which case it's been deleted, or it will soon, in
   // which case there's nothing we need to do.
 }
 
 gfx::Rect OmniboxPopupContentsView::GetPopupBounds() const {
   if (!size_animation_.is_animating())
     return target_bounds_;
 
   gfx::Rect current_frame_bounds = start_bounds_;
   int total_height_delta = target_bounds_.height() - start_bounds_.height();
   // Round |current_height_delta| instead of truncating so we won't leave single
   // white pixels at the bottom of the popup as long when animating very small
   // height differences.
   int current_height_delta = static_cast<int>(
       size_animation_.GetCurrentValue() * total_height_delta - 0.5);
   current_frame_bounds.set_height(
       current_frame_bounds.height() + current_height_delta);
   return current_frame_bounds;
 }
 
 void OmniboxPopupContentsView::LayoutChildren() {
   gfx::Rect contents_rect = GetContentsBounds();
-  int top = contents_rect.y();
-  for (int i = 0; i < child_count(); ++i) {
+
+  provider_logo_->SetPosition(gfx::Point(5, 5));

[Peter Kasting, 2013/06/06 18:52:16]

These numbers are pretty magic

+
+  int top = contents_rect.y() + outside_vertical_padding_;
+  int left = contents_rect.x() + left_margin_;
+  int width = contents_rect.width() - left_margin_ - right_margin_;

[Peter Kasting, 2013/06/06 18:52:16]

Or just:

  contents_rect.Inset(left_margin_, outside_vertical_padding_, right_margin_,
                      0);

And then use the rect coords below.

+  for (size_t i = 0; i < AutocompleteResult::kMaxMatches; ++i) {
     View* v = child_at(i);
     if (v->visible()) {
-      v->SetBounds(contents_rect.x(), top, contents_rect.width(),
-                   v->GetPreferredSize().height());
+      v->SetBounds(left, top, width, v->GetPreferredSize().height());
       top = v->bounds().bottom();
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxPopupContentsView, OmniboxPopupView overrides:
 
 bool OmniboxPopupContentsView::IsOpen() const {
   return popup_ != NULL;
@@ skipping 27 matching lines @@
 
   // Update the match cached by each row, in the process of doing so make sure
   // we have enough row views.
   size_t child_rv_count = child_count();
   const size_t result_size = model_->result().size();
   for (size_t i = 0; i < result_size; ++i) {
     OmniboxResultView* view = result_view_at(i);
     view->SetMatch(GetMatchAtIndex(i));
     view->SetVisible(true);
   }
-  for (size_t i = result_size; i < child_rv_count; ++i)
+  for (size_t i = result_size; i < AutocompleteResult::kMaxMatches; ++i)
     child_at(i)->SetVisible(false);
 
   gfx::Rect new_target_bounds = CalculateTargetBounds(CalculatePopupHeight());
 
   // If we're animating and our target height changes, reset the animation.
   // NOTE: If we just reset blindly on _every_ update, then when the user types
   // rapidly we could get "stuck" trying repeatedly to animate shrinking by the
   // last few pixels to get to one visible result.
   if (new_target_bounds.height() != target_bounds_.height())
     size_animation_.Reset();
   target_bounds_ = new_target_bounds;
 
   if (popup_ == NULL) {
     // If the popup is currently closed, we need to create it.
     popup_ = (new AutocompletePopupWidget)->AsWeakPtr();
     views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
     params.can_activate = false;
     params.transparent = true;
-    params.parent = location_bar_->GetWidget()->GetNativeView();
+    params.parent = view_delegate_->GetPopupParent();
     params.bounds = GetPopupBounds();
-    params.context = location_bar_->GetWidget()->GetNativeView();
+    params.context = view_delegate_->GetPopupParent();
     popup_->Init(params);
 #if defined(USE_AURA)
     views::corewm::SetWindowVisibilityAnimationType(
         popup_->GetNativeView(),
         views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL);
 #if defined(OS_CHROMEOS)
     // No animation for autocomplete popup appearance.
     views::corewm::SetWindowVisibilityAnimationTransition(
         popup_->GetNativeView(), views::corewm::ANIMATE_HIDE);
 #endif
@@ skipping 59 matching lines @@
     const ui::Animation* animation) {
   // We should only be running the animation when the popup is already visible.
   DCHECK(popup_ != NULL);
   popup_->SetBounds(GetPopupBounds());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxPopupContentsView, views::View overrides:
 
 void OmniboxPopupContentsView::Layout() {
-  UpdateBlurRegion();
-
   // Size our children to the available content area.
   LayoutChildren();
 
   // We need to manually schedule a paint here since we are a layered window and
   // won't implicitly require painting until we ask for one.
   SchedulePaint();
 }
 
 views::View* OmniboxPopupContentsView::GetEventHandlerForPoint(
     const gfx::Point& point) {
@@ skipping 76 matching lines @@
   canvas->DrawColor(result_view_at(0)->GetColor(
       OmniboxResultView::NORMAL, OmniboxResultView::BACKGROUND));
   View::PaintChildren(canvas);
 }
 
 int OmniboxPopupContentsView::CalculatePopupHeight() {
   DCHECK_GE(static_cast<size_t>(child_count()), model_->result().size());
   int popup_height = 0;
   for (size_t i = 0; i < model_->result().size(); ++i)
     popup_height += child_at(i)->GetPreferredSize().height();
-  return popup_height;
+
+  // Add enough space on the top and bottom so it looks like there is the same
+  // amount of space between the text and the popup border as there is in the
+  // interior between each row of text.
+  //
+  // Discovering the exact amount of leading and padding around the font is
+  // a bit tricky and platform-specific, but this computation seems to work in
+  // practice.
+  OmniboxResultView* result_view = result_view_at(0);
+  outside_vertical_padding_ =
+      (result_view->GetPreferredSize().height() -
+       result_view->GetTextHeight());
+
+  return popup_height + outside_vertical_padding_ * 2 +
+        bottom_shadow_->height() - kBorderInterior;
 }
 
 OmniboxResultView* OmniboxPopupContentsView::CreateResultView(
     OmniboxResultViewModel* model,
     int model_index,
     const gfx::Font& font) {
-  return new OmniboxResultView(model, model_index, location_bar_, font);
+  return new OmniboxResultView(model, model_index, view_delegate_, font);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxPopupContentsView, views::View overrides, protected:
 
 void OmniboxPopupContentsView::OnPaint(gfx::Canvas* canvas) {
+  gfx::Rect contents_bounds = GetContentsBounds();
+  contents_bounds.set_height(
+      contents_bounds.height() - bottom_shadow_->height() + kBorderInterior);
+
   gfx::Path path;
-  MakeContentsPath(&path, GetContentsBounds());
+  MakeContentsPath(&path, contents_bounds);
   canvas->Save();
   canvas->sk_canvas()->clipPath(path,
                                 SkRegion::kIntersect_Op,
                                 true /* doAntialias */);
   PaintResultViews(canvas);
-
-  // We want the contents background to be slightly transparent so we can see
-  // the blurry glass effect on DWM systems behind. We do this _after_ we paint
-  // the children since they paint text, and GDI will reset this alpha data if
-  // we paint text after this call.
-  MakeCanvasTransparent(canvas);
   canvas->Restore();
 
   // Now we paint the border, so it will be alpha-blended atop the contents.
   // This looks slightly better in the corners than drawing the contents atop
   // the border.
-  OnPaintBorder(canvas);
+  //OnPaintBorder(canvas);

[Peter Kasting, 2013/06/06 18:52:16]

Remove this

+
+  canvas->TileImageInt(*bottom_shadow_, 0, height() - bottom_shadow_->height(),
+                       width(), bottom_shadow_->height());
 }
 
 void OmniboxPopupContentsView::PaintChildren(gfx::Canvas* canvas) {
   // We paint our children inside OnPaint().
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxPopupContentsView, private:
 
 bool OmniboxPopupContentsView::HasMatchAt(size_t index) const {
   return index < model_->result().size();
 }
 
 const AutocompleteMatch& OmniboxPopupContentsView::GetMatchAtIndex(
     size_t index) const {
   return model_->result().match_at(index);
 }
 
 void OmniboxPopupContentsView::MakeContentsPath(

[Peter Kasting, 2013/06/06 18:52:16]

This function can just be inlined into its lone caller now.

     gfx::Path* path,
     const gfx::Rect& bounding_rect) {
   SkRect rect;

[Peter Kasting, 2013/06/06 18:52:16]

Can avoid this temp by using the 4-arg version of SkPath::addRect().

   rect.set(SkIntToScalar(bounding_rect.x()),
            SkIntToScalar(bounding_rect.y()),
            SkIntToScalar(bounding_rect.right()),
            SkIntToScalar(bounding_rect.bottom()));
-
-  SkScalar radius = SkIntToScalar(views::BubbleBorder::GetCornerRadius());
-  path->addRoundRect(rect, radius, radius);
-}
-
-void OmniboxPopupContentsView::UpdateBlurRegion() {
-#if defined(OS_WIN) && !defined(USE_AURA)
-  // We only support background blurring on Vista with Aero-Glass enabled.
-  if (!ui::win::IsAeroGlassEnabled() || !GetWidget())
-    return;
-
-  // Provide a blurred background effect within the contents region of the
-  // popup.
-  DWM_BLURBEHIND bb = {0};
-  bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;
-  bb.fEnable = true;
-
-  // Translate the contents rect into widget coordinates, since that's what
-  // DwmEnableBlurBehindWindow expects a region in.
-  gfx::Rect contents_rect = ConvertRectToWidget(GetContentsBounds());
-  gfx::Path contents_path;
-  MakeContentsPath(&contents_path, contents_rect);
-  base::win::ScopedGDIObject<HRGN> popup_region;
-  popup_region.Set(contents_path.CreateNativeRegion());
-  bb.hRgnBlur = popup_region.Get();
-  DwmEnableBlurBehindWindow(GetWidget()->GetNativeView(), &bb);
-#endif
-}
-
-void OmniboxPopupContentsView::MakeCanvasTransparent(gfx::Canvas* canvas) {
-  // Allow the window blur effect to show through the popup background.
-  SkAlpha alpha = GetThemeProvider()->ShouldUseNativeFrame() ?
-      kGlassPopupAlpha : kOpaquePopupAlpha;
-  canvas->DrawColor(SkColorSetA(
-      result_view_at(0)->GetColor(OmniboxResultView::NORMAL,
-          OmniboxResultView::BACKGROUND), alpha), SkXfermode::kDstIn_Mode);
+  path->addRect(rect);
 }
 
 void OmniboxPopupContentsView::OpenIndex(size_t index,
                                          WindowOpenDisposition disposition) {
   if (!HasMatchAt(index))
     return;
 
   // OpenMatch() may close the popup, which will clear the result set and, by
   // extension, |match| and its contents.  So copy the relevant match out to
   // make sure it stays alive until the call completes.
@@ skipping 11 matching lines @@
   for (int i = 0; i < nb_match; ++i) {
     views::View* child = child_at(i);
     gfx::Point point_in_child_coords(point);
     View::ConvertPointToTarget(this, child, &point_in_child_coords);
     if (child->HitTestPoint(point_in_child_coords))
       return i;
   }
   return OmniboxPopupModel::kNoMatch;
 }
 
 gfx::Rect OmniboxPopupContentsView::CalculateTargetBounds(int h) {

[Peter Kasting, 2013/06/06 18:52:16]

This can be inlined into its caller too

-  gfx::Rect location_bar_bounds(location_bar_->GetContentsBounds());
-  const views::Border* border = location_bar_->border();
-  if (border) {
-    // Adjust for the border so that the bubble and location bar borders are
-    // aligned.
-    gfx::Insets insets = border->GetInsets();
-    location_bar_bounds.Inset(insets.left(), 0, insets.right(), 0);
-  } else {
-    // The normal location bar is drawn using a background graphic that includes
-    // the border, so we inset by enough to make the edges line up, and the
-    // bubble appear at the same height as the Star bubble.
-    location_bar_bounds.Inset(LocationBarView::kNormalHorizontalEdgeThickness,
-                              0);
-  }
-  gfx::Point location_bar_origin(location_bar_bounds.origin());
-  views::View::ConvertPointToScreen(location_bar_, &location_bar_origin);
-  location_bar_bounds.set_origin(location_bar_origin);
-  return bubble_border_->GetBounds(
-      location_bar_bounds, gfx::Size(location_bar_bounds.width(), h));
+  gfx::Point top_left_screen_coord;
+  int width;
+  view_delegate_->GetPopupPositioningInfo(
+      &top_left_screen_coord, &width, &left_margin_, &right_margin_);
+
+  return gfx::Rect(top_left_screen_coord, gfx::Size(width, h));
 }
 
 void OmniboxPopupContentsView::UpdateLineEvent(
     const ui::LocatedEvent& event,
     bool should_set_selected_line) {
   size_t index = GetIndexForPoint(event.location());
   model_->SetHoveredLine(index);
   if (HasMatchAt(index) && should_set_selected_line)
     model_->SetSelectedLine(index, false, false);
 }
 
 void OmniboxPopupContentsView::OpenSelectedLine(
     const ui::LocatedEvent& event,
     WindowOpenDisposition disposition) {
   size_t index = GetIndexForPoint(event.location());
   OpenIndex(index, disposition);
 }
 
 OmniboxResultView* OmniboxPopupContentsView::result_view_at(size_t i) {
   return static_cast<OmniboxResultView*>(child_at(static_cast<int>(i)));
 }