views: Move autocomplete files into omnibox directory.

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 "chrome/browser/ui/views/autocomplete/autocomplete_result_view.h"
+#include "chrome/browser/ui/views/omnibox/omnibox_result_view.h"
 
 #include <algorithm>  // NOLINT
 
 #include "base/i18n/bidi_line_iterator.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_model.h"
-#include "chrome/browser/ui/views/autocomplete/autocomplete_result_view_model.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
+#include "chrome/browser/ui/views/omnibox/omnibox_result_view_model.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/native_theme/native_theme.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 
 namespace {
 
 const char16 kEllipsis[] = { 0x2026, 0x0 };
 
 // The minimum distance between the top and bottom of the {icon|text} and the
 // top or bottom of the row.
 const int kMinimumIconVerticalPadding = 2;
 const int kMinimumTextVerticalPadding = 3;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompleteResultView, public:
+// OmniboxResultView, public:
 
 // Precalculated data used to draw the portion of a match classification that
 // fits entirely within one run.
-struct AutocompleteResultView::ClassificationData {
+struct OmniboxResultView::ClassificationData {
   string16 text;
   const gfx::Font* font;
   SkColor color;
   gfx::Size pixel_size;
 };
 
 // Precalculated data used to draw a complete visual run within the match.
 // This will include all or part of at leasdt one, and possibly several,
 // classifications.
-struct AutocompleteResultView::RunData {
+struct OmniboxResultView::RunData {
   size_t run_start;  // Offset within the match text where this run begins.
   int visual_order;  // Where this run occurs in visual order.  The earliest
   // run drawn is run 0.
   bool is_rtl;
   int pixel_width;
   Classifications classifications;  // Classification pieces within this run,
                                     // in logical order.
 };
 
 // This class is a utility class for calculations affected by whether the result
 // view is horizontally mirrored.  The drawing functions can be written as if
 // all drawing occurs left-to-right, and then use this class to get the actual
 // coordinates to begin drawing onscreen.
-class AutocompleteResultView::MirroringContext {
+class OmniboxResultView::MirroringContext {
  public:
   MirroringContext() : center_(0), right_(0) {}
 
   // Tells the mirroring context to use the provided range as the physical
   // bounds of the drawing region.  When coordinate mirroring is needed, the
   // mirror point will be the center of this range.
   void Initialize(int x, int width) {
     center_ = x + width / 2;
     right_ = x + width;
   }
@@ skipping 11 matching lines @@
     return right_ - x;
   }
 
  private:
   int center_;
   int right_;
 
   DISALLOW_COPY_AND_ASSIGN(MirroringContext);
 };
 
-AutocompleteResultView::AutocompleteResultView(
-    AutocompleteResultViewModel* model,
+OmniboxResultView::OmniboxResultView(
+    OmniboxResultViewModel* model,
     int model_index,
     const gfx::Font& font,
     const gfx::Font& bold_font)
     : edge_item_padding_(LocationBarView::GetItemPadding()),
       item_padding_(LocationBarView::GetItemPadding()),
       minimum_text_vertical_padding_(kMinimumTextVerticalPadding),
       model_(model),
       model_index_(model_index),
       normal_font_(font),
       bold_font_(bold_font),
       ellipsis_width_(font.GetStringWidth(string16(kEllipsis))),
       mirroring_context_(new MirroringContext()),
       keyword_icon_(new views::ImageView()),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           animation_(new ui::SlideAnimation(this))) {
   CHECK_GE(model_index, 0);
   if (default_icon_size_ == 0) {
     default_icon_size_ =
         ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         AutocompleteMatch::TypeToIcon(AutocompleteMatch::URL_WHAT_YOU_TYPED))->
         width();
   }
   keyword_icon_->set_owned_by_client();
   keyword_icon_->EnableCanvasFlippingForRTLUI(true);
   keyword_icon_->SetImage(GetKeywordIcon());
   keyword_icon_->SizeToPreferredSize();
 }
 
-AutocompleteResultView::~AutocompleteResultView() {
+OmniboxResultView::~OmniboxResultView() {
 }
 
 // static
-SkColor AutocompleteResultView::GetColor(ResultViewState state,
-                                         ColorKind kind) {
+SkColor OmniboxResultView::GetColor(ResultViewState state, ColorKind kind) {
   static bool initialized = false;
   static SkColor colors[NUM_STATES][NUM_KINDS];
   if (!initialized) {
 #if defined(OS_WIN)
     colors[NORMAL][BACKGROUND] = color_utils::GetSysSkColor(COLOR_WINDOW);
     colors[SELECTED][BACKGROUND] = color_utils::GetSysSkColor(COLOR_HIGHLIGHT);
     colors[NORMAL][TEXT] = color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
     colors[SELECTED][TEXT] = color_utils::GetSysSkColor(COLOR_HIGHLIGHTTEXT);
 #elif defined(USE_AURA)
     const ui::NativeTheme* theme = ui::NativeTheme::instance();
@@ skipping 33 matching lines @@
       // alpha.)
       colors[i][DIVIDER] =
           color_utils::AlphaBlend(colors[i][TEXT], colors[i][BACKGROUND], 0x34);
     }
     initialized = true;
   }
 
   return colors[state][kind];
 }
 
-void AutocompleteResultView::SetMatch(const AutocompleteMatch& match) {
+void OmniboxResultView::SetMatch(const AutocompleteMatch& match) {
   match_ = match;
   animation_->Reset();
 
   if (match.associated_keyword.get()) {
     keyword_icon_->SetImage(GetKeywordIcon());
 
     if (!keyword_icon_->parent())
       AddChildView(keyword_icon_.get());
   } else if (keyword_icon_->parent()) {
     RemoveChildView(keyword_icon_.get());
   }
 
   Layout();
 }
 
-void AutocompleteResultView::ShowKeyword(bool show_keyword) {
+void OmniboxResultView::ShowKeyword(bool show_keyword) {
   if (show_keyword)
     animation_->Show();
   else
     animation_->Hide();
 }
 
-void AutocompleteResultView::Invalidate() {
+void OmniboxResultView::Invalidate() {
   keyword_icon_->SetImage(GetKeywordIcon());
   SchedulePaint();
 }
 
-gfx::Size AutocompleteResultView::GetPreferredSize() {
+gfx::Size OmniboxResultView::GetPreferredSize() {
   return gfx::Size(0, std::max(
       default_icon_size_ + (kMinimumIconVerticalPadding * 2),
       GetTextHeight() + (minimum_text_vertical_padding_ * 2)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompleteResultView, protected:
+// OmniboxResultView, protected:
 
-AutocompleteResultView::ResultViewState
-    AutocompleteResultView::GetState() const {
+OmniboxResultView::ResultViewState OmniboxResultView::GetState() const {
   if (model_->IsSelectedIndex(model_index_))
     return SELECTED;
   return model_->IsHoveredIndex(model_index_) ? HOVERED : NORMAL;
 }
 
-void AutocompleteResultView::PaintMatch(gfx::Canvas* canvas,
-                                        const AutocompleteMatch& match,
-                                        int x) {
+void OmniboxResultView::PaintMatch(gfx::Canvas* canvas,
+                                   const AutocompleteMatch& match,
+                                   int x) {
   x = DrawString(canvas, match.contents, match.contents_class, false, x,
                  text_bounds_.y());
 
   // Paint the description.
   // TODO(pkasting): Because we paint in multiple separate pieces, we can wind
   // up with no space even for an ellipsis for one or both of these pieces.
   // Instead, we should paint the entire match as a single long string.  This
   // would also let us use a more properly-localizable string than we get with
   // just the IDS_AUTOCOMPLETE_MATCH_DESCRIPTION_SEPARATOR.
   if (!match.description.empty()) {
     string16 separator =
         l10n_util::GetStringUTF16(IDS_AUTOCOMPLETE_MATCH_DESCRIPTION_SEPARATOR);
     ACMatchClassifications classifications;
     classifications.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     x = DrawString(canvas, separator, classifications, true, x,
                    text_bounds_.y());
 
     DrawString(canvas, match.description, match.description_class, true, x,
                text_bounds_.y());
   }
 }
 
-int AutocompleteResultView::GetTextHeight() const {
+int OmniboxResultView::GetTextHeight() const {
   return std::max(normal_font_.GetHeight(), bold_font_.GetHeight());
 }
 
 // static
-bool AutocompleteResultView::SortRunsLogically(const RunData& lhs,
-                                               const RunData& rhs) {
+bool OmniboxResultView::SortRunsLogically(const RunData& lhs,
+                                          const RunData& rhs) {
   return lhs.run_start < rhs.run_start;
 }
 
 // static
-bool AutocompleteResultView::SortRunsVisually(const RunData& lhs,
-                                              const RunData& rhs) {
+bool OmniboxResultView::SortRunsVisually(const RunData& lhs,
+                                         const RunData& rhs) {
   return lhs.visual_order < rhs.visual_order;
 }
 
 // static
-int AutocompleteResultView::default_icon_size_ = 0;
+int OmniboxResultView::default_icon_size_ = 0;
 
-const SkBitmap* AutocompleteResultView::GetIcon() const {
+const SkBitmap* OmniboxResultView::GetIcon() const {
   const SkBitmap* bitmap = model_->GetIconIfExtensionMatch(model_index_);
   if (bitmap)
     return bitmap;
 
   int icon = match_.starred ?
       IDR_OMNIBOX_STAR : AutocompleteMatch::TypeToIcon(match_.type);
   if (GetState() == SELECTED) {
     switch (icon) {
       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 ui::ResourceBundle::GetSharedInstance().GetBitmapNamed(icon);
 }
 
-const gfx::ImageSkia* AutocompleteResultView::GetKeywordIcon() const {
+const gfx::ImageSkia* OmniboxResultView::GetKeywordIcon() const {
   // 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.
   return ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
       (GetState() == SELECTED) ? IDR_OMNIBOX_TTS_SELECTED : IDR_OMNIBOX_TTS);
 }
 
-int AutocompleteResultView::DrawString(
+int OmniboxResultView::DrawString(
     gfx::Canvas* canvas,
     const string16& text,
     const ACMatchClassifications& classifications,
     bool force_dim,
     int x,
     int y) {
   if (text.empty())
     return x;
 
   // Check whether or not this text is a URL.  URLs are always displayed LTR
@@ skipping 147 matching lines @@
       canvas->DrawStringInt(j->text, *j->font, j->color, left, y,
                             j->pixel_size.width(), j->pixel_size.height(),
                             flags);
       x += j->pixel_size.width();
     }
   }
 
   return x;
 }
 
-void AutocompleteResultView::Elide(Runs* runs, int remaining_width) const {
+void OmniboxResultView::Elide(Runs* runs, int remaining_width) const {
   // The complexity of this function is due to edge cases like the following:
   // We have 100 px of available space, an initial classification that takes 86
   // px, and a font that has a 15 px wide ellipsis character.  Now if the first
   // classification is followed by several very narrow classifications (e.g. 3
   // px wide each), we don't know whether we need to elide or not at the time we
   // see the first classification -- it depends on how many subsequent
   // classifications follow, and some of those may be in the next run (or
   // several runs!).  This is why instead we let our caller move forward until
   // we know we definitely need to elide, and then in this function we move
   // backward again until we find a string that we can successfully do the
@@ skipping 67 matching lines @@
       //     ellipsis we'll append to it, or
       //   * It is also bold, in which case we don't want to fall back
       //     to a normal ellipsis anyway (see comment above).
     }
   }
 
   // We couldn't draw anything.
   runs->clear();
 }
 
-void AutocompleteResultView::Layout() {
+void OmniboxResultView::Layout() {
   const SkBitmap* icon = GetIcon();
 
   icon_bounds_.SetRect(edge_item_padding_ +
       ((icon->width() == default_icon_size_) ?
           0 : LocationBarView::kIconInternalPadding),
       (height() - icon->height()) / 2, icon->width(), icon->height());
 
   int text_x = edge_item_padding_ + default_icon_size_ + item_padding_;
   int text_height = GetTextHeight();
   int text_width;
@@ skipping 12 matching lines @@
     keyword_icon_->SetPosition(gfx::Point(kw_x,
         (height() - keyword_icon_->height()) / 2));
   } else {
     text_width = width() - text_x - edge_item_padding_;
   }
 
   text_bounds_.SetRect(text_x, std::max(0, (height() - text_height) / 2),
       std::max(text_width, 0), text_height);
 }
 
-void AutocompleteResultView::OnBoundsChanged(
-    const gfx::Rect& previous_bounds) {
+void OmniboxResultView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   animation_->SetSlideDuration(width() / 4);
 }
 
-void AutocompleteResultView::OnPaint(gfx::Canvas* canvas) {
+void OmniboxResultView::OnPaint(gfx::Canvas* canvas) {
   const ResultViewState state = GetState();
   if (state != NORMAL)
     canvas->DrawColor(GetColor(state, BACKGROUND));
 
   if (!match_.associated_keyword.get() ||
       keyword_icon_->x() > icon_bounds_.right()) {
     // Paint the icon.
     canvas->DrawImageInt(*GetIcon(), GetMirroredXForRect(icon_bounds_),
                          icon_bounds_.y());
 
     // Paint the text.
     int x = GetMirroredXForRect(text_bounds_);
     mirroring_context_->Initialize(x, text_bounds_.width());
     PaintMatch(canvas, match_, x);
   }
 
   if (match_.associated_keyword.get()) {
     // Paint the keyword text.
     int x = GetMirroredXForRect(keyword_text_bounds_);
     mirroring_context_->Initialize(x, keyword_text_bounds_.width());
     PaintMatch(canvas, *match_.associated_keyword.get(), x);
   }
 }
 
-void AutocompleteResultView::AnimationProgressed(
-    const ui::Animation* animation) {
+void OmniboxResultView::AnimationProgressed(const ui::Animation* animation) {
   Layout();
   SchedulePaint();
 }