Supports the invisible underline for native input fields.

ui/views/controls/textfield/textfield_model.cc

 // Copyright 2014 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/textfield/textfield_model.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 546 matching lines @@
     CancelCompositionText();
   else if (HasSelection())
     DeleteSelection();
 
   if (composition.text.empty())
     return;
 
   size_t cursor = GetCursorPosition();
   base::string16 new_text = text();
   render_text_->SetText(new_text.insert(cursor, composition.text));
-  gfx::Range range(cursor, cursor + composition.text.length());
-  render_text_->SetCompositionRange(range);
+  composition_range_ = gfx::Range(cursor, cursor + composition.text.length());
+  // Don't render the underline for composition which is configured as

[msw, 2015/03/26 20:22:48]

nit: "Don't render transparent composition underlines."

[Shu Chen, 2015/03/30 03:56:21]

Done.

+  // transparent color.
+  if (composition.underlines.size() > 0 && composition.underlines[0].color != 0)
+    render_text_->SetCompositionRange(composition_range_);
+  else
+    render_text_->SetCompositionRange(gfx::Range::InvalidRange());
   gfx::Range emphasized_range = GetFirstEmphasizedRange(composition);
   if (emphasized_range.IsValid()) {
     // This is a workaround due to the lack of support in RenderText to draw
     // a thick underline. In a composition returned from an IME, the segment
     // emphasized by a thick underline usually represents the target clause.
     // Because the target clause is more important than the actual selection
     // range (or caret position) in the composition here we use a selection-like
     // marker instead to show this range.
     // TODO(yukawa, msw): Support thick underlines and remove this workaround.
     render_text_->SelectRange(gfx::Range(
         cursor + emphasized_range.GetMin(),
         cursor + emphasized_range.GetMax()));
   } else if (!composition.selection.is_empty()) {
     render_text_->SelectRange(gfx::Range(
         cursor + composition.selection.GetMin(),
         cursor + composition.selection.GetMax()));
   } else {
     render_text_->SetCursorPosition(cursor + composition.selection.end());
   }
 }
 
 void TextfieldModel::ConfirmCompositionText() {
   DCHECK(HasCompositionText());
-  gfx::Range range = render_text_->GetCompositionRange();
-  base::string16 composition = text().substr(range.start(), range.length());
+  base::string16 composition = text().substr(
+      composition_range_.start(), composition_range_.length());
   // TODO(oshima): current behavior on ChromeOS is a bit weird and not
   // sure exactly how this should work. Find out and fix if necessary.
-  AddOrMergeEditHistory(new InsertEdit(false, composition, range.start()));
-  render_text_->SetCursorPosition(range.end());
+  AddOrMergeEditHistory(
+      new InsertEdit(false, composition, composition_range_.start()));
+  render_text_->SetCursorPosition(composition_range_.end());
   ClearComposition();
   if (delegate_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldModel::CancelCompositionText() {
   DCHECK(HasCompositionText());
-  gfx::Range range = render_text_->GetCompositionRange();
+  gfx::Range range = composition_range_;
   ClearComposition();
   base::string16 new_text = text();
   render_text_->SetText(new_text.erase(range.start(), range.length()));
   render_text_->SetCursorPosition(range.start());
   if (delegate_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldModel::ClearComposition() {
-  render_text_->SetCompositionRange(gfx::Range::InvalidRange());
+  composition_range_ = gfx::Range::InvalidRange();
+  render_text_->SetCompositionRange(composition_range_);
 }
 
 void TextfieldModel::GetCompositionTextRange(gfx::Range* range) const {
-  *range = gfx::Range(render_text_->GetCompositionRange());
+  *range = composition_range_;
 }
 
 bool TextfieldModel::HasCompositionText() const {
-  return !render_text_->GetCompositionRange().is_empty();
+  return !composition_range_.is_empty();
 }
 
 void TextfieldModel::ClearEditHistory() {
   STLDeleteElements(&edit_history_);
   current_edit_ = edit_history_.end();
 }
 
 /////////////////////////////////////////////////////////////////
 // TextfieldModel: private
 
@@ skipping 126 matching lines @@
   ClearComposition();
   if (delete_from != delete_to)
     render_text_->SetText(old_text.erase(delete_from, delete_to - delete_from));
   if (!new_text.empty())
     render_text_->SetText(old_text.insert(new_text_insert_at, new_text));
   render_text_->SetCursorPosition(new_cursor_pos);
   // TODO(oshima): Select text that was just undone, like Mac (but not GTK).
 }
 
 }  // namespace views