InstantExtended(gtk): Hide top match if told to so.

chrome/browser/ui/gtk/omnibox/omnibox_popup_view_gtk.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/gtk/omnibox/omnibox_popup_view_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 80 matching lines @@
 // UTF-8 Left-to-right embedding.
 const char* kLRE = "\xe2\x80\xaa";
 
 // Return a Rect covering the whole area of |window|.
 gfx::Rect GetWindowRect(GdkWindow* window) {
   gint width = gdk_window_get_width(window);
   gint height = gdk_window_get_height(window);
   return gfx::Rect(width, height);
 }
 
-// Return a Rect for the space for a result line.  This excludes the border,
-// but includes the padding.  This is the area that is colored for a selection.
-gfx::Rect GetRectForLine(size_t line, int width) {
-  return gfx::Rect(kBorderThickness,
-                   (line * kHeightPerResult) + kBorderThickness,
-                   width - (kBorderThickness * 2),
-                   kHeightPerResult);
-}
-
 // TODO(deanm): Find some better home for this, and make it more efficient.
 size_t GetUTF8Offset(const string16& text, size_t text_offset) {
   return UTF16ToUTF8(text.substr(0, text_offset)).length();
 }
 
 // Generates the normal URL color, a green color used in unhighlighted URL
 // text. It is a mix of |kURLTextColor| and the current text color.  Unlike the
 // selected text color, it is more important to match the qualities of the
 // foreground typeface color instead of taking the background into account.
 GdkColor NormalURLColor(GdkColor foreground) {
@@ skipping 43 matching lines @@
   // The luminance should match the luminance of the foreground text.  Again,
   // we clamp so as to have at some amount of color (green) in the text.
   double opposite_l = fg_hsl.l;
   double l = std::max(0.1, std::min(0.9, opposite_l));
 
   color_utils::HSL output = { hue_hsl.h, s, l };
   return gfx::SkColorToGdkColor(color_utils::HSLToSkColor(output, 255));
 }
 }  // namespace
 
+// static
 void OmniboxPopupViewGtk::SetupLayoutForMatch(
     PangoLayout* layout,
     const string16& text,
     const AutocompleteMatch::ACMatchClassifications& classifications,
     const GdkColor* base_color,
     const GdkColor* dim_color,
     const GdkColor* url_color,
     const std::string& prefix_text) {
   // In RTL, mark text with left-to-right embedding mark if there is no strong
   // RTL characters inside it, so the ending punctuation displays correctly
@@ skipping 78 matching lines @@
   pango_layout_set_text(layout, text_utf8.data(), text_utf8.length());
   pango_layout_set_attributes(layout, attrs);  // Ref taken.
   pango_attr_list_unref(attrs);
 }
 
 OmniboxPopupViewGtk::OmniboxPopupViewGtk(const gfx::Font& font,
                                          OmniboxView* omnibox_view,
                                          OmniboxEditModel* edit_model,
                                          GtkWidget* location_bar)
     : signal_registrar_(new ui::GtkSignalRegistrar),
-      model_(new OmniboxPopupModel(this, edit_model)),
       omnibox_view_(omnibox_view),
       location_bar_(location_bar),
       window_(gtk_window_new(GTK_WINDOW_POPUP)),
       layout_(NULL),
-      theme_service_(GtkThemeService::GetFrom(edit_model->profile())),
+      theme_service_(NULL),
       font_(font.DeriveFont(kEditFontAdjust)),
       ignore_mouse_drag_(false),
       opened_(false) {
+  // edit_model may be NULL in unit tests.
+  if (edit_model) {
+    model_.reset(new OmniboxPopupModel(this, edit_model));
+    theme_service_ = GtkThemeService::GetFrom(edit_model->profile());
+  }
+}
+
+void OmniboxPopupViewGtk::Init() {
   gtk_widget_set_can_focus(window_, FALSE);
   // Don't allow the window to be resized.  This also forces the window to
   // shrink down to the size of its child contents.
   gtk_window_set_resizable(GTK_WINDOW(window_), FALSE);
   gtk_widget_set_app_paintable(window_, TRUE);
   // Have GTK double buffer around the expose signal.
   gtk_widget_set_double_buffered(window_, TRUE);
 
   // Cache the layout so we don't have to create it for every expose.  If we
   // were a real widget we should handle changing directions, but we're not
@@ skipping 37 matching lines @@
 
 OmniboxPopupViewGtk::~OmniboxPopupViewGtk() {
   // Stop listening to our signals before we destroy the model. I suspect that
   // we can race window destruction, otherwise.
   signal_registrar_.reset();
 
   // Explicitly destroy our model here, before we destroy our GTK widgets.
   // This is because the model destructor can call back into us, and we need
   // to make sure everything is still valid when it does.
   model_.reset();
-  g_object_unref(layout_);
-  gtk_widget_destroy(window_);
+  // layout_ may be NULL in unit tests.
+  if (layout_) {
+    g_object_unref(layout_);
+    gtk_widget_destroy(window_);
+  }
 }
 
 bool OmniboxPopupViewGtk::IsOpen() const {
   return opened_;
 }
 
 void OmniboxPopupViewGtk::InvalidateLine(size_t line) {
   // TODO(deanm): Is it possible to use some constant for the width, instead
   // of having to query the width of the window?
   GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
   GdkRectangle line_rect = GetRectForLine(
       line, GetWindowRect(gdk_window).width()).ToGdkRectangle();
   gdk_window_invalidate_rect(gdk_window, &line_rect, FALSE);
 }
 
 void OmniboxPopupViewGtk::UpdatePopupAppearance() {
-  const AutocompleteResult& result = model_->result();
-  if (result.empty()) {
+  const AutocompleteResult& result = GetResult();
+  const size_t hidden_matches = GetHiddenMatchCount();
+  if (result.size() <= hidden_matches) {
     Hide();
     return;
   }
 
-  Show(result.size());
+  Show(result.size() - hidden_matches);
   gtk_widget_queue_draw(window_);
 }
 
 gfx::Rect OmniboxPopupViewGtk::GetTargetBounds() {
   if (!gtk_widget_get_realized(window_))
     return gfx::Rect();
 
   gfx::Rect retval = ui::GetWidgetScreenBounds(window_);
 
   // The widget bounds don't update synchronously so may be out of sync with
@@ skipping 89 matching lines @@
 void OmniboxPopupViewGtk::StackWindow() {
   gfx::NativeView omnibox_view = omnibox_view_->GetNativeView();
   DCHECK(GTK_IS_WIDGET(omnibox_view));
   GtkWidget* toplevel = gtk_widget_get_toplevel(omnibox_view);
   DCHECK(gtk_widget_is_toplevel(toplevel));
   ui::StackPopupWindow(window_, toplevel);
 }
 
 size_t OmniboxPopupViewGtk::LineFromY(int y) {
   size_t line = std::max(y - kBorderThickness, 0) / kHeightPerResult;
-  return std::min(line, model_->result().size() - 1);
+  return std::min(line + GetHiddenMatchCount(), GetResult().size() - 1);
 }
 
 void OmniboxPopupViewGtk::AcceptLine(size_t line,
                                      WindowOpenDisposition disposition) {
   // 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.
-  AutocompleteMatch match = model_->result().match_at(line);
+  AutocompleteMatch match = GetResult().match_at(line);
   omnibox_view_->OpenMatch(match, disposition, GURL(), line);
 }
 
 gfx::Image OmniboxPopupViewGtk::IconForMatch(
     const AutocompleteMatch& match,
     bool selected,
     bool is_selected_keyword) {
   const gfx::Image image = model_->GetIconIfExtensionMatch(match);
   if (!image.IsEmpty())
     return image;
@@ skipping 29 matching lines @@
     }
   }
 
   return theme_service_->GetImageNamed(icon);
 }
 
 void OmniboxPopupViewGtk::GetVisibleMatchForInput(
     size_t index,
     const AutocompleteMatch** match,
     bool* is_selected_keyword) {
-  const AutocompleteResult& result = model_->result();
+  const AutocompleteResult& result = GetResult();
 
   if (result.match_at(index).associated_keyword.get() &&
       model_->selected_line() == index &&
       model_->selected_line_state() == OmniboxPopupModel::KEYWORD) {
     *match = result.match_at(index).associated_keyword.get();
     *is_selected_keyword = true;
     return;
   }
 
   *match = &result.match_at(index);
   *is_selected_keyword = false;
 }
 
+gfx::Rect OmniboxPopupViewGtk::GetRectForLine(size_t line, int width) {
+  size_t visible_line = line - GetHiddenMatchCount();
+  return gfx::Rect(kBorderThickness,
+                   (visible_line * kHeightPerResult) + kBorderThickness,
+                   width - (kBorderThickness * 2),
+                   kHeightPerResult);
+}
+
+size_t OmniboxPopupViewGtk::GetHiddenMatchCount() {
+  return GetResult().ShouldHideTopMatch() ? 1 : 0;
+}
+
+const AutocompleteResult& OmniboxPopupViewGtk::GetResult() const {

[Evan Stade, 2013/08/15 01:05:12]

make the definition order match the declaration order

[Jered, 2013/08/15 16:08:49]

Done.

+  return model_->result();
+}
+
 gboolean OmniboxPopupViewGtk::HandleMotion(GtkWidget* widget,
                                            GdkEventMotion* event) {
   // TODO(deanm): Windows has a bunch of complicated logic here.
   size_t line = LineFromY(static_cast<int>(event->y));
   // There is both a hovered and selected line, hovered just means your mouse
   // is over it, but selected is what's showing in the location edit.
   model_->SetHoveredLine(line);
   // Select the line if the user has the left mouse button down.
   if (!ignore_mouse_drag_ && (event->state & GDK_BUTTON1_MASK))
     model_->SetSelectedLine(line, false, false);
@@ skipping 30 matching lines @@
     default:
       // Don't open the result.
       break;
   }
   return TRUE;
 }
 
 gboolean OmniboxPopupViewGtk::HandleExpose(GtkWidget* widget,
                                            GdkEventExpose* event) {
   bool ltr = !base::i18n::IsRTL();
-  const AutocompleteResult& result = model_->result();
+  const AutocompleteResult& result = GetResult();
 
   gfx::Rect window_rect = GetWindowRect(event->window);
   gfx::Rect damage_rect = gfx::Rect(event->area);
   // Handle when our window is super narrow.  A bunch of the calculations
   // below would go negative, and really we're not going to fit anything
   // useful in such a small window anyway.  Just don't paint anything.
   // This means we won't draw the border, but, yeah, whatever.
   // TODO(deanm): Make the code more robust and remove this check.
   if (window_rect.width() < (kIconAreaWidth * 3))
     return TRUE;
 
   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
   gdk_cairo_rectangle(cr, &event->area);
   cairo_clip(cr);
 
   // This assert is kinda ugly, but it would be more currently unneeded work
   // to support painting a border that isn't 1 pixel thick.  There is no point
   // in writing that code now, and explode if that day ever comes.
   COMPILE_ASSERT(kBorderThickness == 1, border_1px_implied);
   // Draw the 1px border around the entire window.
   gdk_cairo_set_source_color(cr, &border_color_);
   cairo_rectangle(cr, 0, 0, window_rect.width(), window_rect.height());
   cairo_stroke(cr);
 
   pango_layout_set_height(layout_, kHeightPerResult * PANGO_SCALE);
 
-  for (size_t i = 0; i < result.size(); ++i) {
+  for (size_t i = GetHiddenMatchCount(); i < result.size(); ++i) {
     gfx::Rect line_rect = GetRectForLine(i, window_rect.width());
     // Only repaint and layout damaged lines.
     if (!line_rect.Intersects(damage_rect))
       continue;
 
     const AutocompleteMatch* match = NULL;
     bool is_selected_keyword = false;
     GetVisibleMatchForInput(i, &match, &is_selected_keyword);
     bool is_selected = (model_->selected_line() == i);
     bool is_hovered = (model_->hovered_line() == i);
@@ skipping 90 matching lines @@
                               theme_service_->GetImageNamed(
                                   is_selected ? IDR_OMNIBOX_TTS_DARK :
                                   IDR_OMNIBOX_TTS),
                               icon_start_x, line_rect.y() + kIconTopPadding);
     }
   }
 
   cairo_destroy(cr);
   return TRUE;
 }