Change std::wstring to string16 for views::Label and views::Link

views/controls/label.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 "views/controls/label.h"
 
+#include <algorithm>
 #include <cmath>
 #include <limits>
+#include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/insets.h"
 #include "views/background.h"
 
 namespace views {
 
 // The colors to use for enabled and disabled labels.
 static SkColor kEnabledColor;
 static SkColor kDisabledColor;
 
 // static
 const char Label::kViewClassName[] = "views/Label";
 
 const int Label::kFocusBorderPadding = 1;
 
 Label::Label() {
-  Init(std::wstring(), GetDefaultFont());
+  Init(string16(), GetDefaultFont());
 }
 
-Label::Label(const std::wstring& text) {
+Label::Label(const string16& text) {
   Init(text, GetDefaultFont());
 }
 
-Label::Label(const std::wstring& text, const gfx::Font& font) {
+Label::Label(const string16& text, const gfx::Font& font) {
   Init(text, font);
 }
 
 Label::~Label() {
 }
 
 void Label::SetFont(const gfx::Font& font) {
   font_ = font;
   text_size_valid_ = false;
   PreferredSizeChanged();
   SchedulePaint();
 }
 
-void Label::SetText(const std::wstring& text) {
-  text_ = WideToUTF16Hack(text);
+void Label::SetText(const string16& text) {
+  text_ = text;
   url_set_ = false;
   text_size_valid_ = false;
   PreferredSizeChanged();
   SchedulePaint();
 }
 
-const std::wstring Label::GetText() const {
-  return url_set_ ? UTF8ToWide(url_.spec()) : UTF16ToWideHack(text_);
+const string16 Label::GetText() const {
+  return url_set_ ? UTF8ToUTF16(url_.spec()) : text_;
 }
 
 void Label::SetURL(const GURL& url) {
   url_ = url;
   text_ = UTF8ToUTF16(url_.spec());
   url_set_ = true;
   text_size_valid_ = false;
   PreferredSizeChanged();
   SchedulePaint();
 }
@@ skipping 175 matching lines @@
   return false;
 }
 
 void Label::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_STATICTEXT;
   state->state = ui::AccessibilityTypes::STATE_READONLY;
   state->name = text_;
 }
 
 void Label::PaintText(gfx::Canvas* canvas,
-                      const std::wstring& text,
+                      const string16& text,
                       const gfx::Rect& text_bounds,
                       int flags) {
-  canvas->DrawStringInt(WideToUTF16Hack(text), font_, color_,
+  canvas->DrawStringInt(text, font_, color_,
                         text_bounds.x(), text_bounds.y(),
                         text_bounds.width(), text_bounds.height(), flags);
 
   if (HasFocus() || paint_as_focused_) {
     gfx::Rect focus_bounds = text_bounds;
     focus_bounds.Inset(-kFocusBorderPadding, -kFocusBorderPadding);
     canvas->DrawFocusRect(focus_bounds.x(), focus_bounds.y(),
                           focus_bounds.width(), focus_bounds.height());
   }
 }
@@ skipping 20 matching lines @@
   return text_size_;
 }
 
 void Label::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   text_size_valid_ &= !is_multi_line_;
 }
 
 void Label::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
 
-  std::wstring paint_text;
+  string16 paint_text;
   gfx::Rect text_bounds;
   int flags = 0;
   CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   PaintText(canvas, paint_text, text_bounds, flags);
 }
 
 void Label::OnPaintBackground(gfx::Canvas* canvas) {
   const Background* bg = contains_mouse_ ? GetMouseOverBackground() : NULL;
   if (!bg)
     bg = background();
   if (bg)
     bg->Paint(canvas, this);
 }
 
 // static
 gfx::Font Label::GetDefaultFont() {
   return ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont);
 }
 
-void Label::Init(const std::wstring& text, const gfx::Font& font) {
+void Label::Init(const string16& text, const gfx::Font& font) {
   static bool initialized = false;
   if (!initialized) {
 #if defined(OS_WIN)
     kEnabledColor = color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
     kDisabledColor = color_utils::GetSysSkColor(COLOR_GRAYTEXT);
 #else
     // TODO(beng): source from theme provider.
     kEnabledColor = SK_ColorBLACK;
     kDisabledColor = SK_ColorGRAY;
 #endif
@@ skipping 88 matching lines @@
   return flags;
 }
 
 gfx::Rect Label::GetAvailableRect() const {
   gfx::Rect bounds(gfx::Point(), size());
   gfx::Insets insets(GetInsets());
   bounds.Inset(insets.left(), insets.top(), insets.right(), insets.bottom());
   return bounds;
 }
 
-void Label::CalculateDrawStringParams(std::wstring* paint_text,
+void Label::CalculateDrawStringParams(string16* paint_text,
                                       gfx::Rect* text_bounds,
                                       int* flags) const {
   DCHECK(paint_text && text_bounds && flags);
 
   if (url_set_) {
     // TODO(jungshik) : Figure out how to get 'intl.accept_languages'
     // preference and use it when calling ElideUrl.
-    *paint_text = UTF16ToWideHack(
-        ui::ElideUrl(url_, font_, GetAvailableRect().width(), std::string()));
+    *paint_text = ui::ElideUrl(url_, font_, GetAvailableRect().width(),
+                               std::string());
 
     // An URLs is always treated as an LTR text and therefore we should
     // explicitly mark it as such if the locale is RTL so that URLs containing
     // Hebrew or Arabic characters are displayed correctly.
     //
     // Note that we don't check the View's UI layout setting in order to
     // determine whether or not to insert the special Unicode formatting
     // characters. We use the locale settings because an URL is always treated
     // as an LTR string, even if its containing view does not use an RTL UI
     // layout.
-    *paint_text = UTF16ToWide(base::i18n::GetDisplayStringInLTRDirectionality(
-        WideToUTF16(*paint_text)));
+    *paint_text = base::i18n::GetDisplayStringInLTRDirectionality(
+        *paint_text);
   } else if (elide_in_middle_) {
-    *paint_text = UTF16ToWideHack(ui::ElideText(text_,
-        font_, GetAvailableRect().width(), true));
+    *paint_text = ui::ElideText(text_, font_, GetAvailableRect().width(),
+                                true);
   } else {
-    *paint_text = UTF16ToWideHack(text_);
+    *paint_text = text_;
   }
 
   *text_bounds = GetTextBounds();
   *flags = ComputeMultiLineFlags();
   // If rtl_alignment_mode_ is AUTO_DETECT_ALIGNMENT (such as for text from
   // webpage, not from chrome's UI), its directionality is forced to be RTL if
   // it is right aligned. Otherwise, its directionality is forced to be LTR.
   if (rtl_alignment_mode_ == AUTO_DETECT_ALIGNMENT) {
     if (horiz_alignment_ == ALIGN_RIGHT)
       *flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
     else
       *flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
   }
 }
 
 }  // namespace views