Merge NativeTextfieldViews into views::Textfield.

chrome/browser/ui/views/omnibox/omnibox_view_views.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 "chrome/browser/ui/views/omnibox/omnibox_view_views.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 26 matching lines @@
 #include "ui/base/ime/text_input_type.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/selection_model.h"
 #include "ui/views/border.h"
 #include "ui/views/button_drag_utils.h"
-#include "ui/views/controls/textfield/native_textfield_views.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/browser_process.h"
 #endif
@@ skipping 111 matching lines @@
       ToolbarModel::NONE, LocationBarView::BACKGROUND));
 
   if (popup_window_mode_)
     SetReadOnly(true);
 
   if (chrome::ShouldDisplayOriginChip())
     set_placeholder_text(l10n_util::GetStringUTF16(IDS_OMNIBOX_EMPTY_HINT));
 
   // Initialize the popup view using the same font.
   popup_view_.reset(OmniboxPopupContentsView::Create(
-      font_list(), this, model(), location_bar_view_));
+      GetFontList(), this, model(), location_bar_view_));
 
 #if defined(OS_CHROMEOS)
   chromeos::input_method::InputMethodManager::Get()->
       AddCandidateWindowObserver(this);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxViewViews, views::Textfield implementation:
 
@@ skipping 156 matching lines @@
   // Note the parallel with SkipDefaultKeyEventProcessing above.
   if (views::FocusManager::IsTabTraversalKeyEvent(event)) {
     if (model()->is_keyword_hint() && !event.IsShiftDown()) {
       model()->AcceptKeyword(ENTERED_KEYWORD_MODE_VIA_TAB);
       return true;
     }
     if (model()->popup_model()->IsOpen()) {
       if (event.IsShiftDown() &&
           model()->popup_model()->selected_line_state() ==
               OmniboxPopupModel::KEYWORD) {
-        model()->ClearKeyword(text());
+        model()->ClearKeyword(GetText());
       } else {
         model()->OnUpOrDownKeyPressed(event.IsShiftDown() ? -1 : 1);
       }
       return true;
     }
   }
 
   return false;
 }
 
@@ skipping 83 matching lines @@
     // Something visibly changed.  Re-enable URL replacement.
     controller()->GetToolbarModel()->set_url_replacement_enabled(true);
     model()->UpdatePermanentText();
 
     // Tweak: if the user had all the text selected, select all the new text.
     // This makes one particular case better: the user clicks in the box to
     // change it right before the permanent URL is changed.  Since the new URL
     // is still fully selected, the user's typing will replace the edit contents
     // as they'd intended.
     const gfx::Range range(GetSelectedRange());
-    const bool was_select_all = (range.length() == text().length());
+    const bool was_select_all = (range.length() == GetText().length());
 
     RevertAll();
 
     // Only select all when we have focus.  If we don't have focus, selecting
     // all is unnecessary since the selection will change on regaining focus,
     // and can in fact cause artifacts, e.g. if the user is on the NTP and
     // clicks a link to navigate, causing |was_select_all| to be vacuously true
     // for the empty omnibox, and we then select all here, leading to the
     // trailing portion of a long URL being scrolled into view.  We could try
     // and address cases like this, but it seems better to just not muck with
     // things when the omnibox isn't focused to begin with.
     if (was_select_all && model()->has_focus())
       SelectAll(range.is_reversed());
   } else if (old_security_level != security_level_) {
     EmphasizeURLComponents();
   }
 }
 
 base::string16 OmniboxViewViews::GetText() const {
   // TODO(oshima): IME support
-  return text();
+  return Textfield::GetText();
 }
 
 void OmniboxViewViews::SetUserText(const base::string16& text,
                                    const base::string16& display_text,
                                    bool update_popup) {
   saved_selection_for_focus_change_ = gfx::Range::InvalidRange();
   OmniboxView::SetUserText(text, display_text, update_popup);
 }
 
 void OmniboxViewViews::SetWindowTextAndCaretPos(const base::string16& text,
                                                 size_t caret_pos,
                                                 bool update_popup,
                                                 bool notify_text_changed) {
   const gfx::Range range(caret_pos, caret_pos);
   SetTextAndSelectedRange(text, range);
 
   if (update_popup)
     UpdatePopup();
 
   if (notify_text_changed)
     TextChanged();
 }
 
 void OmniboxViewViews::SetForcedQuery() {
-  const base::string16 current_text(text());
+  const base::string16 current_text(GetText());
   const size_t start = current_text.find_first_not_of(base::kWhitespaceUTF16);
   if (start == base::string16::npos || (current_text[start] != '?'))
     OmniboxView::SetUserText(base::ASCIIToUTF16("?"));
   else
     SelectRange(gfx::Range(current_text.size(), start + 1));
 }
 
 bool OmniboxViewViews::IsSelectAll() const {
   // TODO(oshima): IME support.
-  return text() == GetSelectedText();
+  return GetText() == GetSelectedText();
 }
 
 bool OmniboxViewViews::DeleteAtEndPressed() {
   return delete_at_end_pressed_;
 }
 
 void OmniboxViewViews::GetSelectionBounds(
     base::string16::size_type* start,
     base::string16::size_type* end) const {
   const gfx::Range range = GetSelectedRange();
@@ skipping 14 matching lines @@
   model()->SetInputInProgress(true);
   if (!model()->has_focus())
     return;
 
   // Prevent inline autocomplete when the caret isn't at the end of the text,
   // and during IME composition editing unless
   // |kEnableOmniboxAutoCompletionForIme| is enabled.
   const gfx::Range sel = GetSelectedRange();
   model()->StartAutocomplete(
       !sel.is_empty(),
-      sel.GetMax() < text().length() ||
+      sel.GetMax() < GetText().length() ||
       (IsIMEComposing() && !IsOmniboxAutoCompletionForImeEnabled()));
 }
 
 void OmniboxViewViews::SetFocus() {
   RequestFocus();
   // Restore caret visibility if focus is explicitly requested. This is
   // necessary because if we already have invisible focus, the RequestFocus()
   // call above will short-circuit, preventing us from reaching
   // OmniboxEditModel::OnSetFocus(), which handles restoring visibility when the
   // omnibox regains focus after losing focus.
@@ skipping 11 matching lines @@
   if (save_original_selection)
     saved_temporary_selection_ = GetSelectedRange();
 
   SetWindowTextAndCaretPos(display_text, display_text.length(), false,
                            notify_text_changed);
 }
 
 bool OmniboxViewViews::OnInlineAutocompleteTextMaybeChanged(
     const base::string16& display_text,
     size_t user_text_length) {
-  if (display_text == text())
+  if (display_text == GetText())
     return false;
 
   if (IsIMEComposing()) {
     location_bar_view_->SetImeInlineAutocompletion(
         display_text.substr(user_text_length));
   } else {
     gfx::Range range(display_text.size(), user_text_length);
     SetTextAndSelectedRange(display_text, range);
   }
   TextChanged();
   return true;
 }
 
 void OmniboxViewViews::OnInlineAutocompleteTextCleared() {
   // Hide the inline autocompletion for IME users.
   location_bar_view_->SetImeInlineAutocompletion(base::string16());
 }
 
 void OmniboxViewViews::OnRevertTemporaryText() {
   SelectRange(saved_temporary_selection_);
   // We got here because the user hit the Escape key. We explicitly don't call
   // TextChanged(), since OmniboxPopupModel::ResetToDefaultMatch() has already
   // been called by now, and it would've called TextChanged() if it was
   // warranted.
 }
 
 void OmniboxViewViews::OnBeforePossibleChange() {
   // Record our state.
-  text_before_change_ = text();
+  text_before_change_ = GetText();
   sel_before_change_ = GetSelectedRange();
   ime_composing_before_change_ = IsIMEComposing();
 }
 
 bool OmniboxViewViews::OnAfterPossibleChange() {
   // See if the text or selection have changed since OnBeforePossibleChange().
-  const base::string16 new_text = text();
+  const base::string16 new_text = GetText();
   const gfx::Range new_sel = GetSelectedRange();
   const bool text_changed = (new_text != text_before_change_) ||
       (ime_composing_before_change_ != IsIMEComposing());
   const bool selection_differs =
       !((sel_before_change_.is_empty() && new_sel.is_empty()) ||
         sel_before_change_.EqualsIgnoringDirection(new_sel));
 
   // When the user has deleted text, we don't allow inline autocomplete.  Make
   // sure to not flag cases like selecting part of the text and then pasting
   // (or typing) the prefix of that selection.  (We detect these by making
@@ skipping 37 matching lines @@
 
 base::string16 OmniboxViewViews::GetGrayTextAutocompletion() const {
 #if defined(OS_WIN) || defined(USE_AURA)
   return location_bar_view_->GetGrayTextAutocompletion();
 #else
   return base::string16();
 #endif
 }
 
 int OmniboxViewViews::GetTextWidth() const {
-  return textfield_view_->GetWidthNeededForText();
+  // Returns the width necessary to display the current text, including any
+  // necessary space for the cursor or border/margin.
+  return GetRenderText()->GetContentWidth() + GetInsets().width();
 }
 
 int OmniboxViewViews::GetWidth() const {
   return location_bar_view_->width();
 }
 
 bool OmniboxViewViews::IsImeComposing() const {
   return IsIMEComposing();
 }
 
@@ skipping 16 matching lines @@
 bool OmniboxViewViews::HandleKeyEvent(views::Textfield* textfield,
                                       const ui::KeyEvent& event) {
   delete_at_end_pressed_ = false;
 
   if (event.key_code() == ui::VKEY_BACK) {
     // No extra handling is needed in keyword search mode, if there is a
     // non-empty selection, or if the cursor is not leading the text.
     if (model()->is_keyword_hint() || model()->keyword().empty() ||
         HasSelection() || GetCursorPosition() != 0)
       return false;
-    model()->ClearKeyword(text());
+    model()->ClearKeyword(GetText());
     return true;
   }
 
   if (event.key_code() == ui::VKEY_DELETE && !event.IsAltDown()) {
     delete_at_end_pressed_ =
-        (!HasSelection() && GetCursorPosition() == text().length());
+        (!HasSelection() && GetCursorPosition() == GetText().length());
   }
 
   // Handle the right-arrow key for LTR text and the left-arrow key for RTL text
   // if there is gray text that needs to be committed.
-  if (GetCursorPosition() == text().length()) {
+  if (GetCursorPosition() == GetText().length()) {
     base::i18n::TextDirection direction = GetTextDirection();
     if ((direction == base::i18n::LEFT_TO_RIGHT &&
          event.key_code() == ui::VKEY_RIGHT) ||
         (direction == base::i18n::RIGHT_TO_LEFT &&
          event.key_code() == ui::VKEY_LEFT)) {
       return model()->CommitSuggestedText();
     }
   }
 
   return false;
@@ skipping 175 matching lines @@
       chromeos::input_method::InputMethodManager* manager) {
   ime_candidate_window_open_ = false;
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxViewViews, private:
 
 int OmniboxViewViews::GetOmniboxTextLength() const {
   // TODO(oshima): Support IME.
-  return static_cast<int>(text().length());
+  return static_cast<int>(GetText().length());
 }
 
 void OmniboxViewViews::EmphasizeURLComponents() {
   // See whether the contents are a URL with a non-empty host portion, which we
   // should emphasize.  To check for a URL, rather than using the type returned
   // by Parse(), ask the model, which will check the desired page transition for
   // this input.  This can tell us whether an UNKNOWN input string is going to
   // be treated as a search or a navigation, and is the same method the Paste
   // And Go system uses.
   url_parse::Component scheme, host;
-  AutocompleteInput::ParseForEmphasizeComponents(text(), &scheme, &host);
-  bool grey_out_url = text().substr(scheme.begin, scheme.len) ==
+  AutocompleteInput::ParseForEmphasizeComponents(GetText(), &scheme, &host);
+  bool grey_out_url = GetText().substr(scheme.begin, scheme.len) ==
       base::UTF8ToUTF16(extensions::kExtensionScheme);
   bool grey_base = model()->CurrentTextIsURL() &&
       (host.is_nonempty() || grey_out_url);
   SetColor(location_bar_view_->GetColor(
       security_level_,
       grey_base ? LocationBarView::DEEMPHASIZED_TEXT : LocationBarView::TEXT));
   if (grey_base && !grey_out_url) {
     ApplyColor(
         location_bar_view_->GetColor(security_level_, LocationBarView::TEXT),
         gfx::Range(host.begin, host.end()));
@@ skipping 31 matching lines @@
   const base::string16 text(GetClipboardText());
   if (!text.empty()) {
     // Record this paste, so we can do different behavior.
     model()->OnPaste();
     // Force a Paste operation to trigger the text_changed code in
     // OnAfterPossibleChange(), even if identical contents are pasted.
     text_before_change_.clear();
     InsertOrReplaceText(text);
   }
 }