Moving common code into OmniboxView from OmniboxView*

chrome/browser/ui/gtk/omnibox/omnibox_view_gtk.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/gtk/omnibox/omnibox_view_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include <algorithm>
@@ skipping 142 matching lines @@
 }
 
 }  // namespace
 
 OmniboxViewGtk::OmniboxViewGtk(OmniboxEditController* controller,
                                ToolbarModel* toolbar_model,
                                Browser* browser,
                                CommandUpdater* command_updater,
                                bool popup_window_mode,
                                GtkWidget* location_bar)
-    : browser_(browser),
+    : OmniboxView(browser->profile(), controller, toolbar_model,
+                  command_updater),
+      browser_(browser),
       text_view_(NULL),
       tag_table_(NULL),
       text_buffer_(NULL),
       faded_text_tag_(NULL),
       secure_scheme_tag_(NULL),
       security_error_scheme_tag_(NULL),
       normal_text_tag_(NULL),
       instant_anchor_tag_(NULL),
       instant_view_(NULL),
       instant_mark_(NULL),
-      model_(new OmniboxEditModel(this, controller, browser->profile())),
-      controller_(controller),
-      toolbar_model_(toolbar_model),
-      command_updater_(command_updater),
       popup_window_mode_(popup_window_mode),
       security_level_(ToolbarModel::NONE),
       mark_set_handler_id_(0),
       button_1_pressed_(false),
       theme_service_(GtkThemeService::GetFrom(browser->profile())),
       enter_was_pressed_(false),
       tab_was_pressed_(false),
       paste_clipboard_requested_(false),
       enter_was_inserted_(false),
       selection_suggested_(false),
       delete_was_pressed_(false),
       delete_at_end_pressed_(false),
       handling_key_press_(false),
       content_maybe_changed_by_key_press_(false),
       update_popup_without_focus_(false),
       supports_pre_edit_(!gtk_check_version(2, 20, 0)),
       pre_edit_size_before_change_(0),
       going_to_focus_(NULL) {
   popup_view_.reset(
       new OmniboxPopupViewGtk
-          (GetFont(), this, model_.get(), location_bar));
+          (GetFont(), this, model(), location_bar));
 }
 
 OmniboxViewGtk::~OmniboxViewGtk() {
   // 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();
 
   // We own our widget and TextView related objects.
   if (alignment_.get()) {  // Init() has been called.
     alignment_.Destroy();
     g_object_unref(text_buffer_);
     g_object_unref(tag_table_);
     // The tags we created are owned by the tag_table, and should be destroyed
     // along with it.  We don't hold our own reference to them.
   }
 }
@@ skipping 199 matching lines @@
 void OmniboxViewGtk::SetFocus() {
   DCHECK(text_view_);
   gtk_widget_grab_focus(text_view_);
 }
 
 int OmniboxViewGtk::WidthOfTextAfterCursor() {
   // Not used.
   return -1;
 }
 
-OmniboxEditModel* OmniboxViewGtk::model() {
-  return model_.get();
-}
-
-const OmniboxEditModel* OmniboxViewGtk::model() const {
-  return model_.get();
-}
-
 void OmniboxViewGtk::SaveStateToTab(WebContents* tab) {
   DCHECK(tab);
   // If any text has been selected, register it as the PRIMARY selection so it
   // can still be pasted via middle-click after the text view is cleared.
   if (!selected_text_.empty())
     SavePrimarySelection(selected_text_);
   // NOTE: GetStateForTabSwitch may affect GetSelection, so order is important.
-  OmniboxEditModel::State model_state = model_->GetStateForTabSwitch();
+  OmniboxEditModel::State model_state = model()->GetStateForTabSwitch();
   GetStateAccessor()->SetProperty(
       tab->GetPropertyBag(),
       AutocompleteEditState(model_state, ViewState(GetSelection())));
 }
 
 void OmniboxViewGtk::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;
 
   if (contents) {
     selected_text_.clear();
     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).
       StartUpdatingHighlightedText();
       SetSelectedRange(state->view_state.selection_range);
       FinishUpdatingHighlightedText();
     }
   } else if (visibly_changed_permanent_text) {
     RevertAll();
     // TODO(deanm): There should be code to restore select all here.
   } else if (changed_security_level) {
     EmphasizeURLComponents();
   }
 }
 
-void OmniboxViewGtk::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 OmniboxViewGtk::GetText() const {
   GtkTextIter start, end;
   GetTextBufferBounds(&start, &end);
   gchar* utf8 = gtk_text_buffer_get_text(text_buffer_, &start, &end, false);
   string16 out(UTF8ToUTF16(utf8));
   g_free(utf8);
 
   if (supports_pre_edit_) {
     // We need to treat the text currently being composed by the input method
     // as part of the text content, so that omnibox can work correctly in the
     // middle of composition.
     if (pre_edit_.size()) {
       GtkTextMark* mark = gtk_text_buffer_get_insert(text_buffer_);
       gtk_text_buffer_get_iter_at_mark(text_buffer_, &start, mark);
       out.insert(gtk_text_iter_get_offset(&start), pre_edit_);
     }
   }
   return out;
 }
 
-bool OmniboxViewGtk::IsEditingOrEmpty() const {
-  return model_->user_input_in_progress() || (GetTextLength() == 0);
-}
-
-int OmniboxViewGtk::GetIcon() const {
-  return IsEditingOrEmpty() ?
-      AutocompleteMatch::TypeToIcon(model_->CurrentTextType()) :
-      toolbar_model_->GetIcon();
-}
-
-void OmniboxViewGtk::SetUserText(const string16& text) {
-  SetUserText(text, text, true);
-}
-
-void OmniboxViewGtk::SetUserText(const string16& text,
-                                 const string16& display_text,
-                                 bool update_popup) {
-  model_->SetUserText(text);
-  // TODO(deanm): something about selection / focus change here.
-  SetWindowTextAndCaretPos(display_text, display_text.length(), update_popup,
-      true);
-}
-
 void OmniboxViewGtk::SetWindowTextAndCaretPos(const string16& text,
                                               size_t caret_pos,
                                               bool update_popup,
                                               bool notify_text_changed) {
   CharRange range(static_cast<int>(caret_pos), static_cast<int>(caret_pos));
   SetTextAndSelectedRange(text, range);
 
   if (update_popup)
     UpdatePopup();
 
@@ skipping 36 matching lines @@
   *end = static_cast<size_t>(selection.cp_max);
 }
 
 void OmniboxViewGtk::SelectAll(bool reversed) {
   // SelectAll() is invoked as a side effect of other actions (e.g.  switching
   // tabs or hitting Escape) in autocomplete_edit.cc, so we don't update the
   // PRIMARY selection here.
   SelectAllInternal(reversed, false);
 }
 
-void OmniboxViewGtk::RevertAll() {
-  ClosePopup();
-  model_->Revert();
-  TextChanged();
-}
-
 void OmniboxViewGtk::UpdatePopup() {
-  model_->SetInputInProgress(true);
-  if (!update_popup_without_focus_ && !model_->has_focus())
+  model()->SetInputInProgress(true);
+  if (!update_popup_without_focus_ && !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.
   CharRange sel = GetSelection();
   bool no_inline_autocomplete =
-      std::max(sel.cp_max, sel.cp_min) < GetTextLength() || IsImeComposing();
-  model_->StartAutocomplete(sel.cp_min != sel.cp_max, no_inline_autocomplete);
-}
-
-void OmniboxViewGtk::ClosePopup() {
-  model_->StopAutocomplete();
+      std::max(sel.cp_max, sel.cp_min) < GetOmniboxTextLength() ||
+      IsImeComposing();
+  model()->StartAutocomplete(sel.cp_min != sel.cp_max, no_inline_autocomplete);
 }
 
 void OmniboxViewGtk::OnTemporaryTextMaybeChanged(
     const string16& display_text,
     bool save_original_selection) {
   if (save_original_selection)
     saved_temporary_selection_ = GetSelection();
 
   StartUpdatingHighlightedText();
   SetWindowTextAndCaretPos(display_text, display_text.length(), false, false);
@@ skipping 19 matching lines @@
   StartUpdatingHighlightedText();
   SetSelectedRange(saved_temporary_selection_);
   FinishUpdatingHighlightedText();
   TextChanged();
 }
 
 void OmniboxViewGtk::OnBeforePossibleChange() {
   // Record this paste, so we can do different behavior.
   if (paste_clipboard_requested_) {
     paste_clipboard_requested_ = false;
-    model_->on_paste();
+    model()->on_paste();
   }
 
   // This method will be called in HandleKeyPress() method just before
   // handling a key press event. So we should prevent it from being called
   // when handling the key press event.
   if (handling_key_press_)
     return;
 
   // Record our state.
   text_before_change_ = GetText();
@@ skipping 17 matching lines @@
   // {Start|Finish}UpdatingHighlightedText() are called here to prevent the
   // PRIMARY selection from being changed.
   if (enter_was_pressed_ && enter_was_inserted_) {
     StartUpdatingHighlightedText();
     SetTextAndSelectedRange(text_before_change_, sel_before_change_);
     FinishUpdatingHighlightedText();
     return false;
   }
 
   const CharRange new_sel = GetSelection();
-  const int length = GetTextLength();
+  const int length = GetOmniboxTextLength();
   const bool selection_differs =
       ((new_sel.cp_min != new_sel.cp_max) ||
        (sel_before_change_.cp_min != sel_before_change_.cp_max)) &&
       ((new_sel.cp_min != sel_before_change_.cp_min) ||
        (new_sel.cp_max != sel_before_change_.cp_max));
   const bool at_end_of_edit =
       (new_sel.cp_min == length && new_sel.cp_max == length);
 
   // See if the text or selection have changed since OnBeforePossibleChange().
   const string16 new_text(GetText());
   text_changed_ = (new_text != text_before_change_) || (supports_pre_edit_ &&
       (pre_edit_.size() != pre_edit_size_before_change_));
 
   if (text_changed_)
     AdjustTextJustification();
 
   // 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.cp_min <= std::min(sel_before_change_.cp_min,
                                  sel_before_change_.cp_max));
 
   delete_at_end_pressed_ = false;
 
-  const bool something_changed = model_->OnAfterPossibleChange(
+  const bool something_changed = model()->OnAfterPossibleChange(
       text_before_change_, new_text, new_sel.selection_min(),
       new_sel.selection_max(), selection_differs, text_changed_,
       just_deleted_text, !IsImeComposing());
 
-  // If only selection was changed, we don't need to call |controller_|'s
+  // If only selection was changed, we don't need to call the controller's
   // 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_was_pressed_ && at_end_of_edit) {
     delete_at_end_pressed_ = true;
-    model_->OnChanged();
+    model()->OnChanged();
   }
   delete_was_pressed_ = false;
 
   return something_changed;
 }
 
 gfx::NativeView OmniboxViewGtk::GetNativeView() const {
   return alignment_.get();
 }
 
 gfx::NativeView OmniboxViewGtk::GetRelativeWindowForPopup() const {
   GtkWidget* toplevel = gtk_widget_get_toplevel(GetNativeView());
   DCHECK(gtk_widget_is_toplevel(toplevel));
   return toplevel;
 }
 
-CommandUpdater* OmniboxViewGtk::GetCommandUpdater() {
-  return command_updater_;
-}
-
 void OmniboxViewGtk::SetInstantSuggestion(const string16& suggestion,
                                           bool animate_to_complete) {
   std::string suggestion_utf8 = UTF16ToUTF8(suggestion);
 
   gtk_label_set_text(GTK_LABEL(instant_view_), suggestion_utf8.c_str());
 
   StopAnimation();
 
   if (suggestion.empty()) {
     gtk_widget_hide(instant_view_);
@@ skipping 68 matching lines @@
 
 void OmniboxViewGtk::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED);
 
   SetBaseColor();
 }
 
 void OmniboxViewGtk::AnimationEnded(const ui::Animation* animation) {
-  model_->CommitSuggestedText(false);
+  model()->CommitSuggestedText(false);
 }
 
 void OmniboxViewGtk::AnimationProgressed(const ui::Animation* animation) {
   UpdateInstantViewColors();
 }
 
 void OmniboxViewGtk::AnimationCanceled(const ui::Animation* animation) {
   UpdateInstantViewColors();
 }
 
@@ skipping 211 matching lines @@
   handling_key_press_ = false;
   if (content_maybe_changed_by_key_press_)
     OnAfterPossibleChange();
 
   // Set |tab_was_pressed_| to false, to make sure Tab to search behavior can
   // only be triggered by pressing Tab key.
   tab_was_pressed_ = false;
 
   if (enter_was_pressed_ && enter_was_inserted_) {
     bool alt_held = (event->state & GDK_MOD1_MASK);
-    model_->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
+    model()->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
     result = TRUE;
   } else if (!result && event->keyval == GDK_Escape &&
              (event->state & gtk_accelerator_get_default_mod_mask()) == 0) {
     // We can handle the Escape key if |text_view_| 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.
-    result = model_->OnEscapeKeyPressed();
+    result = model()->OnEscapeKeyPressed();
   } else if (event->keyval == GDK_Control_L || event->keyval == GDK_Control_R) {
     // 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 (!text_changed_ && event->keyval == GDK_Delete &&
              event->state & GDK_SHIFT_MASK) {
     // 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();
   }
 
   // Set |enter_was_pressed_| to false, to make sure OnAfterPossibleChange() can
   // act as normal for changes made by other events.
   enter_was_pressed_ = false;
 
   // If the key event is not handled by |text_view_| or us, then we need to
   // propagate the key event up to parent widgets by returning FALSE.
   // In this case we need to stop the signal emission explicitly to prevent the
   // default "key-press-event" handler of |text_view_| from being called again.
@@ skipping 11 matching lines @@
   // 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->keyval == GDK_Control_L || event->keyval == GDK_Control_R) {
     // Round trip to query the control state after the release.  This allows
     // you to release one control key while still holding another control key.
     GdkDisplay* display = gdk_window_get_display(event->window);
     GdkModifierType mod;
     gdk_display_get_pointer(display, NULL, NULL, NULL, &mod);
     if (!(mod & GDK_CONTROL_MASK))
-      model_->OnControlKeyChanged(false);
+      model()->OnControlKeyChanged(false);
   }
 
   // Even though we handled the press ourselves, let GtkTextView handle the
   // release.  It shouldn't do anything particularly interesting, but it will
   // handle the IME work for us.
   return FALSE;  // Propagate into GtkTextView.
 }
 
 gboolean OmniboxViewGtk::HandleViewButtonPress(GtkWidget* sender,
                                                GdkEventButton* event) {
   // We don't need to care about double and triple clicks.
   if (event->type != GDK_BUTTON_PRESS)
     return FALSE;
 
   DCHECK(text_view_);
 
   if (event->button == 1) {
     button_1_pressed_ = true;
 
     // Button press event may change the selection, we need to record the change
-    // and report it to |model_| later when button is released.
+    // and report it to model() later when button is released.
     OnBeforePossibleChange();
   } else if (event->button == 2) {
     // GtkTextView pastes PRIMARY selection with middle click.
-    // We can't call model_->on_paste_replacing_all() here, because the actual
+    // We can't call model()->on_paste_replacing_all() here, because the actual
     // paste clipboard action may not be performed if the clipboard is empty.
     paste_clipboard_requested_ = true;
   }
   return FALSE;
 }
 
 gboolean OmniboxViewGtk::HandleViewButtonRelease(GtkWidget* sender,
                                                  GdkEventButton* event) {
   if (event->button != 1)
     return FALSE;
 
   bool button_1_was_pressed = button_1_pressed_;
   button_1_pressed_ = false;
 
   DCHECK(text_view_);
 
   // Call the GtkTextView default handler, ignoring the fact that it will
   // likely have told us to stop propagating.  We want to handle selection.
   GtkWidgetClass* klass = GTK_WIDGET_GET_CLASS(text_view_);
   klass->button_release_event(text_view_, event);
 
-  // Inform |model_| about possible text selection change. We may get a button
+  // Inform model() about possible text selection change. We may get a button
   // release with no press (e.g. if the user clicks in the omnibox to dismiss a
   // bubble).
   if (button_1_was_pressed)
     OnAfterPossibleChange();
 
   return TRUE;  // Don't continue, we called the default handler already.
 }
 
 gboolean OmniboxViewGtk::HandleViewFocusIn(GtkWidget* sender,
                                            GdkEventFocus* event) {
   DCHECK(text_view_);
   update_popup_without_focus_ = false;
 
   GdkModifierType modifiers;
   GdkWindow* gdk_window = gtk_widget_get_window(text_view_);
   gdk_window_get_pointer(gdk_window, NULL, NULL, &modifiers);
-  model_->OnSetFocus((modifiers & GDK_CONTROL_MASK) != 0);
-  controller_->OnSetFocus();
+  model()->OnSetFocus((modifiers & GDK_CONTROL_MASK) != 0);
+  controller()->OnSetFocus();
   // TODO(deanm): Some keyword hit business, etc here.
 
   g_signal_connect(
       gdk_keymap_get_for_display(gtk_widget_get_display(text_view_)),
       "direction-changed",
       G_CALLBACK(&HandleKeymapDirectionChangedThunk), this);
 
   AdjustTextJustification();
 
   return FALSE;  // Continue propagation.
 }
 
 gboolean OmniboxViewGtk::HandleViewFocusOut(GtkWidget* sender,
                                             GdkEventFocus* event) {
   DCHECK(text_view_);
   GtkWidget* view_getting_focus = NULL;
   GtkWindow* toplevel = platform_util::GetTopLevel(sender);
   if (gtk_window_is_active(toplevel))
     view_getting_focus = going_to_focus_;
 
   // This must be invoked before ClosePopup.
-  model_->OnWillKillFocus(view_getting_focus);
+  model()->OnWillKillFocus(view_getting_focus);
 
   // Close the popup.
-  ClosePopup();
+  CloseOmniboxPopup();
   // Tell the model to reset itself.
-  model_->OnKillFocus();
-  controller_->OnKillFocus();
+  model()->OnKillFocus();
+  controller()->OnKillFocus();
 
   g_signal_handlers_disconnect_by_func(
       gdk_keymap_get_for_display(gtk_widget_get_display(text_view_)),
       reinterpret_cast<gpointer>(&HandleKeymapDirectionChangedThunk), this);
 
   return FALSE;  // Pass the event on to the GtkTextView.
 }
 
 void OmniboxViewGtk::HandleViewMoveCursor(
     GtkWidget* sender,
@@ skipping 16 matching lines @@
     PangoDirection content_dir = GetContentDirection();
     gint count_towards_end = content_dir == PANGO_DIRECTION_RTL ? -1 : 1;
 
     // We want the GtkEntry behavior when you move the cursor while you have a
     // selection.  GtkTextView just drops the selection and moves the cursor,
     // but instead we want to move the cursor to the appropiate end of the
     // selection.
     if (has_selection) {
       // We have a selection and start / end are in ascending order.
       // Cursor placement will remove the selection, so we need inform
-      // |model_| about this change by
+      // model() about this change by
       // calling On{Before|After}PossibleChange() methods.
       OnBeforePossibleChange();
       gtk_text_buffer_place_cursor(
           text_buffer_, count == count_towards_end ? &sel_end : &sel_start);
       OnAfterPossibleChange();
       handled = true;
     } else if (count == count_towards_end && !IsCaretAtEnd()) {
-      handled = model_->CommitSuggestedText(true);
+      handled = model()->CommitSuggestedText(true);
     }
   } else if (step == GTK_MOVEMENT_PAGES) {  // Page up and down.
     // Multiply by count for the direction (if we move too much that's ok).
-    model_->OnUpOrDownKeyPressed(model_->result().size() * count);
+    model()->OnUpOrDownKeyPressed(model()->result().size() * count);
     handled = true;
   } else if (step == GTK_MOVEMENT_DISPLAY_LINES) {  // Arrow up and down.
-    model_->OnUpOrDownKeyPressed(count);
+    model()->OnUpOrDownKeyPressed(count);
     handled = true;
   }
 
   if (!handled) {
     // Cursor movement may change the selection, we need to record the change
-    // and report it to |model_|.
+    // and report it to model().
     if (has_selection || extend_selection)
       OnBeforePossibleChange();
 
     // Propagate into GtkTextView
     GtkTextViewClass* klass = GTK_TEXT_VIEW_GET_CLASS(text_view_);
     klass->move_cursor(GTK_TEXT_VIEW(text_view_), step, count,
                        extend_selection);
 
     if (has_selection || extend_selection)
       OnAfterPossibleChange();
@@ skipping 10 matching lines @@
   // Don't force a minimum width, but use the font-relative height.  This is a
   // run-first handler, so the default handler was already called.
   req->width = 1;
 }
 
 void OmniboxViewGtk::HandlePopupMenuDeactivate(GtkWidget* sender) {
   // When the context menu appears, |text_view_|'s focus is lost. After an item
   // is activated, the focus comes back to |text_view_|, but only after the
   // check in UpdatePopup(). We set this flag to make UpdatePopup() aware that
   // it will be receiving focus again.
-  if (!model_->has_focus())
+  if (!model()->has_focus())
     update_popup_without_focus_ = true;
 }
 
 void OmniboxViewGtk::HandlePopulatePopup(GtkWidget* sender, GtkMenu* menu) {
   GtkWidget* separator = gtk_separator_menu_item_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), separator);
   gtk_widget_show(separator);
 
   // Search Engine menu item.
   GtkWidget* search_engine_menuitem = gtk_menu_item_new_with_mnemonic(
       ui::ConvertAcceleratorsFromWindowsStyle(
           l10n_util::GetStringUTF8(IDS_EDIT_SEARCH_ENGINES)).c_str());
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), search_engine_menuitem);
   g_signal_connect(search_engine_menuitem, "activate",
                    G_CALLBACK(HandleEditSearchEnginesThunk), this);
   gtk_widget_set_sensitive(search_engine_menuitem,
-      command_updater_->IsCommandEnabled(IDC_EDIT_SEARCH_ENGINES));
+      command_updater()->IsCommandEnabled(IDC_EDIT_SEARCH_ENGINES));
   gtk_widget_show(search_engine_menuitem);
 
   // Detect the Paste menu item by searching for the one that
   // uses the stock Paste label (i.e. gtk-paste).
   string16 stock_paste_label(UTF8ToUTF16(GTK_STOCK_PASTE));
   GList* list = gtk_container_get_children(GTK_CONTAINER(menu));
   guint index = 1;
   for (GList* item = list; item != NULL; item = item->next, ++index) {
     if (GTK_IS_IMAGE_MENU_ITEM(item->data)) {
       gboolean is_stock = gtk_image_menu_item_get_use_stock(
@@ skipping 12 matching lines @@
   // If we don't find the stock Paste menu item,
   // the Paste and Go item will be appended at the end of the popup menu.
   GtkClipboard* x_clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
   gchar* text = gtk_clipboard_wait_for_text(x_clipboard);
   sanitized_text_for_paste_and_go_ = text ?
       StripJavascriptSchemas(CollapseWhitespace(UTF8ToUTF16(text), true)) :
       string16();
   g_free(text);
   GtkWidget* paste_go_menuitem = gtk_menu_item_new_with_mnemonic(
       ui::ConvertAcceleratorsFromWindowsStyle(l10n_util::GetStringUTF8(
-          model_->IsPasteAndSearch(sanitized_text_for_paste_and_go_) ?
+          model()->IsPasteAndSearch(sanitized_text_for_paste_and_go_) ?
               IDS_PASTE_AND_SEARCH : IDS_PASTE_AND_GO)).c_str());
   gtk_menu_shell_insert(GTK_MENU_SHELL(menu), paste_go_menuitem, index);
   g_signal_connect(paste_go_menuitem, "activate",
                    G_CALLBACK(HandlePasteAndGoThunk), this);
   gtk_widget_set_sensitive(paste_go_menuitem,
-      model_->CanPasteAndGo(sanitized_text_for_paste_and_go_));
+      model()->CanPasteAndGo(sanitized_text_for_paste_and_go_));
   gtk_widget_show(paste_go_menuitem);
 
   g_signal_connect(menu, "deactivate",
                    G_CALLBACK(HandlePopupMenuDeactivateThunk), this);
 }
 
 void OmniboxViewGtk::HandleEditSearchEngines(GtkWidget* sender) {
-  command_updater_->ExecuteCommand(IDC_EDIT_SEARCH_ENGINES);
+  command_updater()->ExecuteCommand(IDC_EDIT_SEARCH_ENGINES);
 }
 
 void OmniboxViewGtk::HandlePasteAndGo(GtkWidget* sender) {
-  model_->PasteAndGo(sanitized_text_for_paste_and_go_);
+  model()->PasteAndGo(sanitized_text_for_paste_and_go_);
 }
 
 void OmniboxViewGtk::HandleMarkSet(GtkTextBuffer* buffer,
                                    GtkTextIter* location,
                                    GtkTextMark* mark) {
   if (!text_buffer_ || buffer != text_buffer_)
     return;
 
   if (mark != gtk_text_buffer_get_insert(text_buffer_) &&
       mark != gtk_text_buffer_get_selection_bound(text_buffer_)) {
@@ skipping 109 matching lines @@
                                        GdkDragContext* context) {
   string16 text = UTF8ToUTF16(GetSelectedText());
 
   if (text.empty())
     return;
 
   // Use AdjustTextForCopy to make sure we prefix the text with 'http://'.
   CharRange selection = GetSelection();
   GURL url;
   bool write_url;
-  model_->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
+  model()->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
                             &url, &write_url);
   if (write_url) {
     selected_text_ = UTF16ToUTF8(text);
     GtkTargetList* copy_targets =
         gtk_text_buffer_get_copy_target_list(text_buffer_);
     gtk_target_list_add(copy_targets,
                         ui::GetAtomForTarget(ui::CHROME_NAMED_URL),
                         GTK_TARGET_SAME_APP, ui::CHROME_NAMED_URL);
   }
   dragged_text_ = selected_text_;
@@ skipping 31 matching lines @@
     gunichar c = g_utf8_get_char(p);
 
     // 0x200B is Zero Width Space, which is inserted just before the instant
     // anchor for working around the GtkTextView's misalignment bug.
     // This character might be captured and inserted into the content by undo
     // manager, so we need to filter it out here.
     if (c != 0x200B)
       base::WriteUnicodeCharacter(c, &filtered_text);
   }
 
-  if (model_->is_pasting())
+  if (model()->is_pasting())
     filtered_text = StripJavascriptSchemas(
         CollapseWhitespace(filtered_text, true));
 
   if (!filtered_text.empty()) {
     // Avoid inserting the text after the instant anchor.
     ValidateTextBufferIter(location);
 
     // Call the default handler to insert filtered text.
     GtkTextBufferClass* klass = GTK_TEXT_BUFFER_GET_CLASS(buffer);
     std::string utf8_text = UTF16ToUTF8(filtered_text);
     klass->insert_text(buffer, location, utf8_text.data(),
                        static_cast<gint>(utf8_text.length()));
   }
 
   // Stop propagating the signal emission to prevent the default handler from
   // being called again.
   static guint signal_id = g_signal_lookup("insert-text", GTK_TYPE_TEXT_BUFFER);
   g_signal_stop_emission(buffer, signal_id, 0);
 }
 
 void OmniboxViewGtk::HandleBackSpace(GtkWidget* sender) {
   // 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;  // Propgate into GtkTextView.
 
   DCHECK(text_view_);
 
   GtkTextIter sel_start, sel_end;
   // Checks if there is some text selected.
   if (gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end))
     return;  // Propgate into GtkTextView.
 
   GtkTextIter start;
   gtk_text_buffer_get_start_iter(text_buffer_, &start);
 
   if (!gtk_text_iter_equal(&start, &sel_start))
     return;  // Propgate into GtkTextView.
 
   // We're showing a keyword and the user pressed backspace at the beginning
   // of the text. Delete the selected keyword.
-  model_->ClearKeyword(GetText());
+  model()->ClearKeyword(GetText());
 
   // Stop propagating the signal emission into GtkTextView.
   static guint signal_id = g_signal_lookup("backspace", GTK_TYPE_TEXT_VIEW);
   g_signal_stop_emission(text_view_, signal_id, 0);
 }
 
 void OmniboxViewGtk::HandleViewMoveFocus(GtkWidget* widget,
                                          GtkDirectionType direction) {
   if (!tab_was_pressed_)
     return;
 
   // If special behavior is triggered, then stop the signal emission to
   // prevent the focus from being moved.
   bool handled = false;
 
   // Trigger Tab to search behavior only when Tab key is pressed.
-  if (model_->is_keyword_hint() && !shift_was_pressed_) {
-    handled = model_->AcceptKeyword();
-  } else if (model_->popup_model()->IsOpen()) {
+  if (model()->is_keyword_hint() && !shift_was_pressed_) {
+    handled = model()->AcceptKeyword();
+  } else if (model()->popup_model()->IsOpen()) {
     if (shift_was_pressed_ &&
-        model_->popup_model()->selected_line_state() ==
+        model()->popup_model()->selected_line_state() ==
             OmniboxPopupModel::KEYWORD)
-      model_->ClearKeyword(GetText());
+      model()->ClearKeyword(GetText());
     else
-      model_->OnUpOrDownKeyPressed(shift_was_pressed_ ? -1 : 1);
+      model()->OnUpOrDownKeyPressed(shift_was_pressed_ ? -1 : 1);
 
     handled = true;
   }
 
   if (supports_pre_edit_ && !handled && !pre_edit_.empty())
     handled = true;
 
   if (!handled && gtk_widget_get_visible(instant_view_))
-    handled = model_->CommitSuggestedText(true);
+    handled = model()->CommitSuggestedText(true);
 
   if (!handled)
-    handled = model_->AcceptCurrentInstantPreview();
+    handled = model()->AcceptCurrentInstantPreview();
 
   if (handled) {
     static guint signal_id = g_signal_lookup("move-focus", GTK_TYPE_WIDGET);
     g_signal_stop_emission(widget, signal_id, 0);
   }
 }
 
 void OmniboxViewGtk::HandleCopyClipboard(GtkWidget* sender) {
   HandleCopyOrCutClipboard(true);
 }
@@ skipping 14 matching lines @@
 
   GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
   if (!clipboard)
     return;
 
   CharRange selection = GetSelection();
   GURL url;
   string16 text(UTF8ToUTF16(GetSelectedText()));
   bool write_url;
-  model_->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
+  model()->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
                             &url, &write_url);
 
   if (write_url) {
     BookmarkNodeData data;
     data.ReadFromTuple(url, text);
     data.WriteToClipboard(NULL);
 
     // Stop propagating the signal.
     static guint copy_signal_id =
         g_signal_lookup("copy-clipboard", GTK_TYPE_TEXT_VIEW);
     static guint cut_signal_id =
         g_signal_lookup("cut-clipboard", GTK_TYPE_TEXT_VIEW);
     g_signal_stop_emission(text_view_,
                            copy ? copy_signal_id : cut_signal_id,
                            0);
 
     if (!copy && gtk_text_view_get_editable(GTK_TEXT_VIEW(text_view_)))
       gtk_text_buffer_delete_selection(text_buffer_, true, true);
   }
 
   OwnPrimarySelection(UTF16ToUTF8(text));
 }
 
+int OmniboxViewGtk::GetOmniboxTextLength() const {
+  GtkTextIter end;
+  gtk_text_buffer_get_iter_at_mark(text_buffer_, &end, instant_mark_);
+  if (supports_pre_edit_) {
+    // We need to count the length of the text being composed, because we treat
+    // it as part of the content in GetText().
+    return gtk_text_iter_get_offset(&end) + pre_edit_.size();
+  }
+  return gtk_text_iter_get_offset(&end);
+}
+
+void OmniboxViewGtk::EmphasizeURLComponents() {
+  if (supports_pre_edit_) {
+    // We can't change the text style easily, if the pre-edit string (the text
+    // being composed by the input method) is not empty, which is not treated as
+    // a part of the text content inside GtkTextView. And it's ok to simply
+    // return in this case, as this method will be called again when the
+    // pre-edit string gets committed.
+    if (pre_edit_.size()) {
+      strikethrough_ = CharRange();
+      return;
+    }
+  }
+  // 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;
+  string16 text(GetText());
+  AutocompleteInput::ParseForEmphasizeComponents(
+      text, model()->GetDesiredTLD(), &scheme, &host);
+  const bool emphasize = model()->CurrentTextIsURL() && (host.len > 0);
+
+  // Set the baseline emphasis.
+  GtkTextIter start, end;
+  GetTextBufferBounds(&start, &end);
+  gtk_text_buffer_remove_all_tags(text_buffer_, &start, &end);
+  if (emphasize) {
+    gtk_text_buffer_apply_tag(text_buffer_, faded_text_tag_, &start, &end);
+
+    // We've found a host name, give it more emphasis.
+    gtk_text_buffer_get_iter_at_line_index(text_buffer_, &start, 0,
+                                           GetUTF8Offset(text,
+                                                         host.begin));
+    gtk_text_buffer_get_iter_at_line_index(text_buffer_, &end, 0,
+                                           GetUTF8Offset(text,
+                                                         host.end()));
+
+    gtk_text_buffer_apply_tag(text_buffer_, normal_text_tag_, &start, &end);
+  } else {
+    gtk_text_buffer_apply_tag(text_buffer_, normal_text_tag_, &start, &end);
+  }
+
+  strikethrough_ = CharRange();
+  // Emphasize the scheme for security UI display purposes (if necessary).
+  if (!model()->user_input_in_progress() && scheme.is_nonempty() &&
+      (security_level_ != ToolbarModel::NONE)) {
+    CharRange scheme_range = CharRange(GetUTF8Offset(text, scheme.begin),
+                                       GetUTF8Offset(text, scheme.end()));
+    ItersFromCharRange(scheme_range, &start, &end);
+
+    if (security_level_ == ToolbarModel::SECURITY_ERROR) {
+      strikethrough_ = scheme_range;
+      // When we draw the strikethrough, we don't want to include the ':' at the
+      // end of the scheme.
+      strikethrough_.cp_max--;
+
+      gtk_text_buffer_apply_tag(text_buffer_, security_error_scheme_tag_,
+                                &start, &end);
+    } else if (security_level_ == ToolbarModel::SECURITY_WARNING) {
+      gtk_text_buffer_apply_tag(text_buffer_, faded_text_tag_, &start, &end);
+    } else {
+      gtk_text_buffer_apply_tag(text_buffer_, secure_scheme_tag_, &start, &end);
+    }
+  }
+}
+
 bool OmniboxViewGtk::OnPerformDropImpl(const string16& text) {
   string16 sanitized_string(StripJavascriptSchemas(
       CollapseWhitespace(text, true)));
-  if (model_->CanPasteAndGo(sanitized_string)) {
-    model_->PasteAndGo(sanitized_string);
+  if (model()->CanPasteAndGo(sanitized_string)) {
+    model()->PasteAndGo(sanitized_string);
     return true;
   }
 
   return false;
 }
 
 gfx::Font OmniboxViewGtk::GetFont() {
   bool use_gtk = theme_service_->UsingNativeTheme();
   if (use_gtk) {
     // If we haven't initialized the text view yet, just create a temporary one
@@ skipping 34 matching lines @@
                                entries, len,
                                ClipboardGetSelectionThunk,
                                ClipboardSelectionCleared,
                                G_OBJECT(text_buffer_));
 
   gtk_target_list_unref(list);
   gtk_target_table_free(entries, len);
 }
 
 void OmniboxViewGtk::HandlePasteClipboard(GtkWidget* sender) {
-  // We can't call model_->on_paste_replacing_all() here, because the actual
+  // We can't call model()->on_paste_replacing_all() here, because the actual
   // paste clipboard action may not be performed if the clipboard is empty.
   paste_clipboard_requested_ = true;
 }
 
 gfx::Rect OmniboxViewGtk::WindowBoundsFromIters(GtkTextIter* iter1,
                                                 GtkTextIter* iter2) {
   GdkRectangle start_location, end_location;
   GtkTextView* text_view = GTK_TEXT_VIEW(text_view_);
   gtk_text_view_get_iter_location(text_view, iter1, &start_location);
   gtk_text_view_get_iter_location(text_view, iter2, &end_location);
@@ skipping 116 matching lines @@
 }
 
 void OmniboxViewGtk::ItersFromCharRange(const CharRange& range,
                                         GtkTextIter* iter_min,
                                         GtkTextIter* iter_max) {
   DCHECK(!IsImeComposing());
   gtk_text_buffer_get_iter_at_offset(text_buffer_, iter_min, range.cp_min);
   gtk_text_buffer_get_iter_at_offset(text_buffer_, iter_max, range.cp_max);
 }
 
-int OmniboxViewGtk::GetTextLength() const {
-  GtkTextIter end;
-  gtk_text_buffer_get_iter_at_mark(text_buffer_, &end, instant_mark_);
-  if (supports_pre_edit_) {
-    // We need to count the length of the text being composed, because we treat
-    // it as part of the content in GetText().
-    return gtk_text_iter_get_offset(&end) + pre_edit_.size();
-  }
-  return gtk_text_iter_get_offset(&end);
-}
-
-void OmniboxViewGtk::PlaceCaretAt(int pos) {
-  GtkTextIter cursor;
-  gtk_text_buffer_get_iter_at_offset(text_buffer_, &cursor, pos);
-  gtk_text_buffer_place_cursor(text_buffer_, &cursor);
-}
-
 bool OmniboxViewGtk::IsCaretAtEnd() const {
   const CharRange selection = GetSelection();
   return selection.cp_min == selection.cp_max &&
-      selection.cp_min == GetTextLength();
-}
-
-void OmniboxViewGtk::EmphasizeURLComponents() {
-  if (supports_pre_edit_) {
-    // We can't change the text style easily, if the pre-edit string (the text
-    // being composed by the input method) is not empty, which is not treated as
-    // a part of the text content inside GtkTextView. And it's ok to simply
-    // return in this case, as this method will be called again when the
-    // pre-edit string gets committed.
-    if (pre_edit_.size()) {
-      strikethrough_ = CharRange();
-      return;
-    }
-  }
-  // 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;
-  string16 text(GetText());
-  AutocompleteInput::ParseForEmphasizeComponents(
-      text, model_->GetDesiredTLD(), &scheme, &host);
-  const bool emphasize = model_->CurrentTextIsURL() && (host.len > 0);
-
-  // Set the baseline emphasis.
-  GtkTextIter start, end;
-  GetTextBufferBounds(&start, &end);
-  gtk_text_buffer_remove_all_tags(text_buffer_, &start, &end);
-  if (emphasize) {
-    gtk_text_buffer_apply_tag(text_buffer_, faded_text_tag_, &start, &end);
-
-    // We've found a host name, give it more emphasis.
-    gtk_text_buffer_get_iter_at_line_index(text_buffer_, &start, 0,
-                                           GetUTF8Offset(text,
-                                                         host.begin));
-    gtk_text_buffer_get_iter_at_line_index(text_buffer_, &end, 0,
-                                           GetUTF8Offset(text,
-                                                         host.end()));
-
-    gtk_text_buffer_apply_tag(text_buffer_, normal_text_tag_, &start, &end);
-  } else {
-    gtk_text_buffer_apply_tag(text_buffer_, normal_text_tag_, &start, &end);
-  }
-
-  strikethrough_ = CharRange();
-  // Emphasize the scheme for security UI display purposes (if necessary).
-  if (!model_->user_input_in_progress() && scheme.is_nonempty() &&
-      (security_level_ != ToolbarModel::NONE)) {
-    CharRange scheme_range = CharRange(GetUTF8Offset(text, scheme.begin),
-                                       GetUTF8Offset(text, scheme.end()));
-    ItersFromCharRange(scheme_range, &start, &end);
-
-    if (security_level_ == ToolbarModel::SECURITY_ERROR) {
-      strikethrough_ = scheme_range;
-      // When we draw the strikethrough, we don't want to include the ':' at the
-      // end of the scheme.
-      strikethrough_.cp_max--;
-
-      gtk_text_buffer_apply_tag(text_buffer_, security_error_scheme_tag_,
-                                &start, &end);
-    } else if (security_level_ == ToolbarModel::SECURITY_WARNING) {
-      gtk_text_buffer_apply_tag(text_buffer_, faded_text_tag_, &start, &end);
-    } else {
-      gtk_text_buffer_apply_tag(text_buffer_, secure_scheme_tag_, &start, &end);
-    }
-  }
+      selection.cp_min == GetOmniboxTextLength();
 }
 
 void OmniboxViewGtk::StopAnimation() {
   // Clear the animation delegate so we don't get an AnimationEnded() callback.
   instant_animation_->set_delegate(NULL);
   instant_animation_->Stop();
   UpdateInstantViewColors();
 }
 
-void OmniboxViewGtk::TextChanged() {
-  EmphasizeURLComponents();
-  model_->OnChanged();
-}
-
 void OmniboxViewGtk::SavePrimarySelection(const std::string& selected_text) {
   DCHECK(text_view_);
 
   GtkClipboard* clipboard =
       gtk_widget_get_clipboard(text_view_, GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
   if (!clipboard)
     return;
 
   gtk_clipboard_set_text(
@@ skipping 174 matching lines @@
 void OmniboxViewGtk::UpdatePrimarySelectionIfValidURL() {
   string16 text = UTF8ToUTF16(GetSelectedText());
 
   if (text.empty())
     return;
 
   // Use AdjustTextForCopy to make sure we prefix the text with 'http://'.
   CharRange selection = GetSelection();
   GURL url;
   bool write_url;
-  model_->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
+  model()->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
                             &url, &write_url);
   if (write_url) {
     selected_text_ = UTF16ToUTF8(text);
     OwnPrimarySelection(selected_text_);
   }
 }
 
 void OmniboxViewGtk::HandlePreEditChanged(GtkWidget* sender,
                                           const gchar* pre_edit) {
   // GtkTextView won't fire "begin-user-action" and "end-user-action" signals
@@ skipping 48 matching lines @@
 void OmniboxViewGtk::AdjustVerticalAlignmentOfInstantView() {
   // By default, GtkTextView layouts an anchored child widget just above the
   // baseline, so we need to move the |instant_view_| down to make sure it
   // has the same baseline as the |text_view_|.
   PangoLayout* layout = gtk_label_get_layout(GTK_LABEL(instant_view_));
   int height;
   pango_layout_get_size(layout, NULL, &height);
   int baseline = pango_layout_get_baseline(layout);
   g_object_set(instant_anchor_tag_, "rise", baseline - height, NULL);
 }