Revert of Delete pre-MD code from OmniboxResultView

chrome/browser/ui/views/omnibox/omnibox_result_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.
 
 // For WinDDK ATL compatibility, these ATL headers must come first.
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>  // NOLINT
 #include <atlwin.h>  // NOLINT
 #endif
 
 #include "base/macros.h"
 #include "chrome/browser/ui/views/omnibox/omnibox_result_view.h"
 
 #include <limits.h>
 
 #include <algorithm>  // NOLINT
 
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/views/location_bar/background_with_1_px_border.h"
+#include "chrome/browser/ui/views/location_bar/icon_label_bubble_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/browser/ui/views/omnibox/omnibox_popup_contents_view.h"
 #include "chrome/grit/generated_resources.h"
+#include "chrome/grit/theme_resources.h"
 #include "components/grit/components_scaled_resources.h"
 #include "components/omnibox/browser/omnibox_popup_model.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/render_text.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/gfx/vector_icons_public.h"
 #include "ui/native_theme/native_theme.h"
 
 using ui::NativeTheme;
 
 namespace {
 
 // A mapping from OmniboxResultView's ResultViewState/ColorKind types to
 // NativeTheme colors.
@@ skipping 125 matching lines @@
 
  private:
   int center_;
   int right_;
 
   DISALLOW_COPY_AND_ASSIGN(MirroringContext);
 };
 
 OmniboxResultView::OmniboxResultView(OmniboxPopupContentsView* model,
                                      int model_index,
+                                     LocationBarView* location_bar_view,
                                      const gfx::FontList& font_list)
     : model_(model),
       model_index_(model_index),
+      location_bar_view_(location_bar_view),
       font_list_(font_list),
       font_height_(std::max(
           font_list.GetHeight(),
           font_list.DeriveWithWeight(gfx::Font::Weight::BOLD).GetHeight())),
       mirroring_context_(new MirroringContext()),
       keyword_icon_(new views::ImageView()),
       animation_(new gfx::SlideAnimation(this)) {
   CHECK_GE(model_index, 0);
+  if (default_icon_size_ == 0)
+    default_icon_size_ = LocationBarView::kIconWidth;
   keyword_icon_->set_owned_by_client();
   keyword_icon_->EnableCanvasFlippingForRTLUI(true);
-  keyword_icon_->SetImage(
-      GetVectorIcon(gfx::VectorIconId::OMNIBOX_KEYWORD_SEARCH));
+  keyword_icon_->SetImage(GetKeywordIcon());
   keyword_icon_->SizeToPreferredSize();
 }
 
 OmniboxResultView::~OmniboxResultView() {
 }
 
 SkColor OmniboxResultView::GetColor(
     ResultViewState state,
     ColorKind kind) const {
   for (size_t i = 0; i < arraysize(kTranslationTable); ++i) {
@@ skipping 27 matching lines @@
 }
 
 void OmniboxResultView::ShowKeyword(bool show_keyword) {
   if (show_keyword)
     animation_->Show();
   else
     animation_->Hide();
 }
 
 void OmniboxResultView::Invalidate() {
-  const ResultViewState state = GetState();
-  if (state == NORMAL) {
-    set_background(nullptr);
-  } else {
-    const SkColor bg_color = GetColor(state, BACKGROUND);
-    set_background(new BackgroundWith1PxBorder(bg_color, bg_color));
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    const ResultViewState state = GetState();
+    if (state == NORMAL) {
+      set_background(nullptr);
+    } else {
+      const SkColor bg_color = GetColor(state, BACKGROUND);
+      set_background(new BackgroundWith1PxBorder(bg_color, bg_color));
+    }
   }
 
+  keyword_icon_->SetImage(GetKeywordIcon());
+
   // While the text in the RenderTexts may not have changed, the styling
   // (color/bold) may need to change. So we reset them to cause them to be
   // recomputed in OnPaint().
   contents_rendertext_.reset();
   description_rendertext_.reset();
   separator_rendertext_.reset();
   keyword_contents_rendertext_.reset();
   keyword_description_rendertext_.reset();
 }
 
@@ skipping 218 matching lines @@
         text_length;
     const gfx::Range current_range(text_start, text_end);
 
     // Calculate style-related data.
     if (classifications[i].style & ACMatchClassification::MATCH)
       render_text->ApplyWeight(gfx::Font::Weight::BOLD, current_range);
 
     ColorKind color_kind = TEXT;
     if (classifications[i].style & ACMatchClassification::URL) {
       color_kind = URL;
-      // Consider logical string for domain "ABC.com/hello" where ABC are
+      // Consider logical string for domain "ABC.comי/hello" where ABC are
       // Hebrew (RTL) characters. This string should ideally show as
       // "CBA.com/hello". If we do not force LTR on URL, it will appear as
       // "com/hello.CBA".
       // With IDN and RTL TLDs, it might be okay to allow RTL rendering of URLs,
       // but it still has some pitfalls like :
       // ABC.COM/abc-pqr/xyz/FGH will appear as HGF/abc-pqr/xyz/MOC.CBA which
       // really confuses the path hierarchy of the URL.
       // Also, if the URL supports https, the appearance will change into LTR
       // directionality.
       // In conclusion, LTR rendering of URL is probably the safest bet.
@@ skipping 38 matching lines @@
   const gfx::Range& glyph_bounds =
       input_render_text->GetGlyphBounds(contents_start_index);
   const int start_padding = is_match_contents_rtl ?
       std::max(glyph_bounds.start(), glyph_bounds.end()) :
       std::min(glyph_bounds.start(), glyph_bounds.end());
 
   return is_ui_rtl ?
       (input_render_text->GetContentWidth() - start_padding) : start_padding;
 }
 
+// static
+int OmniboxResultView::default_icon_size_ = 0;
+
 const char* OmniboxResultView::GetClassName() const {
   return "OmniboxResultView";
 }
 
 gfx::ImageSkia OmniboxResultView::GetIcon() const {
   const gfx::Image image = model_->GetIconIfExtensionMatch(model_index_);
   if (!image.IsEmpty())
     return image.AsImageSkia();
 
-  return GetVectorIcon(
-      model_->IsStarredMatch(match_)
-          ? gfx::VectorIconId::OMNIBOX_STAR
-          : AutocompleteMatch::TypeToVectorIcon(match_.type));
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    return GetVectorIcon(
+        model_->IsStarredMatch(match_)
+            ? gfx::VectorIconId::OMNIBOX_STAR
+            : AutocompleteMatch::TypeToVectorIcon(match_.type));
+  }
+
+  int icon = model_->IsStarredMatch(match_) ?
+      IDR_OMNIBOX_STAR : AutocompleteMatch::TypeToIcon(match_.type);
+  if (GetState() == SELECTED) {
+    switch (icon) {
+      case IDR_OMNIBOX_CALCULATOR:
+        icon = IDR_OMNIBOX_CALCULATOR_SELECTED;
+        break;
+      case IDR_OMNIBOX_EXTENSION_APP:
+        icon = IDR_OMNIBOX_EXTENSION_APP_SELECTED;
+        break;
+      case IDR_OMNIBOX_HTTP:
+        icon = IDR_OMNIBOX_HTTP_SELECTED;
+        break;
+      case IDR_OMNIBOX_SEARCH:
+        icon = IDR_OMNIBOX_SEARCH_SELECTED;
+        break;
+      case IDR_OMNIBOX_STAR:
+        icon = IDR_OMNIBOX_STAR_SELECTED;
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+  return *location_bar_view_->GetThemeProvider()->GetImageSkiaNamed(icon);
+}
+
+gfx::ImageSkia OmniboxResultView::GetKeywordIcon() const {
+  if (ui::MaterialDesignController::IsModeMaterial())
+    return GetVectorIcon(gfx::VectorIconId::OMNIBOX_KEYWORD_SEARCH);
+
+  // NOTE: If we ever begin returning icons of varying size, then callers need
+  // to ensure that |keyword_icon_| is resized each time its image is reset.
+  int icon = IDR_OMNIBOX_TTS;
+  if (GetState() == SELECTED)
+    icon = IDR_OMNIBOX_TTS_SELECTED;
+
+  return *location_bar_view_->GetThemeProvider()->GetImageSkiaNamed(icon);
 }
 
 gfx::ImageSkia OmniboxResultView::GetVectorIcon(
     gfx::VectorIconId icon_id) const {
   // For selected rows, paint the icon the same color as the text.
   SkColor color = GetColor(GetState(), TEXT);
   if (GetState() != SELECTED)
     color = color_utils::DeriveDefaultIconColor(color);
   return gfx::CreateVectorIcon(icon_id, 16, color);
 }
 
 bool OmniboxResultView::ShowOnlyKeywordMatch() const {
   return match_.associated_keyword &&
       (keyword_icon_->x() <= icon_bounds_.right());
 }
 
 void OmniboxResultView::InitContentsRenderTextIfNecessary() const {
   if (!contents_rendertext_) {
     contents_rendertext_.reset(
         CreateClassifiedRenderText(
             match_.contents, match_.contents_class, false).release());
   }
 }
 
 void OmniboxResultView::Layout() {
   int horizontal_padding =
       GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING);
-  // The horizontal bounds we're given are the outside bounds, so we can match
-  // the omnibox border outline shape exactly in OnPaint().  We have to inset
-  // here to keep the icons lined up.
-  const int start_x =
-      GetLayoutConstant(LOCATION_BAR_BORDER_THICKNESS) + horizontal_padding;
-  const int end_x = width() - start_x;
+  // In non-material, the horizontal bounds we're given are indented inside the
+  // omnibox border.  In material, we're given the outside bounds, so we can
+  // match the omnibox border outline shape exactly in OnPaint().  So we have to
+  // inset here to keep the icons lined up.
+  const int border_padding = ui::MaterialDesignController::IsModeMaterial() ?
+    GetLayoutConstant(LOCATION_BAR_BORDER_THICKNESS) : 0;
+  const int start_x = border_padding + horizontal_padding;
+  const int end_x = width() - border_padding - horizontal_padding;
 
   const gfx::ImageSkia icon = GetIcon();
-  icon_bounds_.SetRect(start_x, (GetContentLineHeight() - icon.height()) / 2,
+  // Pre-MD, normal icons are 19 px wide, while extension icons are 16 px wide.
+  // The code in IconLabelBubbleView::Layout() positions these icons in the
+  // omnibox using ICON_LABEL_VIEW_TRAILING_PADDING, so we use that here as well
+  // so the icons will line up.
+  //
+  // Technically we don't need the IsModeMaterial() check here, but it will make
+  // it easier to see that all this code is dead once we switch to MD.
+  int icon_x = start_x;
+  if (!ui::MaterialDesignController::IsModeMaterial() &&
+      (icon.width() != default_icon_size_))
+    icon_x += IconLabelBubbleView::kTrailingPaddingPreMd;
+  icon_bounds_.SetRect(icon_x, (GetContentLineHeight() - icon.height()) / 2,
                        icon.width(), icon.height());
 
-  const int text_x = start_x + LocationBarView::kIconWidth + horizontal_padding;
+  const int text_x = start_x + default_icon_size_ + horizontal_padding;
   int text_width = end_x - text_x;
 
   if (match_.associated_keyword.get()) {
     const int max_kw_x = end_x - keyword_icon_->width();
     const int kw_x = animation_->CurrentValueBetween(max_kw_x, start_x);
     const int kw_text_x = kw_x + keyword_icon_->width() + horizontal_padding;
 
     text_width = kw_x - text_x - horizontal_padding;
     keyword_text_bounds_.SetRect(
         kw_text_x, 0, std::max(end_x - kw_text_x, 0), height());
     keyword_icon_->SetPosition(
         gfx::Point(kw_x, (height() - keyword_icon_->height()) / 2));
   }
 
   text_bounds_.SetRect(text_x, 0, std::max(text_width, 0), height());
 }
 
 void OmniboxResultView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   animation_->SetSlideDuration(width() / 4);
 }
 
 void OmniboxResultView::OnPaint(gfx::Canvas* canvas) {
-  View::OnPaint(canvas);
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    View::OnPaint(canvas);
+  } else {
+    const ResultViewState state = GetState();
+    if (state != NORMAL)
+      canvas->DrawColor(GetColor(state, BACKGROUND));
+  }
 
   // NOTE: While animating the keyword match, both matches may be visible.
 
   if (!ShowOnlyKeywordMatch()) {
     canvas->DrawImageInt(GetIcon(), GetMirroredXForRect(icon_bounds_),
                          icon_bounds_.y());
     int x = GetMirroredXForRect(text_bounds_);
     mirroring_context_->Initialize(x, text_bounds_.width());
     InitContentsRenderTextIfNecessary();
 
@@ skipping 42 matching lines @@
 int OmniboxResultView::GetAnswerLineHeight() const {
   // ANSWER_TEXT_LARGE is the largest font used and so defines the boundary that
   // all the other answer styles fit within.
   return ui::ResourceBundle::GetSharedInstance()
       .GetFontList(GetTextStyle(SuggestionAnswer::ANSWER_TEXT_LARGE).font)
       .GetHeight();
 }
 
 int OmniboxResultView::GetContentLineHeight() const {
   return std::max(
-      LocationBarView::kIconWidth +
-          GetLayoutInsets(OMNIBOX_DROPDOWN_ICON).height(),
+      default_icon_size_ + GetLayoutInsets(OMNIBOX_DROPDOWN_ICON).height(),
       GetTextHeight() + GetLayoutInsets(OMNIBOX_DROPDOWN_TEXT).height());
 }
 
 std::unique_ptr<gfx::RenderText> OmniboxResultView::CreateAnswerLine(
     const SuggestionAnswer::ImageLine& line,
     gfx::FontList font_list) const {
   std::unique_ptr<gfx::RenderText> destination =
       CreateRenderText(base::string16());
   destination->SetFontList(font_list);
 
@@ skipping 62 matching lines @@
   destination->AppendText(text);
   const TextStyle& text_style = GetTextStyle(text_type);
   // TODO(dschuyler): follow up on the problem of different font sizes within
   // one RenderText.  Maybe with destination->SetFontList(...).
   destination->ApplyWeight(
       is_bold ? gfx::Font::Weight::BOLD : gfx::Font::Weight::NORMAL, range);
   destination->ApplyColor(
       GetNativeTheme()->GetSystemColor(text_style.colors[GetState()]), range);
   destination->ApplyBaselineStyle(text_style.baseline, range);
 }