Remove wstring from autocomplete.

chrome/browser/ui/views/autocomplete/autocomplete_popup_contents_view.cc

 // Copyright (c) 2011 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/autocomplete_popup_contents_view.h"
 
 #include "base/compiler_specific.h"
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/rtl.h"
 #include "base/utf_string_conversions.h"
@@ skipping 90 matching lines @@
           color_utils::AlphaBlend(colors[i][TEXT], colors[i][BACKGROUND], 128);
       colors[i][URL] = color_utils::GetReadableColor(SkColorSetRGB(0, 128, 0),
                                                      colors[i][BACKGROUND]);
     }
     initialized = true;
   }
 
   return colors[state][kind];
 }
 
-const wchar_t kEllipsis[] = L"\x2026";
+const char16 kEllipsis[] = { 0x2026 };
 
 const SkAlpha kGlassPopupAlpha = 240;
 const SkAlpha kOpaquePopupAlpha = 255;
 // The minimum distance between the top and bottom of the icon and the top or
 // bottom of the row. "Minimum" is used because the vertical padding may be
 // larger, depending on the size of the text.
 const int kIconVerticalPadding = 2;
 // The minimum distance between the top and bottom of the text and the top or
 // bottom of the row. See comment about the use of "minimum" for
 // kIconVerticalPadding.
@@ skipping 164 matching lines @@
   virtual gfx::Size GetPreferredSize();
 
   // Returns the preferred height for a single row.
   static int GetPreferredHeight(const gfx::Font& font,
                                 const gfx::Font& bold_font);
 
  private:
   // Precalculated data used to draw the portion of a match classification that
   // fits entirely within one run.
   struct ClassificationData {
-    std::wstring text;
+    string16 text;
     const gfx::Font* font;
     SkColor color;
     int pixel_width;
   };
   typedef std::vector<ClassificationData> Classifications;
 
   // 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 RunData {
@@ skipping 13 matching lines @@
 
   ResultViewState GetState() const;
 
   const SkBitmap* GetIcon() const;
 
   // Draws the specified |text| into the canvas, using highlighting provided by
   // |classifications|. If |force_dim| is true, ACMatchClassification::DIM is
   // added to all of the classifications. Returns the x position to the right
   // of the string.
   int DrawString(gfx::Canvas* canvas,
-                 const std::wstring& text,
+                 const string16& text,
                  const ACMatchClassifications& classifications,
                  bool force_dim,
                  int x,
                  int y);
 
   // Elides |runs| to fit in |remaining_width|.  The runs in |runs| should be in
   // logical order.
   //
   // When we need to elide a run, the ellipsis will be placed at the end of that
   // run.  This means that if we elide a run whose visual direction is opposite
@@ skipping 74 matching lines @@
 
 AutocompleteResultView::AutocompleteResultView(
     AutocompleteResultViewModel* model,
     int model_index,
     const gfx::Font& font,
     const gfx::Font& bold_font)
     : model_(model),
       model_index_(model_index),
       normal_font_(font),
       bold_font_(bold_font),
-      ellipsis_width_(font.GetStringWidth(WideToUTF16(kEllipsis))),
+      ellipsis_width_(font.GetStringWidth(string16(kEllipsis))),
       mirroring_context_(new MirroringContext()),
       match_(NULL, 0, false, AutocompleteMatch::URL_WHAT_YOU_TYPED) {
   CHECK(model_index >= 0);
   if (icon_size_ == 0) {
     icon_size_ = ResourceBundle::GetSharedInstance().GetBitmapNamed(
         AutocompleteMatch::TypeToIcon(AutocompleteMatch::URL_WHAT_YOU_TYPED))->
         width();
   }
 }
 
@@ skipping 15 matching lines @@
   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()) {
-    std::wstring separator = UTF16ToWide(l10n_util::GetStringUTF16(
-        IDS_AUTOCOMPLETE_MATCH_DESCRIPTION_SEPARATOR));
+    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());
   }
 }
@@ skipping 54 matching lines @@
       case IDR_OMNIBOX_SEARCH:  icon = IDR_OMNIBOX_SEARCH_SELECTED; break;
       case IDR_OMNIBOX_STAR:    icon = IDR_OMNIBOX_STAR_SELECTED; break;
       default:             NOTREACHED(); break;
     }
   }
   return ResourceBundle::GetSharedInstance().GetBitmapNamed(icon);
 }
 
 int AutocompleteResultView::DrawString(
     gfx::Canvas* canvas,
-    const std::wstring& text,
+    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
   // regardless of locale.
   bool is_url = true;
   for (ACMatchClassifications::const_iterator i(classifications.begin());
        i != classifications.end(); ++i) {
     if (!(i->style & ACMatchClassification::URL)) {
       is_url = false;
       break;
     }
   }
 
   // Split the text into visual runs.  We do this first so that we don't need to
   // worry about whether our eliding might change the visual display in
   // unintended ways, e.g. by removing directional markings or by adding an
   // ellipsis that's not enclosed in appropriate markings.
   base::i18n::BiDiLineIterator bidi_line;
-  if (!bidi_line.Open(WideToUTF16Hack(text), base::i18n::IsRTL(), is_url))
+  if (!bidi_line.Open(text, base::i18n::IsRTL(), is_url))
     return x;
   const int num_runs = bidi_line.CountRuns();
   Runs runs;
   for (int run = 0; run < num_runs; ++run) {
     int run_start_int = 0, run_length_int = 0;
     // The index we pass to GetVisualRun corresponds to the position of the run
     // in the displayed text. For example, the string "Google in HEBREW" (where
     // HEBREW is text in the Hebrew language) has two runs: "Google in " which
     // is an LTR run, and "HEBREW" which is an RTL run. In an LTR context, the
     // run "Google in " has the index 0 (since it is the leftmost run
@@ skipping 34 matching lines @@
       const bool use_bold_font = !!(style & ACMatchClassification::MATCH);
       current_data->font = &(use_bold_font ? bold_font_ : normal_font_);
       const ResultViewState state = GetState();
       if (style & ACMatchClassification::URL)
         current_data->color = GetColor(state, URL);
       else if (style & ACMatchClassification::DIM)
         current_data->color = GetColor(state, DIMMED_TEXT);
       else
         current_data->color = GetColor(state, force_dim ? DIMMED_TEXT : TEXT);
       current_data->pixel_width =
-          current_data->font->GetStringWidth(
-              WideToUTF16Hack(current_data->text));
+          current_data->font->GetStringWidth(current_data->text);
       current_run->pixel_width += current_data->pixel_width;
     }
     DCHECK(!current_run->classifications.empty());
   }
   DCHECK(!runs.empty());
 
   // Sort into logical order so we can elide logically.
   std::sort(runs.begin(), runs.end(), &SortRunsLogically);
 
   // Now determine what to elide, if anything.  Several subtle points:
@@ skipping 35 matching lines @@
     const bool reverse_visible_order = (i->is_rtl != base::i18n::IsRTL());
     int flags = gfx::Canvas::NO_ELLIPSIS;  // We've already elided.
     if (reverse_visible_order) {
       std::reverse(i->classifications.begin(), i->classifications.end());
       if (i->is_rtl)
         flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
     }
     for (Classifications::const_iterator j(i->classifications.begin());
          j != i->classifications.end(); ++j) {
       int left = mirroring_context_->mirrored_left_coord(x, x + j->pixel_width);
-      canvas->DrawStringInt(WideToUTF16Hack(j->text), *j->font, j->color, left,
+      canvas->DrawStringInt(j->text, *j->font, j->color, left,
                             y, j->pixel_width, j->font->GetHeight(), flags);
       x += j->pixel_width;
     }
   }
 
   return x;
 }
 
 void AutocompleteResultView::Elide(Runs* runs, int remaining_width) const {
   // The complexity of this function is due to edge cases like the following:
@@ skipping 18 matching lines @@
         j->text += kEllipsis;
 
         // We also add this classification's width (sans ellipsis) back to the
         // available width since we want to consider the available space we'll
         // have when we draw this classification.
         remaining_width += j->pixel_width;
       }
       first_classification = false;
 
       // Can we fit at least an ellipsis?
-      std::wstring elided_text(UTF16ToWideHack(
-          ui::ElideText(WideToUTF16Hack(j->text), *j->font, remaining_width,
-                        false)));
+      string16 elided_text =
+          ui::ElideText(j->text, *j->font, remaining_width, false);
       Classifications::reverse_iterator prior_classification(j);
       ++prior_classification;
       const bool on_first_classification =
         (prior_classification == i->classifications.rend());
       if (elided_text.empty() && (remaining_width >= ellipsis_width_) &&
           on_first_classification) {
         // Edge case: This classification is bold, we can't fit a bold ellipsis
         // but we can fit a normal one, and this is the first classification in
         // the run.  We should display a lone normal ellipsis, because appending
         // one to the end of the previous run might put it in the wrong visual
         // location (if the previous run is reversed from the normal visual
         // order).
         // NOTE: If this isn't the first classification in the run, we don't
         // need to bother with this; see note below.
         elided_text = kEllipsis;
       }
       if (!elided_text.empty()) {
         // Success.  Elide this classification and stop.
         j->text = elided_text;
 
         // If we could only fit an ellipsis, then only make it bold if there was
         // an immediate prior classification in this run that was also bold, or
         // it will look orphaned.
         if ((elided_text.length() == 1) &&
             (on_first_classification ||
              (prior_classification->font == &normal_font_)))
           j->font = &normal_font_;
 
-        j->pixel_width = j->font->GetStringWidth(WideToUTF16Hack(elided_text));
+        j->pixel_width = j->font->GetStringWidth(elided_text);
 
         // Erase any other classifications that come after the elided one.
         i->classifications.erase(j.base(), i->classifications.end());
         runs->erase(i.base(), runs->end());
         return;
       }
 
       // We couldn't fit an ellipsis.  Move back one classification,
       // append an ellipsis, and try again.
       // NOTE: In the edge case that a bold ellipsis doesn't fit but a
@@ skipping 391 matching lines @@
     size_t index,
     WindowOpenDisposition disposition) {
   if (!HasMatchAt(index))
     return;
 
   const AutocompleteMatch& match = model_->result().match_at(index);
   // OpenURL() may close the popup, which will clear the result set and, by
   // extension, |match| and its contents.  So copy the relevant strings out to
   // make sure they stay alive until the call completes.
   const GURL url(match.destination_url);
-  std::wstring keyword;
+  string16 keyword;
   const bool is_keyword_hint = model_->GetKeywordForMatch(match, &keyword);
   edit_view_->OpenURL(url, disposition, match.transition, GURL(), index,
-                      is_keyword_hint ? std::wstring() : keyword);
+                      is_keyword_hint ? string16() : keyword);
 }
 
 size_t AutocompletePopupContentsView::GetIndexForPoint(
     const gfx::Point& point) {
   if (!HitTest(point))
     return AutocompletePopupModel::kNoMatch;
 
   int nb_match = model_->result().size();
   DCHECK(nb_match <= GetChildViewCount());
   for (int i = 0; i < nb_match; ++i) {
@@ skipping 34 matching lines @@
   opt_in_view_ = NULL;
   PromoCounter* counter = model_->profile()->GetInstantPromoCounter();
   DCHECK(counter);
   counter->Hide();
   if (opt_in) {
     browser::ShowInstantConfirmDialogIfNecessary(
         location_bar_->GetWindow()->GetNativeWindow(), model_->profile());
   }
   UpdatePopupAppearance();
 }