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 {
+
+// Colors for a light-gray 3D-looking divider made up of two lines.

[Peter Kasting, 2012/05/04 23:33:31]

It's not safe to use hardcoded colors because everything else in the omnibox
uses shades of system colors.

You can try to adjust these based on the background color but it's going to be
tricky to make this look right.  Perhaps you want to use some of the predefined
system colors for 3D objects?

Nit: Define these in the function that uses them and use SkColorSetRGB().

[Jói, 2012/05/04 23:52:19]

Good point, will look into using the system colors.

[Jói, 2012/05/07 16:26:18]

I've switched to using system colors, am waiting to hear from sgabriel@ on which
colors to use on Windows, and which hard-coded values to use on Aura.

+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) {
+  edge_item_padding_ *= 3;
+  item_padding_ *= 3;
+  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());
+  bool description = !match.description.empty();
+  int y = text_bounds().y();
 
-  if (!match.description.empty()) {
+  // When we have only one line of content (no description), we center the
+  // single line vertically on our two-lines-tall results box.
+  if (!description)

[Peter Kasting, 2012/05/04 23:33:31]

Nit: if (match.description.empty()) { ... } else { ... }

This avoids the temp and shortens this stuff a bit

[Jói, 2012/05/07 16:26:18]

Done.

+    y += AutocompleteResultView::GetTextHeight() / 2;
+
+  if (description) {
     // 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();
   }
+
+  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
+  // need to adjust the bounds when there are two lines.

[Peter Kasting, 2012/05/04 23:33:31]

Don't we need to do this all the time, not just when there's a description? 
Otherwise won't the icon paint in the top half of the box when we have a single
centered line?

[Jói, 2012/05/04 23:52:19]

The default case is that it's centered on the whole results item, i.e. centered
on GetContentBounds().

[Jói, 2012/05/07 16:26:18]

Added to the comment to explain why we don't need to do anything in the two-line
case.

+  if (!match.description.empty()) {
+    bounds->set_y((AutocompleteResultView::GetTextHeight() - bounds->height()) /
+                  2 + minimum_text_vertical_padding_);

[Peter Kasting, 2012/05/04 23:33:31]

Nit: The linebreak makes it look as if you're dividing by "2 + x" rather than
dividing by 2, then adding.  Break/indent differently?

[Jói, 2012/05/07 16:26:18]

Done.

+  }
+}
+
 
 // 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);
        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;
 }