Moving common code into OmniboxView from OmniboxView*

chrome/browser/ui/views/omnibox/omnibox_view_win.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_win.h"
 
 #include <algorithm>
 #include <locale>
 #include <string>
 
@@ skipping 421 matching lines @@
 
 }  // namespace
 
 OmniboxViewWin::OmniboxViewWin(OmniboxEditController* controller,
                                ToolbarModel* toolbar_model,
                                LocationBarView* parent_view,
                                CommandUpdater* command_updater,
                                bool popup_window_mode,
                                views::View* location_bar,
                                views::View* popup_parent_view)
-    : model_(new OmniboxEditModel(this, controller, parent_view->profile())),
+    : OmniboxView(parent_view->profile(), controller, toolbar_model,
+          command_updater),
       popup_view_(OmniboxPopupContentsView::Create(
-          parent_view->font(), this, model_.get(), location_bar,
+          parent_view->font(), this, model(), location_bar,
           popup_parent_view)),
-      controller_(controller),
       parent_view_(parent_view),
-      toolbar_model_(toolbar_model),
-      command_updater_(command_updater),
       popup_window_mode_(popup_window_mode),
       force_hidden_(false),
       tracking_click_(),
       tracking_double_click_(false),
       double_click_time_(0),
       can_discard_mousemove_(false),
       ignore_ime_messages_(false),
       delete_at_end_pressed_(false),
       font_(parent_view->font()),
       possible_drag_(false),
@@ skipping 79 matching lines @@
   g_paint_patcher.Pointer()->DerefPatch();
 }
 
 views::View* OmniboxViewWin::parent_view() const {
   return parent_view_;
 }
 
 void OmniboxViewWin::SaveStateToTab(WebContents* tab) {
   DCHECK(tab);
 
-  const OmniboxEditModel::State model_state(model_->GetStateForTabSwitch());
+  const OmniboxEditModel::State model_state(model()->GetStateForTabSwitch());
 
   CHARRANGE selection;
   GetSelection(selection);
   GetStateAccessor()->SetProperty(tab->GetPropertyBag(),
       AutocompleteEditState(
           model_state,
           State(selection, saved_selection_for_focus_change_)));
 }
 
 void OmniboxViewWin::Update(const WebContents* tab_for_state_restoring) {
   const bool visibly_changed_permanent_text =
-      model_->UpdatePermanentText(toolbar_model_->GetText());
+      model()->UpdatePermanentText(toolbar_model()->GetText());
 
   const ToolbarModel::SecurityLevel security_level =
-      toolbar_model_->GetSecurityLevel();
+      toolbar_model()->GetSecurityLevel();
   const bool changed_security_level = (security_level != security_level_);
 
   // Bail early when no visible state will actually change (prevents an
   // unnecessary ScopedFreeze, and thus UpdateWindow()).
   if (!changed_security_level && !visibly_changed_permanent_text &&
       !tab_for_state_restoring)
     return;
 
   // Update our local state as desired.  We set security_level_ here so it will
   // already be correct before we get to any RevertAll()s below and use it.
   security_level_ = security_level;
 
   // When we're switching to a new tab, restore its state, if any.
   ScopedFreeze freeze(this, GetTextObjectModel());
   if (tab_for_state_restoring) {
     // Make sure we reset our own state first.  The new tab may not have any
     // saved state, or it may not have had input in progress, in which case we
     // won't overwrite all our local state.
     RevertAll();
 
     const AutocompleteEditState* state = GetStateAccessor()->GetProperty(
         tab_for_state_restoring->GetPropertyBag());
     if (state) {
-      model_->RestoreState(state->model_state);
+      model()->RestoreState(state->model_state);
 
       // Restore user's selection.  We do this after restoring the user_text
       // above so we're selecting in the correct string.
       SetSelectionRange(state->view_state.selection);
       saved_selection_for_focus_change_ =
           state->view_state.saved_selection_for_focus_change;
     }
   } else if (visibly_changed_permanent_text) {
     // Not switching tabs, just updating the permanent text.  (In the case where
     // we _were_ switching tabs, the RevertAll() above already drew the new
@@ skipping 22 matching lines @@
   } else if (changed_security_level) {
     // Only the security style changed, nothing else.  Redraw our text using it.
     EmphasizeURLComponents();
   }
 }
 
 void OmniboxViewWin::OpenMatch(const AutocompleteMatch& match,
                                WindowOpenDisposition disposition,
                                const GURL& alternate_nav_url,
                                size_t selected_line) {
-  if (!match.destination_url.is_valid())
-    return;
-
   // When we navigate, we first revert to the unedited state, then if necessary
   // synchronously change the permanent text to the new URL.  If we don't freeze
   // here, the user could potentially see a flicker of the current URL before
   // the new one reappears, which would look glitchy.
   ScopedFreeze freeze(this, GetTextObjectModel());
-  model_->OpenMatch(match, disposition, alternate_nav_url, selected_line);
+  OmniboxView::OpenMatch(match, disposition, alternate_nav_url, selected_line);
 }
 
 string16 OmniboxViewWin::GetText() const {
   const int len = GetTextLength() + 1;
   string16 str;
   if (len > 1)
     GetWindowText(WriteInto(&str, len), len);
   return str;
 }
 
-bool OmniboxViewWin::IsEditingOrEmpty() const {
-  return model_->user_input_in_progress() || (GetTextLength() == 0);
-}
-
-int OmniboxViewWin::GetIcon() const {
-  return IsEditingOrEmpty() ?
-      AutocompleteMatch::TypeToIcon(model_->CurrentTextType()) :
-      toolbar_model_->GetIcon();
-}
-
-void OmniboxViewWin::SetUserText(const string16& text) {
-  SetUserText(text, text, true);
-}
-
 void OmniboxViewWin::SetUserText(const string16& text,
                                  const string16& display_text,
                                  bool update_popup) {
   ScopedFreeze freeze(this, GetTextObjectModel());
-  model_->SetUserText(text);
   saved_selection_for_focus_change_.cpMin = -1;
-  SetWindowTextAndCaretPos(display_text, display_text.length(), update_popup,
-      true);
+  OmniboxView::SetUserText(text, display_text, update_popup);
 }
 
 void OmniboxViewWin::SetWindowTextAndCaretPos(const string16& text,
                                               size_t caret_pos,
                                               bool update_popup,
                                               bool notify_text_changed) {
   SetWindowText(text.c_str());
   PlaceCaretAt(caret_pos);
 
   if (update_popup)
     UpdatePopup();
 
   if (notify_text_changed)
     TextChanged();
 }
 
 void OmniboxViewWin::SetForcedQuery() {
   const string16 current_text(GetText());
   const size_t start = current_text.find_first_not_of(kWhitespaceWide);
   if (start == string16::npos || (current_text[start] != '?'))
-    SetUserText(L"?");
+    OmniboxView::SetUserText(L"?");
   else
     SetSelection(current_text.length(), start + 1);
 }
 
 bool OmniboxViewWin::IsSelectAll() const {
   CHARRANGE selection;
   GetSel(selection);
   return IsSelectAllForRange(selection);
 }
 
@@ skipping 11 matching lines @@
 
 void OmniboxViewWin::SelectAll(bool reversed) {
   if (reversed)
     SetSelection(GetTextLength(), 0);
   else
     SetSelection(0, GetTextLength());
 }
 
 void OmniboxViewWin::RevertAll() {
   ScopedFreeze freeze(this, GetTextObjectModel());
-  ClosePopup();
   saved_selection_for_focus_change_.cpMin = -1;
-  model_->Revert();
+  OmniboxView::RevertAll();
 }
 
 void OmniboxViewWin::UpdatePopup() {
   ScopedFreeze freeze(this, GetTextObjectModel());
-  model_->SetInputInProgress(true);
+  model()->SetInputInProgress(true);
 
   // Don't allow the popup to open while the candidate window is open, so
   // they don't overlap.
   if (ime_candidate_window_open_)
     return;
 
-  if (!model_->has_focus()) {
+  if (!model()->has_focus()) {
     // When we're in the midst of losing focus, don't rerun autocomplete.  This
     // can happen when losing focus causes the IME to cancel/finalize a
     // composition.  We still want to note that user input is in progress, we
     // just don't want to do anything else.
     //
     // Note that in this case the ScopedFreeze above was unnecessary; however,
     // we're inside the callstack of OnKillFocus(), which has already frozen the
     // edit, so this will never result in an unnecessary UpdateWindow() call.
     return;
   }
 
   // Don't inline autocomplete when:
   //   * The user is deleting text
   //   * The caret/selection isn't at the end of the text
   //   * The user has just pasted in something that replaced all the text
   //   * The user is trying to compose something in an IME
   CHARRANGE sel;
   GetSel(sel);
-  model_->StartAutocomplete(sel.cpMax != sel.cpMin,
+  model()->StartAutocomplete(sel.cpMax != sel.cpMin,
                             (sel.cpMax < GetTextLength()) || IsImeComposing());
 }
 
-void OmniboxViewWin::ClosePopup() {
-  model_->StopAutocomplete();
-}
-
 void OmniboxViewWin::SetFocus() {
   ::SetFocus(m_hWnd);
 }
 
 void OmniboxViewWin::SetDropHighlightPosition(int position) {
   if (drop_highlight_position_ != position) {
     RepaintDropHighlight(drop_highlight_position_);
     drop_highlight_position_ = position;
     RepaintDropHighlight(drop_highlight_position_);
   }
@@ skipping 110 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.cpMin <= std::min(sel_before_change_.cpMin,
                                  sel_before_change_.cpMax));
 
-  const bool something_changed = model_->OnAfterPossibleChange(
+  const bool something_changed = model()->OnAfterPossibleChange(
       text_before_change_, new_text, new_sel.cpMin, new_sel.cpMax,
       selection_differs, text_differs, just_deleted_text, !IsImeComposing());
 
   if (selection_differs)
-    controller_->OnSelectionBoundsChanged();
+    controller()->OnSelectionBoundsChanged();
 
   if (something_changed && text_differs)
     TextChanged();
 
   if (text_differs) {
     // Note that a TEXT_CHANGED event implies that the cursor/selection
     // probably changed too, so we don't need to send both.
     native_view_host_->GetWidget()->NotifyAccessibilityEvent(
         native_view_host_, ui::AccessibilityTypes::EVENT_TEXT_CHANGED, true);
   } else if (selection_differs) {
     // Notify assistive technology that the cursor or selection changed.
     native_view_host_->GetWidget()->NotifyAccessibilityEvent(
         native_view_host_,
         ui::AccessibilityTypes::EVENT_SELECTION_CHANGED,
         true);
   } else if (delete_at_end_pressed_) {
-    model_->OnChanged();
+    model()->OnChanged();
   }
 
   return something_changed;
 }
 
 gfx::NativeView OmniboxViewWin::GetNativeView() const {
   return m_hWnd;
 }
 
 // static
 gfx::NativeView OmniboxViewWin::GetRelativeWindowForNativeView(
     gfx::NativeView edit_native_view) {
   // When an IME is attached to the rich-edit control, retrieve its window
   // handle, and the popup window of OmniboxPopupView will be shown under the
   // IME windows.
   // Otherwise, the popup window will be shown under top-most windows.
   // TODO(hbono): http://b/1111369 if we exclude this popup window from the
   // display area of IME windows, this workaround becomes unnecessary.
   HWND ime_window = ImmGetDefaultIMEWnd(edit_native_view);
   return ime_window ? ime_window : HWND_NOTOPMOST;
 }
 
 gfx::NativeView OmniboxViewWin::GetRelativeWindowForPopup() const {
   return GetRelativeWindowForNativeView(GetNativeView());
 }
 
-CommandUpdater* OmniboxViewWin::GetCommandUpdater() {
-  return command_updater_;
-}
-
 void OmniboxViewWin::SetInstantSuggestion(const string16& suggestion,
                                           bool animate_to_complete) {
   parent_view_->SetInstantSuggestion(suggestion, animate_to_complete);
 }
 
 int OmniboxViewWin::TextWidth() const {
   return WidthNeededToDisplay(GetText());
 }
 
 string16 OmniboxViewWin::GetInstantSuggestion() const {
@@ skipping 45 matching lines @@
 
 int OmniboxViewWin::OnPerformDropImpl(const views::DropTargetEvent& event,
                                       bool in_drag) {
   const ui::OSExchangeData& data = event.data();
 
   if (data.HasURL()) {
     GURL url;
     string16 title;
     if (data.GetURLAndTitle(&url, &title)) {
       string16 text(StripJavascriptSchemas(UTF8ToUTF16(url.spec())));
-      SetUserText(text);
+      OmniboxView::SetUserText(text);
       model()->AcceptInput(CURRENT_TAB, true);
       return CopyOrLinkDragOperation(event.source_operations());
     }
   } else if (data.HasString()) {
     int string_drop_position = drop_highlight_position();
     string16 text;
     if ((string_drop_position != -1 || !in_drag) && data.GetString(&text)) {
       DCHECK(string_drop_position == -1 ||
              ((string_drop_position >= 0) &&
               (string_drop_position <= GetTextLength())));
       if (in_drag) {
         if (event.source_operations()== ui::DragDropTypes::DRAG_MOVE)
           MoveSelectedText(string_drop_position);
         else
           InsertText(string_drop_position, text);
       } else {
         string16 collapsed_text(CollapseWhitespace(text, true));
-        if (model_->CanPasteAndGo(collapsed_text))
-          model_->PasteAndGo(collapsed_text);
+        if (model()->CanPasteAndGo(collapsed_text))
+          model()->PasteAndGo(collapsed_text);
       }
       return CopyOrLinkDragOperation(event.source_operations());
     }
   }
 
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 bool OmniboxViewWin::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& event) {
   ui::KeyboardCode key = event.key_code();
   // We don't process ALT + numpad digit as accelerators, they are used for
   // entering special characters.  We do translate alt-home.
   if (event.IsAltDown() && (key != ui::VKEY_HOME) &&
       views::NativeTextfieldWin::IsNumPadDigit(key,
           (event.flags() & ui::EF_EXTENDED) != 0))
     return true;
 
   // Skip accelerators for key combinations omnibox wants to crack. This list
   // should be synced with OnKeyDownOnlyWritable() (but for tab which is dealt
   // with above in LocationBarView::SkipDefaultKeyEventProcessing).
   //
   // We cannot return true for all keys because we still need to handle some
   // accelerators (e.g., F5 for reload the page should work even when the
   // Omnibox gets focused).
   switch (key) {
     case ui::VKEY_ESCAPE: {
       ScopedFreeze freeze(this, GetTextObjectModel());
-      return model_->OnEscapeKeyPressed();
+      return model()->OnEscapeKeyPressed();
     }
 
     case ui::VKEY_RETURN:
       return true;
 
     case ui::VKEY_UP:
     case ui::VKEY_DOWN:
       return !event.IsAltDown();
 
     case ui::VKEY_DELETE:
@@ skipping 30 matching lines @@
 bool OmniboxViewWin::IsCommandIdChecked(int command_id) const {
   return false;
 }
 
 bool OmniboxViewWin::IsCommandIdEnabled(int command_id) const {
   switch (command_id) {
     case IDS_UNDO:         return !!CanUndo();
     case IDC_CUT:          return !!CanCut();
     case IDC_COPY:         return !!CanCopy();
     case IDC_PASTE:        return !!CanPaste();
-    case IDS_PASTE_AND_GO: return model_->CanPasteAndGo(GetClipboardText());
+    case IDS_PASTE_AND_GO: return model()->CanPasteAndGo(GetClipboardText());
     case IDS_SELECT_ALL:   return !!CanSelectAll();
     case IDS_EDIT_SEARCH_ENGINES:
-      return command_updater_->IsCommandEnabled(IDC_EDIT_SEARCH_ENGINES);
+      return command_updater()->IsCommandEnabled(IDC_EDIT_SEARCH_ENGINES);
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool OmniboxViewWin::GetAcceleratorForCommandId(
     int command_id,
     ui::Accelerator* accelerator) {
   return parent_view_->GetWidget()->GetAccelerator(command_id, accelerator);
 }
 
 bool OmniboxViewWin::IsItemForCommandIdDynamic(int command_id) const {
   // No need to change the default IDS_PASTE_AND_GO label unless this is a
   // search.
   return command_id == IDS_PASTE_AND_GO;
 }
 
 string16 OmniboxViewWin::GetLabelForCommandId(int command_id) const {
   DCHECK_EQ(IDS_PASTE_AND_GO, command_id);
   return l10n_util::GetStringUTF16(
-      model_->IsPasteAndSearch(GetClipboardText()) ?
+      model()->IsPasteAndSearch(GetClipboardText()) ?
       IDS_PASTE_AND_SEARCH : IDS_PASTE_AND_GO);
 }
 
 void OmniboxViewWin::ExecuteCommand(int command_id) {
   ScopedFreeze freeze(this, GetTextObjectModel());
   if (command_id == IDS_PASTE_AND_GO) {
     // This case is separate from the switch() below since we don't want to wrap
     // it in OnBefore/AfterPossibleChange() calls.
-    model_->PasteAndGo(GetClipboardText());
+    model()->PasteAndGo(GetClipboardText());
     return;
   }
 
   OnBeforePossibleChange();
   switch (command_id) {
     case IDS_UNDO:
       Undo();
       break;
 
     case IDC_CUT:
       Cut();
       break;
 
     case IDC_COPY:
       Copy();
       break;
 
     case IDC_PASTE:
       Paste();
       break;
 
     case IDS_SELECT_ALL:
       SelectAll(false);
       break;
 
     case IDS_EDIT_SEARCH_ENGINES:
-      command_updater_->ExecuteCommand(IDC_EDIT_SEARCH_ENGINES);
+      command_updater()->ExecuteCommand(IDC_EDIT_SEARCH_ENGINES);
       break;
 
     default:
       NOTREACHED();
       break;
   }
   OnAfterPossibleChange();
 }
 
 // static
@@ skipping 169 matching lines @@
   string16 text(GetSelectedText());
   if (text.empty())
     return;
 
   CHARRANGE sel;
   GURL url;
   bool write_url = false;
   GetSel(sel);
   // GetSel() doesn't preserve selection direction, so sel.cpMin will always be
   // the smaller value.
-  model_->AdjustTextForCopy(sel.cpMin, IsSelectAll(), &text, &url, &write_url);
+  model()->AdjustTextForCopy(sel.cpMin, IsSelectAll(), &text, &url, &write_url);
   ui::ScopedClipboardWriter scw(g_browser_process->clipboard(),
                                 ui::Clipboard::BUFFER_STANDARD);
   scw.WriteText(text);
   if (write_url) {
     scw.WriteBookmark(text, url.spec());
     scw.WriteHyperlink(net::EscapeForHTML(text), url.spec());
   }
 }
 
 void OmniboxViewWin::OnCut() {
@@ skipping 40 matching lines @@
 }
 
 LRESULT OmniboxViewWin::OnImeNotify(UINT message,
                                     WPARAM wparam,
                                     LPARAM lparam) {
   // Close the popup when the IME composition window is open, so they don't
   // overlap.
   switch (wparam) {
     case IMN_OPENCANDIDATE:
       ime_candidate_window_open_ = true;
-      ClosePopup();
+      CloseOmniboxPopup();
       break;
     case IMN_CLOSECANDIDATE:
       ime_candidate_window_open_ = false;
 
       // UpdatePopup assumes user input is in progress, so only call it if
       // that's the case. Otherwise, autocomplete may run on an empty user
       // text. For example, Baidu Japanese IME sends IMN_CLOSECANDIDATE when
       // composition mode is entered, but the user may not have input anything
       // yet.
-      if (model_->user_input_in_progress())
+      if (model()->user_input_in_progress())
         UpdatePopup();
 
       break;
     default:
       break;
   }
   return DefWindowProc(message, wparam, lparam);
 }
 
 LRESULT OmniboxViewWin::OnPointerDown(UINT message,
                                       WPARAM wparam,
                                       LPARAM lparam) {
-  if (!model_->has_focus())
+  if (!model()->has_focus())
     SetFocus();
 
   if (IS_POINTER_FIRSTBUTTON_WPARAM(wparam)) {
     TrackMousePosition(kLeft, CPoint(GET_X_LPARAM(lparam),
                                      GET_Y_LPARAM(lparam)));
   }
 
   SetMsgHandled(false);
 
   return 0;
@@ skipping 26 matching lines @@
 
   // CRichEditCtrl changes its text on WM_KEYDOWN instead of WM_CHAR for many
   // different keys (backspace, ctrl-v, ...), so we call this in both cases.
   HandleKeystroke(GetCurrentMessage()->message, key, repeat_count, flags);
 }
 
 void OmniboxViewWin::OnKeyUp(TCHAR key,
                              UINT repeat_count,
                              UINT flags) {
   if (key == VK_CONTROL)
-    model_->OnControlKeyChanged(false);
+    model()->OnControlKeyChanged(false);
 
   // On systems with RTL input languages, ctrl+shift toggles the reading order
   // (depending on which shift key is pressed). But by default the CRichEditCtrl
   // only changes the current reading order, and as soon as the user deletes all
   // the text, or we call SetWindowText(), it reverts to the "default" order.
   // To work around this, if the user hits ctrl+shift, we pass it to
   // DefWindowProc() while the edit is empty, which toggles the default reading
   // order; then we restore the user's input.
   if (!(flags & KF_ALTDOWN) &&
       (((key == VK_CONTROL) && (GetKeyState(VK_SHIFT) < 0)) ||
@@ skipping 17 matching lines @@
 }
 
 void OmniboxViewWin::OnKillFocus(HWND focus_wnd) {
   if (m_hWnd == focus_wnd) {
     // Focus isn't actually leaving.
     SetMsgHandled(false);
     return;
   }
 
   // This must be invoked before ClosePopup.
-  model_->OnWillKillFocus(focus_wnd);
+  model()->OnWillKillFocus(focus_wnd);
 
   // Close the popup.
-  ClosePopup();
+  CloseOmniboxPopup();
 
   // Save the user's existing selection to restore it later.
   GetSelection(saved_selection_for_focus_change_);
 
   // Tell the model to reset itself.
-  model_->OnKillFocus();
+  model()->OnKillFocus();
 
   // Let the CRichEditCtrl do its default handling.  This will complete any
   // in-progress IME composition.  We must do this after setting has_focus_ to
   // false so that UpdatePopup() will know not to rerun autocomplete.
   ScopedFreeze freeze(this, GetTextObjectModel());
   DefWindowProc(WM_KILLFOCUS, reinterpret_cast<WPARAM>(focus_wnd), 0);
 
   // Cancel any user selection and scroll the text back to the beginning of the
   // URL.  We have to do this after calling DefWindowProc() because otherwise
   // an in-progress IME composition will be completed at the new caret position,
@@ skipping 115 matching lines @@
   // First, give other handlers a chance to handle the message to see if we are
   // actually going to activate and gain focus.
   LRESULT result = DefWindowProc(WM_MOUSEACTIVATE,
                                  reinterpret_cast<WPARAM>(window),
                                  MAKELPARAM(hit_test, mouse_message));
   // Check if we're getting focus from a click.  We have to do this here rather
   // than in OnXButtonDown() since in many scenarios OnSetFocus() will be
   // reached before OnXButtonDown(), preventing us from detecting this properly
   // there.  Also in those cases, we need to already know in OnSetFocus() that
   // we should not restore the saved selection.
-  if (!model_->has_focus() &&
+  if (!model()->has_focus() &&
       ((mouse_message == WM_LBUTTONDOWN || mouse_message == WM_RBUTTONDOWN ||
         mouse_message == WM_POINTERDOWN)) &&
       (result == MA_ACTIVATE)) {
     DCHECK(!gaining_focus_.get());
     gaining_focus_.reset(new ScopedFreeze(this, GetTextObjectModel()));
     // NOTE: Despite |mouse_message| being WM_XBUTTONDOWN here, we're not
     // guaranteed to call OnXButtonDown() later!  Specifically, if this is the
     // second click of a double click, we'll reach here but later call
     // OnXButtonDblClk().  Make sure |gaining_focus_| gets reset both places,
     // or we'll have visual glitchiness and then DCHECK failures.
@@ skipping 140 matching lines @@
          rect.left, rect.top, SRCCOPY);
   memory_dc.SelectBitmap(old_bitmap);
   edit_hwnd = old_edit_hwnd;
 }
 
 void OmniboxViewWin::OnPaste() {
   // Replace the selection if we have something to paste.
   const string16 text(GetClipboardText());
   if (!text.empty()) {
     // Record this paste, so we can do different behavior.
-    model_->on_paste();
+    model()->on_paste();
     // Force a Paste operation to trigger the text_changed code in
     // OnAfterPossibleChange(), even if identical contents are pasted into the
     // text box.
     text_before_change_.clear();
     ReplaceSel(text.c_str(), true);
   }
 }
 
 void OmniboxViewWin::OnRButtonDblClk(UINT /*keys*/, const CPoint& /*point*/) {
   gaining_focus_.reset();  // See NOTE in OnMouseActivate().
@@ skipping 17 matching lines @@
 void OmniboxViewWin::OnSetFocus(HWND focus_wnd) {
   views::FocusManager* focus_manager = parent_view_->GetFocusManager();
   if (focus_manager) {
     // Notify the FocusManager that the focused view is now the location bar
     // (our parent view).
     focus_manager->SetFocusedView(parent_view_);
   } else {
     NOTREACHED();
   }
 
-  model_->OnSetFocus(GetKeyState(VK_CONTROL) < 0);
+  model()->OnSetFocus(GetKeyState(VK_CONTROL) < 0);
 
   // Restore saved selection if available.
   if (saved_selection_for_focus_change_.cpMin != -1) {
     SetSelectionRange(saved_selection_for_focus_change_);
     saved_selection_for_focus_change_.cpMin = -1;
   }
 
   SetMsgHandled(false);
 }
 
@@ skipping 91 matching lines @@
   switch (key) {
     case VK_RIGHT:
       // TODO(sky): figure out RTL.
       if (base::i18n::IsRTL())
         return false;
       {
         CHARRANGE selection;
         GetSel(selection);
         return (selection.cpMin == selection.cpMax) &&
             (selection.cpMin == GetTextLength()) &&
-            model_->CommitSuggestedText(true);
+            model()->CommitSuggestedText(true);
       }
 
     case VK_RETURN:
-      model_->AcceptInput((flags & KF_ALTDOWN) ?
+      model()->AcceptInput((flags & KF_ALTDOWN) ?
           NEW_FOREGROUND_TAB : CURRENT_TAB, false);
       return true;
 
     case VK_PRIOR:
     case VK_NEXT:
-      count = model_->result().size();
+      count = model()->result().size();
       // FALL THROUGH
     case VK_UP:
     case VK_DOWN:
       // Ignore alt + numpad, but treat alt + (non-numpad) like (non-numpad).
       if ((flags & KF_ALTDOWN) && !(flags & KF_EXTENDED))
         return false;
 
-      model_->OnUpOrDownKeyPressed(((key == VK_PRIOR) || (key == VK_UP)) ?
+      model()->OnUpOrDownKeyPressed(((key == VK_PRIOR) || (key == VK_UP)) ?
           -count : count);
       return true;
 
     // Hijacking Editing Commands
     //
     // We hijack the keyboard short-cuts for Cut, Copy, and Paste here so that
     // they go through our clipboard routines.  This allows us to be smarter
     // about how we interact with the clipboard and avoid bugs in the
     // CRichEditCtrl.  If we didn't hijack here, the edit control would handle
     // these internally with sending the WM_CUT, WM_COPY, or WM_PASTE messages.
@@ skipping 25 matching lines @@
       if (GetKeyState(VK_CONTROL) >= 0) {
         // Cut text if possible.
         CHARRANGE selection;
         GetSel(selection);
         if (selection.cpMin != selection.cpMax) {
           ScopedFreeze freeze(this, GetTextObjectModel());
           OnBeforePossibleChange();
           Cut();
           OnAfterPossibleChange();
         } else {
-          if (model_->popup_model()->IsOpen()) {
+          if (model()->popup_model()->IsOpen()) {
             // This is a bit overloaded, but we hijack Shift-Delete in this
             // case to delete the current item from the pop-up.  We prefer
             // cutting to this when possible since that's the behavior more
             // people expect from Shift-Delete, and it's more commonly useful.
-            model_->popup_model()->TryDeletingCurrentItem();
+            model()->popup_model()->TryDeletingCurrentItem();
           }
         }
       }
       return true;
 
     case 'X':
       if ((flags & KF_ALTDOWN) || (GetKeyState(VK_CONTROL) >= 0))
         return false;
       if (GetKeyState(VK_SHIFT) >= 0) {
         ScopedFreeze freeze(this, GetTextObjectModel());
@@ skipping 15 matching lines @@
         return false;
       if (GetKeyState((key == 'V') ? VK_SHIFT : VK_CONTROL) >= 0) {
         ScopedFreeze freeze(this, GetTextObjectModel());
         OnBeforePossibleChange();
         Paste();
         OnAfterPossibleChange();
       }
       return true;
 
     case VK_BACK: {
-      if ((flags & KF_ALTDOWN) || model_->is_keyword_hint() ||
-          model_->keyword().empty())
+      if ((flags & KF_ALTDOWN) || model()->is_keyword_hint() ||
+          model()->keyword().empty())
         return false;
 
       {
         CHARRANGE selection;
         GetSel(selection);
         if ((selection.cpMin != selection.cpMax) || (selection.cpMin != 0))
           return false;
       }
 
       // We're showing a keyword and the user pressed backspace at the beginning
       // of the text. Delete the selected keyword.
       ScopedFreeze freeze(this, GetTextObjectModel());
-      model_->ClearKeyword(GetText());
+      model()->ClearKeyword(GetText());
       return true;
     }
 
     case VK_TAB: {
       const bool shift_pressed = GetKeyState(VK_SHIFT) < 0;
-      if (model_->is_keyword_hint() && !shift_pressed) {
+      if (model()->is_keyword_hint() && !shift_pressed) {
         // Accept the keyword.
         ScopedFreeze freeze(this, GetTextObjectModel());
-        model_->AcceptKeyword();
+        model()->AcceptKeyword();
       } else if (shift_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_pressed ? -count : count);
+        model()->OnUpOrDownKeyPressed(shift_pressed ? -count : count);
       }
       return true;
     }
 
     case 0xbb:  // Ctrl-'='.  Triggers subscripting (even in plain text mode).
                 // We don't use VK_OEM_PLUS in case the macro isn't defined.
                 // (e.g., we don't have this symbol in embeded environment).
       return true;
 
     default:
       return false;
   }
 }
 
 bool OmniboxViewWin::OnKeyDownAllModes(TCHAR key,
                                        UINT repeat_count,
                                        UINT flags) {
   // See KF_ALTDOWN comment atop OnKeyDownOnlyWritable().
 
   switch (key) {
     case VK_CONTROL:
-      model_->OnControlKeyChanged(true);
+      model()->OnControlKeyChanged(true);
       return false;
 
     case VK_INSERT:
     case 'C':
       // See more detailed comments in OnKeyDownOnlyWritable().
       if ((flags & KF_ALTDOWN) || (GetKeyState(VK_CONTROL) >= 0))
         return false;
       if (GetKeyState(VK_SHIFT) >= 0)
         Copy();
       return true;
@@ skipping 99 matching lines @@
   // the end of the text, but triple-click will still work.
   if (x < left_bound) {
     return (is_triple_click && ltr_text_in_ltr_layout) ? left_bound - 1 :
                                                          left_bound;
   }
   if ((length == 0) || (x < right_bound))
     return x;
   return is_triple_click ? (right_bound - 1) : right_bound;
 }
 
+int OmniboxViewWin::GetOmniboxTextLength() const {
+  return static_cast<int>(GetTextLength());
+}
+
 void OmniboxViewWin::EmphasizeURLComponents() {
   ITextDocument* const text_object_model = GetTextObjectModel();
   ScopedFreeze freeze(this, text_object_model);
   ScopedSuspendUndo suspend_undo(text_object_model);
 
   // Save the selection.
   CHARRANGE saved_sel;
   GetSelection(saved_sel);
 
   // 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(
-      GetText(), model_->GetDesiredTLD(), &scheme, &host);
-  const bool emphasize = model_->CurrentTextIsURL() && (host.len > 0);
+      GetText(), model()->GetDesiredTLD(), &scheme, &host);
+  const bool emphasize = model()->CurrentTextIsURL() && (host.len > 0);
 
   // Set the baseline emphasis.
   CHARFORMAT cf = {0};
   cf.dwMask = CFM_COLOR;
   // If we're going to emphasize parts of the text, then the baseline state
   // should be "de-emphasized".  If not, then everything should be rendered in
   // the standard text color.
   cf.crTextColor = skia::SkColorToCOLORREF(LocationBarView::GetColor(
       security_level_,
       emphasize ? LocationBarView::DEEMPHASIZED_TEXT : LocationBarView::TEXT));
   // NOTE: Don't use SetDefaultCharFormat() instead of the below; that sets the
   // format that will get applied to text added in the future, not to text
   // already in the edit.
   SelectAll(false);
   SetSelectionCharFormat(cf);
 
   if (emphasize) {
     // We've found a host name, give it more emphasis.
     cf.crTextColor = skia::SkColorToCOLORREF(LocationBarView::GetColor(
         security_level_, LocationBarView::TEXT));
     SetSelection(host.begin, host.end());
     SetSelectionCharFormat(cf);
   }
 
   // Emphasize the scheme for security UI display purposes (if necessary).
   insecure_scheme_component_.reset();
-  if (!model_->user_input_in_progress() && scheme.is_nonempty() &&
+  if (!model()->user_input_in_progress() && scheme.is_nonempty() &&
       (security_level_ != ToolbarModel::NONE)) {
     if (security_level_ == ToolbarModel::SECURITY_ERROR) {
       insecure_scheme_component_.begin = scheme.begin;
       insecure_scheme_component_.len = scheme.len;
     }
     cf.crTextColor = skia::SkColorToCOLORREF(LocationBarView::GetColor(
         security_level_, LocationBarView::SECURITY_TEXT));
     SetSelection(scheme.begin, scheme.end());
     SetSelectionCharFormat(cf);
   }
@@ skipping 130 matching lines @@
     return;
 
   HGDIOBJ last_pen = SelectObject(hdc, CreatePen(PS_SOLID, 1, RGB(0, 0, 0)));
   MoveToEx(hdc, clip_rect.left, clip_rect.top, NULL);
   LineTo(hdc, clip_rect.left, clip_rect.bottom);
   DeleteObject(SelectObject(hdc, last_pen));
 }
 
 void OmniboxViewWin::TextChanged() {
   ScopedFreeze freeze(this, GetTextObjectModel());
-  EmphasizeURLComponents();
-  model_->OnChanged();
+  OmniboxView::TextChanged();
 }
 
 ITextDocument* OmniboxViewWin::GetTextObjectModel() const {
   if (!text_object_model_) {
     // This is lazily initialized, instead of being initialized in the
     // constructor, in order to avoid hurting startup performance.
     base::win::ScopedComPtr<IRichEditOle, NULL> ole_interface;
     ole_interface.Attach(GetOleInterface());
     if (ole_interface) {
       ole_interface.QueryInterface(
@@ skipping 37 matching lines @@
 
   // |sel| was set by GetSelection(), which preserves selection direction, so
   // sel.cpMin may not be the smaller value.
   model()->AdjustTextForCopy(std::min(sel.cpMin, sel.cpMax), is_all_selected,
                              &text_to_write, &url, &write_url);
 
   if (write_url) {
     string16 title;
     SkBitmap favicon;
     if (is_all_selected)
-      model_->GetDataForURLExport(&url, &title, &favicon);
+      model()->GetDataForURLExport(&url, &title, &favicon);
     button_drag_utils::SetURLAndDragImage(url, title, favicon, &data,
                                           native_view_host_->GetWidget());
     supported_modes |= DROPEFFECT_LINK;
     content::RecordAction(UserMetricsAction("Omnibox_DragURL"));
   } else {
     supported_modes |= DROPEFFECT_MOVE;
     content::RecordAction(UserMetricsAction("Omnibox_DragString"));
   }
 
   data.SetString(text_to_write);
@@ skipping 129 matching lines @@
   return (rect.left - client_rect.left) + (client_rect.right - rect.right);
 }
 
 int OmniboxViewWin::WidthNeededToDisplay(const string16& text) const {
   // Use font_.GetStringWidth() instead of
   // PosFromChar(location_entry_->GetTextLength()) because PosFromChar() is
   // apparently buggy. In both LTR UI and RTL UI with left-to-right layout,
   // PosFromChar(i) might return 0 when i is greater than 1.
   return font_.GetStringWidth(text) + GetHorizontalMargin();
 }
-
-bool OmniboxViewWin::IsCaretAtEnd() const {
-  long length = GetTextLength();
-  CHARRANGE sel;
-  GetSelection(sel);
-  return sel.cpMin == sel.cpMax && sel.cpMin == length;
-}