First stab at touch optimized omnibox auto-complete per sgabriel's mocks.

chrome/browser/ui/views/autocomplete/touch_autocomplete_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/autocomplete/touch_autocomplete_popup_contents_view.h"
 
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/views/view.h"
 
+namespace {
+
+SkColor GetDividerLineColor(bool top) {
+  bool initialized = false;
+  static SkColor top_color;
+  static SkColor bottom_color;
+  if (!initialized) {
+#if defined(OS_WIN)
+    top_color = color_utils::GetSysSkColor(COLOR_3DDKSHADOW);

[Peter Kasting, 2012/05/07 21:03:12]

Make sure that the colors you choose are guaranteed to look good with
COLOR_WINDOW as the background; I think the values you've chosen are probably
only guaranteed to look good with COLOR_3DFACE as the background.  In fact I may
have misled you by suggesting system colors at all because I bet there's nothing
that really means what you want.

Instead, you may need to do this by calling
LocationBarView::GetColor(ToolbarModel::NONE, LocationBarView::BACKGROUND) and
tinting the results.  Make sure to take into account what to do on full-white
and full-black backgrounds as well as whether you want the light-vs.-dark colors
you use to be swapped on light-vs.-dark backgrounds.

[Jói, 2012/05/10 18:33:07]

Done.

[Jói, 2012/05/10 18:33:07]

Done.

+    bottom_color = color_utils::GetSysSkColor(COLOR_3DLIGHT);
+#elif defined(USE_AURA)
+    const gfx::NativeTheme* theme = gfx::NativeTheme::instance();
+    top_color = theme->GetSystemColor(gfx::NativeTheme::kColorId_ThreeDShadow);
+    bottom_color = theme->GetSystemColor(
+        gfx::NativeTheme::kColorId_ThreeDLightShadow);
+#else
+    top_color = SkColorSetRGB(0xe3, 0xe3, 0xe3);
+    bottom_color = SkColorSetRGB(0xfe, 0xfe, 0xfe);
+#endif
+    initialized = true;
+  }
+}
+
+SkColor GetDividerLineBottomColor {
+}
+
+// Colors for a light-gray 3D-looking divider made up of two lines.

[Peter Kasting, 2012/05/07 21:03:12]

Nit: This can be removed

[Jói, 2012/05/10 18:33:07]

Done.

+const SkColor kDividerLineTopColor =
+    SkColorSetARGBMacro(0xff, 0xe3, 0xe3, 0xe3);
+const SkColor kDividerLineBottomColor =
+    SkColorSetARGBMacro(0xff, 0xfe, 0xfe, 0xfe);
+
+}  // namespace
+
 
 // TouchAutocompleteResultView ------------------------------------------------
 
 TouchAutocompleteResultView::TouchAutocompleteResultView(
     AutocompleteResultViewModel* model,
     int model_index,
     const gfx::Font& font,
     const gfx::Font& bold_font)
     : AutocompleteResultView(model, model_index, font, bold_font) {
+  set_edge_item_padding(9);
+  set_item_padding_(9);
+  set_minimum_text_vertical_padding(10);
 }
 
 TouchAutocompleteResultView::~TouchAutocompleteResultView() {
 }
 
 void TouchAutocompleteResultView::PaintMatch(gfx::Canvas* canvas,
                                              const AutocompleteMatch& match,
                                              int x) {
-  DrawString(canvas, match.contents, match.contents_class, false, x,
-             text_bounds().y());
+  int y = text_bounds().y();
 
   if (!match.description.empty()) {
     // We use our base class's GetTextHeight below because we need the height
     // of a single line of text.
-    DrawString(canvas, match.description, match.description_class, true, x,
-        text_bounds().y() + AutocompleteResultView::GetTextHeight());
+    DrawString(canvas, match.description, match.description_class, true, x, y);
+    y += AutocompleteResultView::GetTextHeight();
+  } else {
+    // When we have only one line of content (no description), we center the
+    // single line vertically on our two-lines-tall results box.
+    y += AutocompleteResultView::GetTextHeight() / 2;
   }
+
+  DrawString(canvas, match.contents, match.contents_class, false, x, y);
 }
 
 int TouchAutocompleteResultView::GetTextHeight() const {
-  // In the touch version of the autocomplete popup, the text is displayed in
-  // two lines: First line is the title of the suggestion and second is the
-  // description. Hence, the total text height is twice the height of one line.
   return AutocompleteResultView::GetTextHeight() * 2;
 }
 
+void TouchAutocompleteResultView::AdjustIconBounds(
+    const AutocompleteMatch& match, gfx::Rect* bounds) {
+  // We show the icon centered on the first line of content, so we

[Peter Kasting, 2012/05/07 21:03:12]

Nit: We show -> we want to show

+  // need to adjust the bounds when there are two lines.  The default
+  // layout in the base class is to center on the whole results view,
+  // which places th eicon correctly when there are two lines.

[Peter Kasting, 2012/05/07 21:03:12]

Nit: th eicon -> the icon; are two lines -> is one line

I confess, though, now that I understand how you're trying to lay things out, I
wonder if it will look weird.  This will result in the icons not being evenly
spaced from each other.  It seems like it'd be better to either always center
the icon within the entire view, or else always place it on the "first line",
and if there's only one line of text, place that on the "first line" as well
instead of centering it vertically.  Either of these will result in evenly
spaced icons and look better IMO.

+  if (!match.description.empty()) {
+    bounds->set_y(
+        (AutocompleteResultView::GetTextHeight() - bounds->height()) / 2 +
+        minimum_text_vertical_padding_);
+  }
+}
+
 
 // TouchAutocompletePopupContentsView -----------------------------------------
 
 TouchAutocompletePopupContentsView::TouchAutocompletePopupContentsView(
     const gfx::Font& font,
     OmniboxView* omnibox_view,
     AutocompleteEditModel* edit_model,
     views::View* location_bar)
     : AutocompletePopupContentsView(font, omnibox_view, edit_model,
                                     location_bar) {
 }
 
 TouchAutocompletePopupContentsView::~TouchAutocompletePopupContentsView() {
 }
 
 void TouchAutocompletePopupContentsView::UpdatePopupAppearance() {
   AutocompletePopupContentsView::UpdatePopupAppearance();
   Layout();
 }
 
-void TouchAutocompletePopupContentsView::LayoutChildren() {
-  std::vector<View*> visible_children(GetVisibleChildren());
-  gfx::Rect bounds(GetContentsBounds());
-  double child_width =
-      static_cast<double>(bounds.width()) / visible_children.size();
-  int x = bounds.x();
-  for (size_t i = 0; i < visible_children.size(); ++i) {
-    int next_x = bounds.x() + static_cast<int>(((i + 1) * child_width) + 0.5);
-    visible_children[i]->SetBounds(x, bounds.y(), next_x - x, bounds.height());
-    x = next_x;
-  }
-}
-
 void TouchAutocompletePopupContentsView::PaintResultViews(gfx::Canvas* canvas) {
   AutocompletePopupContentsView::PaintResultViews(canvas);
 
   // Draw divider lines.
   std::vector<View*> visible_children(GetVisibleChildren());
   if (visible_children.size() < 2)
     return;
-  SkColor color = AutocompleteResultView::GetColor(
-      AutocompleteResultView::NORMAL, AutocompleteResultView::DIMMED_TEXT);
   gfx::Rect bounds(GetContentsBounds());
   for (std::vector<View*>::const_iterator i(visible_children.begin() + 1);

[Peter Kasting, 2012/05/07 21:03:12]

Nit: I think it would be slightly better to iterate over all children, and draw
lines (conditionally) at the top and bottom of the current view instead of at
the (top - 1) and top of the current view.

While this means we'd need to add conditionals to check for being on the first
and last views, it would also make it more natural to say "don't paint either
line if we're hovered/selected".  Your current code paints the "top color" line
in all cases, which seems like a bug, and while it's fixable without reworking
the loop structure, this way seemed clearer to me.

        i != visible_children.end(); ++i) {
-    canvas->DrawLine(gfx::Point((*i)->x(), bounds.y()),
-                     gfx::Point((*i)->x(), bounds.bottom()), color);
+    TouchAutocompleteResultView* child =
+        static_cast<TouchAutocompleteResultView*>(*i);
+    canvas->DrawLine(
+        gfx::Point(bounds.x(), child->y() - 1),
+        gfx::Point(bounds.right(), child->y() - 1),
+        kDividerLineTopColor);
+    if (child->GetState() == AutocompleteResultView::NORMAL) {
+      canvas->DrawLine(
+          gfx::Point(bounds.x(), child->y()),
+          gfx::Point(bounds.right(), child->y()),
+          kDividerLineBottomColor);
+    }
   }
 }
 
-int TouchAutocompletePopupContentsView::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 = std::max(popup_height,
-                            child_at(i)->GetPreferredSize().height());
-  }
-  return popup_height;
-}
-
 AutocompleteResultView* TouchAutocompletePopupContentsView::CreateResultView(
     AutocompleteResultViewModel* model,
     int model_index,
     const gfx::Font& font,
     const gfx::Font& bold_font) {
   return new TouchAutocompleteResultView(model, model_index, font, bold_font);
 }
 
 std::vector<views::View*>
     TouchAutocompletePopupContentsView::GetVisibleChildren() {
   std::vector<View*> visible_children;
   for (int i = 0; i < child_count(); ++i) {
     View* v = child_at(i);
     if (child_at(i)->visible())
       visible_children.push_back(v);
   }
   return visible_children;
 }