Moving common code into OmniboxView from OmniboxView*

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/logging.h"
 #include "base/property_bag.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 206 matching lines @@
 
 // static
 const char OmniboxViewViews::kViewClassName[] = "BrowserOmniboxViewViews";
 
 OmniboxViewViews::OmniboxViewViews(OmniboxEditController* controller,
                                    ToolbarModel* toolbar_model,
                                    Profile* profile,
                                    CommandUpdater* command_updater,
                                    bool popup_window_mode,
                                    LocationBarView* location_bar)
-    : textfield_(NULL),
+    : OmniboxView(profile, controller, toolbar_model, command_updater),
+      textfield_(NULL),
       popup_window_mode_(popup_window_mode),
-      model_(new OmniboxEditModel(this, controller, profile)),
-      controller_(controller),
-      toolbar_model_(toolbar_model),
-      command_updater_(command_updater),
       security_level_(ToolbarModel::NONE),
       ime_composing_before_change_(false),
       delete_at_end_pressed_(false),
       location_bar_view_(location_bar),
       ime_candidate_window_open_(false),
       select_all_on_mouse_release_(false) {
   if (chrome::search::IsInstantExtendedAPIEnabled(
           location_bar_view_->profile())) {
     set_background(views::Background::CreateSolidBackground(
         chrome::search::kOmniboxBackgroundColor));
   }
 }
 
 OmniboxViewViews::~OmniboxViewViews() {
 #if defined(OS_CHROMEOS)
   chromeos::input_method::InputMethodManager::GetInstance()->
       RemoveCandidateWindowObserver(this);
 #endif
 
   // Explicitly teardown members which have a reference to us.  Just to be safe
   // we want them to be destroyed before destroying any other internal state.
   popup_view_.reset();
-  model_.reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxViewViews public:
 
 void OmniboxViewViews::Init(views::View* popup_parent_view) {
   // The height of the text view is going to change based on the font used.  We
   // don't want to stretch the height, and we want it vertically centered.
   // TODO(oshima): make sure the above happens with views.
   textfield_ = new AutocompleteTextfield(this, location_bar_view_);
   textfield_->SetController(this);
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_URL);
 
   if (popup_window_mode_)
     textfield_->SetReadOnly(true);
 
   const int font_size =
       !popup_window_mode_ && chrome::search::IsInstantExtendedAPIEnabled(
           location_bar_view_->profile()) ?
               chrome::search::kOmniboxFontSize :
               GetEditFontPixelSize(popup_window_mode_);
   const int old_size = textfield_->font().GetFontSize();
   if (font_size != old_size)
     textfield_->SetFont(textfield_->font().DeriveFont(font_size - old_size));
 
   // Create popup view using the same font as |textfield_|'s.
   popup_view_.reset(
       OmniboxPopupContentsView::Create(
-          textfield_->font(), this, model_.get(), location_bar_view_,
+          textfield_->font(), this, model(), location_bar_view_,
           popup_parent_view));
 
   // A null-border to zero out the focused border on textfield.
   const int vertical_margin = !popup_window_mode_ ?
       kAutocompleteVerticalMargin : kAutocompleteVerticalMarginInPopup;
   set_border(views::Border::CreateEmptyBorder(vertical_margin, 0,
                                               vertical_margin, 0));
 #if defined(OS_CHROMEOS)
   chromeos::input_method::InputMethodManager::GetInstance()->
       AddCandidateWindowObserver(this);
@@ skipping 10 matching lines @@
   // See comments in LocationBarView::Layout as to why this uses -1.
   const int start = std::max(0, static_cast<int>(sel.end()) - 1);
   // TODO: add horizontal margin.
   return textfield_->font().GetStringWidth(GetText().substr(start));
 }
 
 bool OmniboxViewViews::HandleAfterKeyEvent(const views::KeyEvent& event,
                                            bool handled) {
   if (event.key_code() == ui::VKEY_RETURN) {
     bool alt_held = event.IsAltDown();
-    model_->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
+    model()->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
     handled = true;
   } else if (!handled && event.key_code() == ui::VKEY_ESCAPE) {
     // We can handle the Escape key if textfield did not handle it.
     // If it's not handled by us, then we need to propagate it up to the parent
     // widgets, so that Escape accelerator can still work.
-    handled = model_->OnEscapeKeyPressed();
+    handled = model()->OnEscapeKeyPressed();
   } else if (event.key_code() == ui::VKEY_CONTROL) {
     // Omnibox2 can switch its contents while pressing a control key. To switch
     // the contents of omnibox2, we notify the OmniboxEditModel class when the
     // control-key state is changed.
-    model_->OnControlKeyChanged(true);
+    model()->OnControlKeyChanged(true);
   } else if (!handled && event.key_code() == ui::VKEY_DELETE &&
              event.IsShiftDown()) {
     // If shift+del didn't change the text, we let this delete an entry from
     // the popup.  We can't check to see if the IME handled it because even if
     // nothing is selected, the IME or the TextView still report handling it.
-    if (model_->popup_model()->IsOpen())
-      model_->popup_model()->TryDeletingCurrentItem();
+    if (model()->popup_model()->IsOpen())
+      model()->popup_model()->TryDeletingCurrentItem();
   } else if (!handled && event.key_code() == ui::VKEY_UP) {
-    model_->OnUpOrDownKeyPressed(-1);
+    model()->OnUpOrDownKeyPressed(-1);
     handled = true;
   } else if (!handled && event.key_code() == ui::VKEY_DOWN) {
-    model_->OnUpOrDownKeyPressed(1);
+    model()->OnUpOrDownKeyPressed(1);
     handled = true;
   } else if (!handled &&
              event.key_code() == ui::VKEY_TAB &&
              !event.IsControlDown()) {
-    if (model_->is_keyword_hint() && !event.IsShiftDown()) {
-      handled = model_->AcceptKeyword();
-    } else if (model_->popup_model()->IsOpen()) {
+    if (model()->is_keyword_hint() && !event.IsShiftDown()) {
+      handled = model()->AcceptKeyword();
+    } else if (model()->popup_model()->IsOpen()) {
       if (event.IsShiftDown() &&
-          model_->popup_model()->selected_line_state() ==
+          model()->popup_model()->selected_line_state() ==
               OmniboxPopupModel::KEYWORD) {
-        model_->ClearKeyword(GetText());
+        model()->ClearKeyword(GetText());
       } else {
-        model_->OnUpOrDownKeyPressed(event.IsShiftDown() ? -1 : 1);
+        model()->OnUpOrDownKeyPressed(event.IsShiftDown() ? -1 : 1);
       }
       handled = true;
     } else {
       string16::size_type start = 0;
       string16::size_type end = 0;
       size_t length = GetTextLength();
       GetSelectionBounds(&start, &end);
       if (start != end || start < length) {
         OnBeforePossibleChange();
         textfield_->SelectRange(ui::Range(length, length));
         OnAfterPossibleChange();
         handled = true;
       }
 
       // TODO(Oshima): handle instant
     }
   }
   // TODO(oshima): page up & down
 
   return handled;
 }
 
 bool OmniboxViewViews::HandleKeyReleaseEvent(const views::KeyEvent& event) {
   // Omnibox2 can switch its contents while pressing a control key. To switch
   // the contents of omnibox2, we notify the OmniboxEditModel class when the
   // control-key state is changed.
   if (event.key_code() == ui::VKEY_CONTROL) {
     // TODO(oshima): investigate if we need to support keyboard with two
     // controls.
-    model_->OnControlKeyChanged(false);
+    model()->OnControlKeyChanged(false);
     return true;
   }
   return false;
 }
 
 void OmniboxViewViews::HandleMousePressEvent(const views::MouseEvent& event) {
   select_all_on_mouse_release_ =
       (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) &&
       !textfield_->HasFocus();
 }
 
 void OmniboxViewViews::HandleMouseDragEvent(const views::MouseEvent& event) {
   select_all_on_mouse_release_ = false;
 }
 
 void OmniboxViewViews::HandleMouseReleaseEvent(const views::MouseEvent& event) {
   if ((event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) &&
       select_all_on_mouse_release_) {
     // Select all in the reverse direction so as not to scroll the caret
     // into view and shift the contents jarringly.
     SelectAll(true);
   }
   select_all_on_mouse_release_ = false;
 }
 
 void OmniboxViewViews::HandleFocusIn() {
   // TODO(oshima): Get control key state.
-  model_->OnSetFocus(false);
-  // Don't call controller_->OnSetFocus as this view has already
+  model()->OnSetFocus(false);
+  // Don't call controller()->OnSetFocus as this view has already
   // acquired the focus.
 }
 
 void OmniboxViewViews::HandleFocusOut() {
   gfx::NativeView native_view = NULL;
 #if defined(USE_AURA)
   views::Widget* widget = GetWidget();
   if (widget) {
     aura::RootWindow* root = widget->GetNativeView()->GetRootWindow();
     if (root)
       native_view = root->GetFocusManager()->GetFocusedWindow();
   }
 #endif
-  model_->OnWillKillFocus(native_view);
+  model()->OnWillKillFocus(native_view);
   // Close the popup.
   ClosePopup();
   // Tell the model to reset itself.
-  model_->OnKillFocus();
-  controller_->OnKillFocus();
+  model()->OnKillFocus();
+  controller()->OnKillFocus();
 }
 
 void OmniboxViewViews::SetLocationEntryFocusable(bool focusable) {
   textfield_->set_focusable(focusable);
 }
 
 bool OmniboxViewViews::IsLocationEntryFocusableInRootView() const {
   return textfield_->IsFocusable();
 }
 
@@ skipping 21 matching lines @@
 }
 
 void OmniboxViewViews::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   if (popup_view_->IsOpen())
     popup_view_->UpdatePopupAppearance();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxViewViews, AutocopmleteEditView implementation:
 
-OmniboxEditModel* OmniboxViewViews::model() {
-  return model_.get();
-}
-
-const OmniboxEditModel* OmniboxViewViews::model() const {
-  return model_.get();
-}
-
 void OmniboxViewViews::SaveStateToTab(WebContents* tab) {
   DCHECK(tab);
 
   // We don't want to keep the IME status, so force quit the current
   // session here.  It may affect the selection status, so order is
   // also important.
   if (textfield_->IsIMEComposing()) {
     textfield_->GetTextInputClient()->ConfirmCompositionText();
     textfield_->GetInputMethod()->CancelComposition(textfield_);
   }
 
   // NOTE: GetStateForTabSwitch may affect GetSelection, so order is important.
-  OmniboxEditModel::State model_state = model_->GetStateForTabSwitch();
+  OmniboxEditModel::State model_state = model()->GetStateForTabSwitch();
   gfx::SelectionModel selection;
   textfield_->GetSelectionModel(&selection);
   GetStateAccessor()->SetProperty(
       tab->GetPropertyBag(),
       AutocompleteEditState(model_state, ViewState(selection)));
 }
 
 void OmniboxViewViews::Update(const WebContents* contents) {
   // NOTE: We're getting the URL text here from the ToolbarModel.
   bool visibly_changed_permanent_text =
-      model_->UpdatePermanentText(toolbar_model_->GetText());
+      model()->UpdatePermanentText(toolbar_model()->GetText());
   ToolbarModel::SecurityLevel security_level =
-        toolbar_model_->GetSecurityLevel();
+        toolbar_model()->GetSecurityLevel();
   bool changed_security_level = (security_level != security_level_);
   security_level_ = security_level;
 
   // TODO(oshima): Copied from gtk implementation which is
   // slightly different from WIN impl. Find out the correct implementation
   // for views-implementation.
   if (contents) {
     RevertAll();
     const AutocompleteEditState* state =
         GetStateAccessor()->GetProperty(contents->GetPropertyBag());
     if (state) {
-      model_->RestoreState(state->model_state);
+      model()->RestoreState(state->model_state);
 
       // Move the marks for the cursor and the other end of the selection to
       // the previously-saved offsets (but preserve PRIMARY).
       textfield_->SelectSelectionModel(state->view_state.selection_model);
       // We do not carry over the current edit history to another tab.
       // TODO(oshima): consider saving/restoring edit history.
       textfield_->ClearEditHistory();
     }
   } else if (visibly_changed_permanent_text) {
     RevertAll();
   } else if (changed_security_level) {
     EmphasizeURLComponents();
   }
 }
 
-void OmniboxViewViews::OpenMatch(const AutocompleteMatch& match,
-                                 WindowOpenDisposition disposition,
-                                 const GURL& alternate_nav_url,
-                                 size_t selected_line) {
-  if (!match.destination_url.is_valid())
-    return;
-
-  model_->OpenMatch(match, disposition, alternate_nav_url, selected_line);
-}
-
 string16 OmniboxViewViews::GetText() const {
   // TODO(oshima): IME support
   return textfield_->text();
 }
 
-bool OmniboxViewViews::IsEditingOrEmpty() const {
-  return model_->user_input_in_progress() || (GetTextLength() == 0);
-}
-
-int OmniboxViewViews::GetIcon() const {
-  return IsEditingOrEmpty() ?
-      AutocompleteMatch::TypeToIcon(model_->CurrentTextType()) :
-      toolbar_model_->GetIcon();
-}
-
-void OmniboxViewViews::SetUserText(const string16& text) {
-  SetUserText(text, text, true);
-}
-
-void OmniboxViewViews::SetUserText(const string16& text,
-                                   const string16& display_text,
-                                   bool update_popup) {
-  model_->SetUserText(text);
-  SetWindowTextAndCaretPos(display_text, display_text.length(), update_popup,
-      true);
-}
-
 void OmniboxViewViews::SetWindowTextAndCaretPos(const string16& text,
                                                 size_t caret_pos,
                                                 bool update_popup,
                                                 bool notify_text_changed) {
   const ui::Range range(caret_pos, caret_pos);
   SetTextAndSelectedRange(text, range);
 
   if (update_popup)
     UpdatePopup();
 
@@ skipping 31 matching lines @@
   } else {
     *start = static_cast<size_t>(range.end());
     *end = static_cast<size_t>(range.start());
   }
 }
 
 void OmniboxViewViews::SelectAll(bool reversed) {
   textfield_->SelectAll(reversed);
 }
 
-void OmniboxViewViews::RevertAll() {
-  ClosePopup();
-  model_->Revert();
-  TextChanged();
-}
-
 void OmniboxViewViews::UpdatePopup() {
-  model_->SetInputInProgress(true);
+  model()->SetInputInProgress(true);
   if (ime_candidate_window_open_)
     return;
-  if (!model_->has_focus())
+  if (!model()->has_focus())
     return;
 
   // Don't inline autocomplete when the caret/selection isn't at the end of
   // the text, or in the middle of composition.
   ui::Range sel;
   textfield_->GetSelectedRange(&sel);
   bool no_inline_autocomplete =
       sel.GetMax() < GetTextLength() || textfield_->IsIMEComposing();
 
-  model_->StartAutocomplete(!sel.is_empty(), no_inline_autocomplete);
-}
-
-void OmniboxViewViews::ClosePopup() {
-  model_->StopAutocomplete();
+  model()->StartAutocomplete(!sel.is_empty(), no_inline_autocomplete);
 }
 
 void OmniboxViewViews::SetFocus() {
   // In views-implementation, the focus is on textfield rather than OmniboxView.
   textfield_->RequestFocus();
 }
 
 void OmniboxViewViews::OnTemporaryTextMaybeChanged(
     const string16& display_text,
     bool save_original_selection) {
@@ skipping 40 matching lines @@
 
   // 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
   // sure the caret, which should be after any insertion, hasn't moved
   // forward of the old selection start.)
   const bool just_deleted_text =
       (text_before_change_.length() > new_text.length()) &&
       (new_sel.start() <= sel_before_change_.GetMin());
 
-  const bool something_changed = model_->OnAfterPossibleChange(
+  const bool something_changed = model()->OnAfterPossibleChange(
       text_before_change_, new_text, new_sel.start(), new_sel.end(),
       selection_differs, text_changed, just_deleted_text,
       !textfield_->IsIMEComposing());
 
-  // If only selection was changed, we don't need to call |model_|'s
+  // If only selection was changed, we don't need to call |model()|'s

[Peter Kasting, 2012/07/26 23:03:24]

Nit: Another case of |model()|

[dominich, 2012/07/27 20:33:54]

Done.

   // OnChanged() method, which is called in TextChanged().
   // But we still need to call EmphasizeURLComponents() to make sure the text
   // attributes are updated correctly.
   if (something_changed && text_changed)
     TextChanged();
   else if (selection_differs)
     EmphasizeURLComponents();
   else if (delete_at_end_pressed_)
-    model_->OnChanged();
+    model()->OnChanged();
 
   return something_changed;
 }
 
 gfx::NativeView OmniboxViewViews::GetNativeView() const {
   return GetWidget()->GetNativeView();
 }
 
 gfx::NativeView OmniboxViewViews::GetRelativeWindowForPopup() const {
   return GetWidget()->GetTopLevelWidget()->GetNativeView();
 }
 
-CommandUpdater* OmniboxViewViews::GetCommandUpdater() {
-  return command_updater_;
-}
-
 void OmniboxViewViews::SetInstantSuggestion(const string16& input,
                                             bool animate_to_complete) {
 #if defined(OS_WIN) || defined(USE_AURA)
   location_bar_view_->SetInstantSuggestion(input, animate_to_complete);
 #endif
 }
 
 string16 OmniboxViewViews::GetInstantSuggestion() const {
 #if defined(OS_WIN) || defined(USE_AURA)
   return location_bar_view_->GetInstantSuggestion();
@@ skipping 32 matching lines @@
 void OmniboxViewViews::ContentsChanged(views::Textfield* sender,
                                        const string16& new_contents) {
 }
 
 bool OmniboxViewViews::HandleKeyEvent(views::Textfield* textfield,
                                       const views::KeyEvent& event) {
   delete_at_end_pressed_ = false;
 
   if (event.key_code() == ui::VKEY_BACK) {
     // Checks if it's currently in keyword search mode.
-    if (model_->is_keyword_hint() || model_->keyword().empty())
+    if (model()->is_keyword_hint() || model()->keyword().empty())
       return false;
     // If there is selection, let textfield handle the backspace.
     if (textfield_->HasSelection())
       return false;
     // If not at the begining of the text, let textfield handle the backspace.
     if (textfield_->GetCursorPosition())
       return false;
-    model_->ClearKeyword(GetText());
+    model()->ClearKeyword(GetText());
     return true;
   }
 
   if (event.key_code() == ui::VKEY_DELETE && !event.IsAltDown()) {
     delete_at_end_pressed_ =
         (!textfield_->HasSelection() &&
          textfield_->GetCursorPosition() == textfield_->text().length());
   }
 
   return false;
 }
 
 void OmniboxViewViews::OnBeforeUserAction(views::Textfield* sender) {
   OnBeforePossibleChange();
 }
 
 void OmniboxViewViews::OnAfterUserAction(views::Textfield* sender) {
   OnAfterPossibleChange();
 }
 
 void OmniboxViewViews::OnAfterCutOrCopy() {
   ui::Range selection_range;
   textfield_->GetSelectedRange(&selection_range);
   ui::Clipboard* cb = views::ViewsDelegate::views_delegate->GetClipboard();
   string16 selected_text;
   cb->ReadText(ui::Clipboard::BUFFER_STANDARD, &selected_text);
   const string16 text = textfield_->text();
   GURL url;
   bool write_url;
-  model_->AdjustTextForCopy(selection_range.GetMin(), selected_text == text,
+  model()->AdjustTextForCopy(selection_range.GetMin(), selected_text == text,
       &selected_text, &url, &write_url);
   ui::ScopedClipboardWriter scw(cb, ui::Clipboard::BUFFER_STANDARD);
   scw.WriteText(selected_text);
   if (write_url) {
     BookmarkNodeData data;
     data.ReadFromTuple(url, text);
     data.WriteToClipboard(NULL);
   }
 }
 
 void OmniboxViewViews::OnWriteDragData(ui::OSExchangeData* data) {
   ui::Range selection_range;
   textfield_->GetSelectedRange(&selection_range);
   string16 selected_text = textfield_->GetSelectedText();
   const string16 text = textfield_->text();
   GURL url;
   bool write_url;
-  model_->AdjustTextForCopy(selection_range.start(), selected_text == text,
+  model()->AdjustTextForCopy(selection_range.start(), selected_text == text,
       &selected_text, &url, &write_url);
   data->SetString(selected_text);
   if (write_url)
     data->SetURL(url, selected_text);
 }
 
 void OmniboxViewViews::UpdateContextMenu(ui::SimpleMenuModel* menu_contents) {
   // Minor note: We use IDC_ for command id here while the underlying textfield
   // is using IDS_ for all its command ids. This is because views cannot depend
   // on IDC_ for now.
   menu_contents->AddItemWithStringId(IDC_EDIT_SEARCH_ENGINES,
       IDS_EDIT_SEARCH_ENGINES);
 
   int paste_position = menu_contents->GetIndexOfCommandId(IDS_APP_PASTE);
   if (paste_position >= 0)
     menu_contents->InsertItemWithStringIdAt(
         paste_position + 1, IDS_PASTE_AND_GO, IDS_PASTE_AND_GO);
 }
 
 bool OmniboxViewViews::IsCommandIdEnabled(int command_id) const {
   return (command_id == IDS_PASTE_AND_GO) ?
-      model_->CanPasteAndGo(GetClipboardText()) :
-      command_updater_->IsCommandEnabled(command_id);
+      model()->CanPasteAndGo(GetClipboardText()) :
+      command_updater()->IsCommandEnabled(command_id);
 }
 
 bool OmniboxViewViews::IsItemForCommandIdDynamic(int command_id) const {
   return command_id == IDS_PASTE_AND_GO;
 }
 
 string16 OmniboxViewViews::GetLabelForCommandId(int command_id) const {
   if (command_id == IDS_PASTE_AND_GO) {
     return l10n_util::GetStringUTF16(
-        model_->IsPasteAndSearch(GetClipboardText()) ?
+        model()->IsPasteAndSearch(GetClipboardText()) ?
         IDS_PASTE_AND_SEARCH : IDS_PASTE_AND_GO);
   }
 
   return string16();
 }
 
 void OmniboxViewViews::ExecuteCommand(int command_id) {
   if (command_id == IDS_PASTE_AND_GO) {
-    model_->PasteAndGo(GetClipboardText());
+    model()->PasteAndGo(GetClipboardText());
     return;
   }
 
-  command_updater_->ExecuteCommand(command_id);
+  command_updater()->ExecuteCommand(command_id);
 }
 
 #if defined(OS_CHROMEOS)
 void OmniboxViewViews::CandidateWindowOpened(
       chromeos::input_method::InputMethodManager* manager) {
   ime_candidate_window_open_ = true;
   ClosePopup();
 }
 
 void OmniboxViewViews::CandidateWindowClosed(
       chromeos::input_method::InputMethodManager* manager) {
   ime_candidate_window_open_ = false;
   UpdatePopup();
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxViewViews, private:
 
 size_t OmniboxViewViews::GetTextLength() const {
   // TODO(oshima): Support instant, IME.
   return textfield_->text().length();
 }
 
+int OmniboxViewViews::GetOmniboxTextLength() const {
+  return static_cast<int>(GetTextLength());
+}
+
 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.
   string16 text = GetText();
   url_parse::Component scheme, host;
-  AutocompleteInput::ParseForEmphasizeComponents(text, model_->GetDesiredTLD(),
+  AutocompleteInput::ParseForEmphasizeComponents(text, model()->GetDesiredTLD(),
                                                  &scheme, &host);
-  const bool emphasize = model_->CurrentTextIsURL() && (host.len > 0);
+  const bool emphasize = model()->CurrentTextIsURL() && (host.len > 0);
 
   SkColor base_color = LocationBarView::GetColor(
       security_level_,
       emphasize ? LocationBarView::DEEMPHASIZED_TEXT : LocationBarView::TEXT);
   ApplyURLStyle(textfield_, 0, text.length(), base_color, false);
 
   if (emphasize) {
     SkColor normal_color =
         LocationBarView::GetColor(security_level_, LocationBarView::TEXT);
     ApplyURLStyle(textfield_, host.begin, host.end(), normal_color, false);
   }
 
   // Emphasize the scheme for security UI display purposes (if necessary).
-  if (!model_->user_input_in_progress() && scheme.is_nonempty() &&
+  if (!model()->user_input_in_progress() && scheme.is_nonempty() &&
       (security_level_ != ToolbarModel::NONE)) {
     SkColor security_color = LocationBarView::GetColor(
         security_level_, LocationBarView::SECURITY_TEXT);
     bool use_strikethrough = (security_level_ == ToolbarModel::SECURITY_ERROR);
     ApplyURLStyle(textfield_, scheme.begin, scheme.end(),
                   security_color, use_strikethrough);
   }
 }
 
-void OmniboxViewViews::TextChanged() {
-  EmphasizeURLComponents();
-  model_->OnChanged();
-}
-
 void OmniboxViewViews::SetTextAndSelectedRange(const string16& text,
                                                const ui::Range& range) {
   if (text != GetText())
     textfield_->SetText(text);
   textfield_->SelectRange(range);
 }
 
 string16 OmniboxViewViews::GetSelectedText() const {
   // TODO(oshima): Support instant, IME.
   return textfield_->GetSelectedText();
 }