Add an 'obscured' flag to views::Label.

ui/views/controls/label.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 "ui/views/controls/label.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/gfx/text_utils.h"
+#include "ui/gfx/utf16_indexing.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
 
 namespace {
 
 const int kCachedSizeLimit = 10;
+const base::char16 kPasswordReplacementChar = '*';
 
 }  // namespace
 
 namespace views {
 
 // static
 const char Label::kViewClassName[] = "Label";
 const int Label::kFocusBorderPadding = 1;
 
 Label::Label() {
@@ skipping 12 matching lines @@
 }
 
 void Label::SetFontList(const gfx::FontList& font_list) {
   font_list_ = font_list;
   ResetCachedSize();
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 void Label::SetText(const base::string16& text) {
   if (text == text_)

[msw, 2014/04/03 18:27:48]

nit: flip the condition and drop the return statement.

[Mike West, 2014/04/04 07:05:16]

Done.

     return;
+  SetTextInternal(text);
+}
+
+void Label::SetTextInternal(const base::string16& text) {
   text_ = text;
+
+  if (is_obscured_) {
+    size_t obscured_text_length =
+        static_cast<size_t>(gfx::UTF16IndexToOffset(text_, 0, text_.length()));
+    layout_text_.assign(obscured_text_length, kPasswordReplacementChar);
+  } else {
+    layout_text_ = text_;
+  }
+
   ResetCachedSize();
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 void Label::SetAutoColorReadabilityEnabled(bool enabled) {
   auto_color_readability_ = enabled;
   RecalculateColors();
 }
 
@@ skipping 57 matching lines @@
   DCHECK(!multi_line || (elide_behavior_ != ELIDE_IN_MIDDLE &&
       elide_behavior_ != ELIDE_AT_BEGINNING));
   if (multi_line != is_multi_line_) {
     is_multi_line_ = multi_line;
     ResetCachedSize();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
+void Label::SetObscured(bool obscured) {
+  if (obscured != is_obscured_) {
+    is_obscured_ = obscured;
+    SetTextInternal(text_);
+  }
+}
+
 void Label::SetAllowCharacterBreak(bool allow_character_break) {
   if (allow_character_break != allow_character_break_) {
     allow_character_break_ = allow_character_break;
     ResetCachedSize();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
 void Label::SetElideBehavior(ElideBehavior elide_behavior) {
   DCHECK(elide_behavior != ELIDE_IN_MIDDLE || !is_multi_line_);
   if (elide_behavior != elide_behavior_) {
     elide_behavior_ = elide_behavior;
     ResetCachedSize();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
 void Label::SetTooltipText(const base::string16& tooltip_text) {
   tooltip_text_ = tooltip_text;
 }
 
 void Label::SizeToFit(int max_width) {
   DCHECK(is_multi_line_);
 
   std::vector<base::string16> lines;
-  base::SplitString(text_, '\n', &lines);
+  base::SplitString(layout_text(), '\n', &lines);
 
   int label_width = 0;
   for (std::vector<base::string16>::const_iterator iter = lines.begin();
        iter != lines.end(); ++iter) {
     label_width = std::max(label_width, gfx::GetStringWidth(*iter, font_list_));
   }
 
   label_width += GetInsets().width();
 
   if (max_width > 0)
@@ skipping 54 matching lines @@
   for (size_t i = 0; i < cached_heights_.size(); ++i) {
     const gfx::Size& s = cached_heights_[i];
     if (s.width() == w)
       return s.height() + GetInsets().height();
   }
 
   int cache_width = w;
 
   int h = font_list_.GetHeight();
   const int flags = ComputeDrawStringFlags();
-  gfx::Canvas::SizeStringInt(text_, font_list_, &w, &h, line_height_, flags);
+  gfx::Canvas::SizeStringInt(
+      layout_text(), font_list_, &w, &h, line_height_, flags);
   cached_heights_[cached_heights_cursor_] = gfx::Size(cache_width, h);
   cached_heights_cursor_ = (cached_heights_cursor_ + 1) % kCachedSizeLimit;
   return h + GetInsets().height();
 }
 
 const char* Label::GetClassName() const {
   return kViewClassName;
 }
 
 View* Label::GetTooltipHandlerForPoint(const gfx::Point& point) {
@@ skipping 19 matching lines @@
   DCHECK(tooltip);
 
   // If a tooltip has been explicitly set, use it.
   if (!tooltip_text_.empty()) {
     tooltip->assign(tooltip_text_);
     return true;
   }
 
   // Show the full text if the text does not fit.
   if (ShouldShowDefaultTooltip()) {
-    *tooltip = text_;
+    *tooltip = layout_text();
     return true;
   }
 
   return false;
 }
 
 void Label::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_STATIC_TEXT;
   state->AddStateFlag(ui::AX_STATE_READ_ONLY);
-  state->name = text_;
+  state->name = layout_text();
 }
 
 void Label::PaintText(gfx::Canvas* canvas,
                       const base::string16& text,
                       const gfx::Rect& text_bounds,
                       int flags) {
   gfx::ShadowValues shadows;
   if (has_shadow_)
     shadows.push_back(gfx::ShadowValue(shadow_offset_, 0,
         enabled() ? enabled_shadow_color_ : disabled_shadow_color_));
@@ skipping 15 matching lines @@
     // SizeStringInt() to calculate the desired width, it doesn't seem to work
     // on Linux.
     int w = is_multi_line_ ?
         GetAvailableRect().width() : std::numeric_limits<int>::max();
     int h = font_list_.GetHeight();
     // For single-line strings, ignore the available width and calculate how
     // wide the text wants to be.
     int flags = ComputeDrawStringFlags();
     if (!is_multi_line_)
       flags |= gfx::Canvas::NO_ELLIPSIS;
-    gfx::Canvas::SizeStringInt(text_, font_list_, &w, &h, line_height_, flags);
+    gfx::Canvas::SizeStringInt(
+        layout_text(), font_list_, &w, &h, line_height_, flags);
     text_size_.SetSize(w, h);
     text_size_valid_ = true;
   }
 
   return text_size_;
 }
 
 void Label::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   text_size_valid_ &= !is_multi_line_;
 }
@@ skipping 17 matching lines @@
 }
 
 void Label::Init(const base::string16& text, const gfx::FontList& font_list) {
   font_list_ = font_list;
   enabled_color_set_ = disabled_color_set_ = background_color_set_ = false;
   auto_color_readability_ = true;
   UpdateColorsFromTheme(ui::NativeTheme::instance());
   horizontal_alignment_ = gfx::ALIGN_CENTER;
   line_height_ = 0;
   is_multi_line_ = false;
+  is_obscured_ = false;
   allow_character_break_ = false;
   elide_behavior_ = ELIDE_AT_END;
   collapse_when_hidden_ = false;
   directionality_mode_ = USE_UI_DIRECTIONALITY;
   enabled_shadow_color_ = 0;
   disabled_shadow_color_ = 0;
   shadow_offset_.SetPoint(1, 1);
   has_shadow_ = false;
   cached_heights_.resize(kCachedSizeLimit);
   ResetCachedSize();
@@ skipping 44 matching lines @@
 
 int Label::ComputeDrawStringFlags() const {
   int flags = 0;
 
   // We can't use subpixel rendering if the background is non-opaque.
   if (SkColorGetA(background_color_) != 0xFF)
     flags |= gfx::Canvas::NO_SUBPIXEL_RENDERING;
 
   if (directionality_mode_ == AUTO_DETECT_DIRECTIONALITY) {
     base::i18n::TextDirection direction =
-        base::i18n::GetFirstStrongCharacterDirection(text_);
+        base::i18n::GetFirstStrongCharacterDirection(layout_text());
     if (direction == base::i18n::RIGHT_TO_LEFT)
       flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
     else
       flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
   }
 
   switch (horizontal_alignment_) {
     case gfx::ALIGN_LEFT:
       flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
       break;
@@ skipping 30 matching lines @@
 }
 
 void Label::CalculateDrawStringParams(base::string16* paint_text,
                                       gfx::Rect* text_bounds,
                                       int* flags) const {
   DCHECK(paint_text && text_bounds && flags);
 
   // TODO(msw): Use ElideRectangleText to support eliding multi-line text.  Once
   // this is done, we can set NO_ELLIPSIS unconditionally at the bottom.
   if (is_multi_line_ || (elide_behavior_ == NO_ELIDE)) {
-    *paint_text = text_;
+    *paint_text = layout_text();
   } else if (elide_behavior_ == ELIDE_AT_BEGINNING) {
-    *paint_text = gfx::ElideText(text_, font_list_, GetAvailableRect().width(),
+    *paint_text = gfx::ElideText(layout_text(),
+                                 font_list_,
+                                 GetAvailableRect().width(),
                                  gfx::ELIDE_AT_BEGINNING);
   } else if (elide_behavior_ == ELIDE_IN_MIDDLE) {
-    *paint_text = gfx::ElideText(text_, font_list_, GetAvailableRect().width(),
+    *paint_text = gfx::ElideText(layout_text(),
+                                 font_list_,
+                                 GetAvailableRect().width(),
                                  gfx::ELIDE_IN_MIDDLE);
   } else if (elide_behavior_ == ELIDE_AT_END) {
-    *paint_text = gfx::ElideText(text_, font_list_, GetAvailableRect().width(),
+    *paint_text = gfx::ElideText(layout_text(),
+                                 font_list_,
+                                 GetAvailableRect().width(),
                                  gfx::ELIDE_AT_END);
   } else {
     DCHECK_EQ(ELIDE_AS_EMAIL, elide_behavior_);
-    *paint_text = gfx::ElideEmail(text_, font_list_,
-                                  GetAvailableRect().width());
+    *paint_text =
+        gfx::ElideEmail(layout_text(), font_list_, GetAvailableRect().width());
   }
 
   *text_bounds = GetTextBounds();
   *flags = ComputeDrawStringFlags();
   if (!is_multi_line_ || (elide_behavior_ == NO_ELIDE))
      *flags |= gfx::Canvas::NO_ELLIPSIS;
 }
 
 void Label::UpdateColorsFromTheme(const ui::NativeTheme* theme) {
   if (!enabled_color_set_) {
@@ skipping 12 matching lines @@
 }
 
 void Label::ResetCachedSize() {
   text_size_valid_ = false;
   cached_heights_cursor_ = 0;
   for (int i = 0; i < kCachedSizeLimit; ++i)
     cached_heights_[i] = gfx::Size();
 }
 
 bool Label::ShouldShowDefaultTooltip() const {
-  return !is_multi_line_ &&
-      gfx::GetStringWidth(text_, font_list_) > GetAvailableRect().width();
+  return !is_multi_line_ && !is_obscured_ &&
+         gfx::GetStringWidth(layout_text(), font_list_) >
+             GetAvailableRect().width();
 }
 
 }  // namespace views