1// Copyright 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
6
7#include <string>
8
9#include "base/auto_reset.h"
10#include "base/format_macros.h"
11#include "base/metrics/histogram.h"
12#include "base/prefs/pref_service.h"
13#include "base/strings/string_number_conversions.h"
14#include "base/strings/string_util.h"
15#include "base/strings/stringprintf.h"
16#include "base/strings/utf_string_conversions.h"
17#include "chrome/app/chrome_command_ids.h"
18#include "chrome/browser/autocomplete/autocomplete_classifier.h"
19#include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
20#include "chrome/browser/autocomplete/autocomplete_input.h"
21#include "chrome/browser/autocomplete/autocomplete_provider.h"
22#include "chrome/browser/autocomplete/extension_app_provider.h"
23#include "chrome/browser/autocomplete/history_url_provider.h"
24#include "chrome/browser/autocomplete/keyword_provider.h"
25#include "chrome/browser/autocomplete/search_provider.h"
26#include "chrome/browser/bookmarks/bookmark_stats.h"
27#include "chrome/browser/chrome_notification_types.h"
28#include "chrome/browser/command_updater.h"
29#include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
30#include "chrome/browser/favicon/favicon_tab_helper.h"
31#include "chrome/browser/google/google_url_tracker.h"
32#include "chrome/browser/net/predictor.h"
33#include "chrome/browser/omnibox/omnibox_log.h"
34#include "chrome/browser/predictors/autocomplete_action_predictor.h"
35#include "chrome/browser/predictors/autocomplete_action_predictor_factory.h"
36#include "chrome/browser/prerender/prerender_field_trial.h"
37#include "chrome/browser/prerender/prerender_manager.h"
38#include "chrome/browser/prerender/prerender_manager_factory.h"
39#include "chrome/browser/profiles/profile.h"
40#include "chrome/browser/search/search.h"
41#include "chrome/browser/search_engines/template_url.h"
42#include "chrome/browser/search_engines/template_url_prepopulate_data.h"
43#include "chrome/browser/search_engines/template_url_service.h"
44#include "chrome/browser/search_engines/template_url_service_factory.h"
45#include "chrome/browser/sessions/session_tab_helper.h"
46#include "chrome/browser/ui/browser_list.h"
47#include "chrome/browser/ui/omnibox/omnibox_current_page_delegate_impl.h"
48#include "chrome/browser/ui/omnibox/omnibox_edit_controller.h"
49#include "chrome/browser/ui/omnibox/omnibox_navigation_observer.h"
50#include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
51#include "chrome/browser/ui/omnibox/omnibox_popup_view.h"
52#include "chrome/browser/ui/omnibox/omnibox_view.h"
53#include "chrome/browser/ui/search/instant_controller.h"
54#include "chrome/browser/ui/search/instant_search_prerenderer.h"
55#include "chrome/browser/ui/search/search_tab_helper.h"
56#include "chrome/browser/ui/toolbar/toolbar_model.h"
57#include "chrome/common/chrome_switches.h"
58#include "chrome/common/net/url_fixer_upper.h"
59#include "chrome/common/pref_names.h"
60#include "chrome/common/url_constants.h"
61#include "content/public/browser/navigation_controller.h"
62#include "content/public/browser/navigation_entry.h"
63#include "content/public/browser/notification_service.h"
64#include "content/public/browser/render_view_host.h"
65#include "content/public/browser/user_metrics.h"
66#include "extensions/common/constants.h"
67#include "ui/gfx/image/image.h"
68#include "url/url_util.h"
69
70using predictors::AutocompleteActionPredictor;
71
72
73// Helpers --------------------------------------------------------------------
74
75namespace {
76
77// Histogram name which counts the number of times that the user text is
78// cleared.  IME users are sometimes in the situation that IME was
79// unintentionally turned on and failed to input latin alphabets (ASCII
80// characters) or the opposite case.  In that case, users may delete all
81// the text and the user text gets cleared.  We'd like to measure how often
82// this scenario happens.
83//
84// Note that since we don't currently correlate "text cleared" events with
85// IME usage, this also captures many other cases where users clear the text;
86// though it explicitly doesn't log deleting all the permanent text as
87// the first action of an editing sequence (see comments in
88// OnAfterPossibleChange()).
89const char kOmniboxUserTextClearedHistogram[] = "Omnibox.UserTextCleared";
90
91enum UserTextClearedType {
92  OMNIBOX_USER_TEXT_CLEARED_BY_EDITING = 0,
93  OMNIBOX_USER_TEXT_CLEARED_WITH_ESCAPE = 1,
94  OMNIBOX_USER_TEXT_CLEARED_NUM_OF_ITEMS,
95};
96
97// Histogram name which counts the number of times the user enters
98// keyword hint mode and via what method.  The possible values are listed
99// in the EnteredKeywordModeMethod enum which is defined in the .h file.
100const char kEnteredKeywordModeHistogram[] = "Omnibox.EnteredKeywordMode";
101
102// Histogram name which counts the number of milliseconds a user takes
103// between focusing and editing the omnibox.
104const char kFocusToEditTimeHistogram[] = "Omnibox.FocusToEditTime";
105
106// Histogram name which counts the number of milliseconds a user takes
107// between focusing and opening an omnibox match.
108const char kFocusToOpenTimeHistogram[] = "Omnibox.FocusToOpenTime";
109
110// Split the percentage match histograms into buckets based on the width of the
111// omnibox.
112const int kPercentageMatchHistogramWidthBuckets[] = { 400, 700, 1200 };
113
114void RecordPercentageMatchHistogram(const base::string16& old_text,
115                                    const base::string16& new_text,
116                                    bool url_replacement_active,
117                                    content::PageTransition transition,
118                                    int omnibox_width) {
119  size_t avg_length = (old_text.length() + new_text.length()) / 2;
120
121  int percent = 0;
122  if (!old_text.empty() && !new_text.empty()) {
123    size_t shorter_length = std::min(old_text.length(), new_text.length());
124    base::string16::const_iterator end(old_text.begin() + shorter_length);
125    base::string16::const_iterator mismatch(
126        std::mismatch(old_text.begin(), end, new_text.begin()).first);
127    size_t matching_characters = mismatch - old_text.begin();
128    percent = static_cast<float>(matching_characters) / avg_length * 100;
129  }
130
131  std::string histogram_name;
132  if (url_replacement_active) {
133    if (transition == content::PAGE_TRANSITION_TYPED) {
134      histogram_name = "InstantExtended.PercentageMatchV2_QuerytoURL";
135      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
136    } else {
137      histogram_name = "InstantExtended.PercentageMatchV2_QuerytoQuery";
138      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
139    }
140  } else {
141    if (transition == content::PAGE_TRANSITION_TYPED) {
142      histogram_name = "InstantExtended.PercentageMatchV2_URLtoURL";
143      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
144    } else {
145      histogram_name = "InstantExtended.PercentageMatchV2_URLtoQuery";
146      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
147    }
148  }
149
150  std::string suffix = "large";
151  for (size_t i = 0; i < arraysize(kPercentageMatchHistogramWidthBuckets);
152       ++i) {
153    if (omnibox_width < kPercentageMatchHistogramWidthBuckets[i]) {
154      suffix = base::IntToString(kPercentageMatchHistogramWidthBuckets[i]);
155      break;
156    }
157  }
158
159  // Cannot rely on UMA histograms macro because the name of the histogram is
160  // generated dynamically.
161  base::HistogramBase* counter = base::LinearHistogram::FactoryGet(
162      histogram_name + "_" + suffix, 1, 101, 102,
163      base::Histogram::kUmaTargetedHistogramFlag);
164  counter->Add(percent);
165}
166
167}  // namespace
168
169
170// OmniboxEditModel::State ----------------------------------------------------
171
172OmniboxEditModel::State::State(bool user_input_in_progress,
173                               const base::string16& user_text,
174                               const base::string16& gray_text,
175                               const base::string16& keyword,
176                               bool is_keyword_hint,
177                               bool url_replacement_enabled,
178                               OmniboxFocusState focus_state,
179                               FocusSource focus_source)
180    : user_input_in_progress(user_input_in_progress),
181      user_text(user_text),
182      gray_text(gray_text),
183      keyword(keyword),
184      is_keyword_hint(is_keyword_hint),
185      url_replacement_enabled(url_replacement_enabled),
186      focus_state(focus_state),
187      focus_source(focus_source) {
188}
189
190OmniboxEditModel::State::~State() {
191}
192
193
194// OmniboxEditModel -----------------------------------------------------------
195
196OmniboxEditModel::OmniboxEditModel(OmniboxView* view,
197                                   OmniboxEditController* controller,
198                                   Profile* profile)
199    : view_(view),
200      controller_(controller),
201      focus_state_(OMNIBOX_FOCUS_NONE),
202      focus_source_(INVALID),
203      user_input_in_progress_(false),
204      user_input_since_focus_(true),
205      just_deleted_text_(false),
206      has_temporary_text_(false),
207      paste_state_(NONE),
208      control_key_state_(UP),
209      is_keyword_hint_(false),
210      profile_(profile),
211      in_revert_(false),
212      allow_exact_keyword_match_(false) {
213  omnibox_controller_.reset(new OmniboxController(this, profile));
214  delegate_.reset(new OmniboxCurrentPageDelegateImpl(controller, profile));
215}
216
217OmniboxEditModel::~OmniboxEditModel() {
218}
219
220const OmniboxEditModel::State OmniboxEditModel::GetStateForTabSwitch() {
221  // Like typing, switching tabs "accepts" the temporary text as the user
222  // text, because it makes little sense to have temporary text when the
223  // popup is closed.
224  if (user_input_in_progress_) {
225    // Weird edge case to match other browsers: if the edit is empty, revert to
226    // the permanent text (so the user can get it back easily) but select it (so
227    // on switching back, typing will "just work").
228    const base::string16 user_text(UserTextFromDisplayText(view_->GetText()));
229    if (user_text.empty()) {
230      base::AutoReset<bool> tmp(&in_revert_, true);
231      view_->RevertAll();
232      view_->SelectAll(true);
233    } else {
234      InternalSetUserText(user_text);
235    }
236  }
237
238  return State(
239      user_input_in_progress_, user_text_, view_->GetGrayTextAutocompletion(),
240      keyword_, is_keyword_hint_,
241      controller_->GetToolbarModel()->url_replacement_enabled(),
242      focus_state_, focus_source_);
243}
244
245void OmniboxEditModel::RestoreState(const State* state) {
246  // We need to update the permanent text correctly and revert the view
247  // regardless of whether there is saved state.
248  controller_->GetToolbarModel()->set_url_replacement_enabled(
249      !state || state->url_replacement_enabled);
250  permanent_text_ = controller_->GetToolbarModel()->GetText();
251  // Don't muck with the search term replacement state, as we've just set it
252  // correctly.
253  view_->RevertWithoutResettingSearchTermReplacement();
254  if (!state)
255    return;
256
257  SetFocusState(state->focus_state, OMNIBOX_FOCUS_CHANGE_TAB_SWITCH);
258  focus_source_ = state->focus_source;
259  // Restore any user editing.
260  if (state->user_input_in_progress) {
261    // NOTE: Be sure and set keyword-related state BEFORE invoking
262    // DisplayTextFromUserText(), as its result depends upon this state.
263    keyword_ = state->keyword;
264    is_keyword_hint_ = state->is_keyword_hint;
265    view_->SetUserText(state->user_text,
266        DisplayTextFromUserText(state->user_text), false);
267    view_->SetGrayTextAutocompletion(state->gray_text);
268  }
269}
270
271AutocompleteMatch OmniboxEditModel::CurrentMatch(
272    GURL* alternate_nav_url) const {
273  // If we have a valid match use it. Otherwise get one for the current text.
274  AutocompleteMatch match = omnibox_controller_->current_match();
275
276  if (!match.destination_url.is_valid()) {
277    GetInfoForCurrentText(&match, alternate_nav_url);
278  } else if (alternate_nav_url) {
279    *alternate_nav_url = AutocompleteResult::ComputeAlternateNavUrl(
280        autocomplete_controller()->input(), match);
281  }
282  return match;
283}
284
285bool OmniboxEditModel::UpdatePermanentText() {
286  SearchProvider* search_provider =
287      autocomplete_controller()->search_provider();
288  if (search_provider && delegate_->CurrentPageExists())
289    search_provider->set_current_page_url(delegate_->GetURL());
290
291  // When there's new permanent text, and the user isn't interacting with the
292  // omnibox, we want to revert the edit to show the new text.  We could simply
293  // define "interacting" as "the omnibox has focus", but we still allow updates
294  // when the omnibox has focus as long as the user hasn't begun editing, isn't
295  // seeing zerosuggestions (because changing this text would require changing
296  // or hiding those suggestions), and hasn't toggled on "Show URL" (because
297  // this update will re-enable search term replacement, which will be annoying
298  // if the user is trying to copy the URL).  When the omnibox doesn't have
299  // focus, we assume the user may have abandoned their interaction and it's
300  // always safe to change the text; this also prevents someone toggling "Show
301  // URL" (which sounds as if it might be persistent) from seeing just that URL
302  // forever afterwards.
303  //
304  // If the page is auto-committing gray text, however, we generally don't want
305  // to make any change to the edit.  While auto-commits modify the underlying
306  // permanent URL, they're intended to have no effect on the user's editing
307  // process -- before and after the auto-commit, the omnibox should show the
308  // same user text and the same instant suggestion, even if the auto-commit
309  // happens while the edit doesn't have focus.
310  base::string16 new_permanent_text = controller_->GetToolbarModel()->GetText();
311  base::string16 gray_text = view_->GetGrayTextAutocompletion();
312  const bool visibly_changed_permanent_text =
313      (permanent_text_ != new_permanent_text) &&
314      (!has_focus() ||
315       (!user_input_in_progress_ &&
316        !(popup_model() && popup_model()->IsOpen()) &&
317        controller_->GetToolbarModel()->url_replacement_enabled())) &&
318      (gray_text.empty() ||
319       new_permanent_text != user_text_ + gray_text);
320
321  permanent_text_ = new_permanent_text;
322  return visibly_changed_permanent_text;
323}
324
325GURL OmniboxEditModel::PermanentURL() {
326  return URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_), std::string());
327}
328
329void OmniboxEditModel::SetUserText(const base::string16& text) {
330  SetInputInProgress(true);
331  InternalSetUserText(text);
332  omnibox_controller_->InvalidateCurrentMatch();
333  paste_state_ = NONE;
334  has_temporary_text_ = false;
335}
336
337bool OmniboxEditModel::CommitSuggestedText() {
338  const base::string16 suggestion = view_->GetGrayTextAutocompletion();
339  if (suggestion.empty())
340    return false;
341
342  const base::string16 final_text = view_->GetText() + suggestion;
343  view_->OnBeforePossibleChange();
344  view_->SetWindowTextAndCaretPos(final_text, final_text.length(), false,
345      false);
346  view_->OnAfterPossibleChange();
347  return true;
348}
349
350void OmniboxEditModel::OnChanged() {
351  // Don't call CurrentMatch() when there's no editing, as in this case we'll
352  // never actually use it.  This avoids running the autocomplete providers (and
353  // any systems they then spin up) during startup.
354  const AutocompleteMatch& current_match = user_input_in_progress_ ?
355      CurrentMatch(NULL) : AutocompleteMatch();
356
357  AutocompleteActionPredictor::Action recommended_action =
358      AutocompleteActionPredictor::ACTION_NONE;
359  if (user_input_in_progress_) {
360    InstantSearchPrerenderer* prerenderer =
361        InstantSearchPrerenderer::GetForProfile(profile_);
362    if (prerenderer &&
363        prerenderer->IsAllowed(current_match, controller_->GetWebContents()) &&
364        popup_model()->IsOpen() && has_focus()) {
365      recommended_action = AutocompleteActionPredictor::ACTION_PRERENDER;
366    } else {
367      AutocompleteActionPredictor* action_predictor =
368          predictors::AutocompleteActionPredictorFactory::GetForProfile(
369              profile_);
370      action_predictor->RegisterTransitionalMatches(user_text_, result());
371      // Confer with the AutocompleteActionPredictor to determine what action,
372      // if any, we should take. Get the recommended action here even if we
373      // don't need it so we can get stats for anyone who is opted in to UMA,
374      // but only get it if the user has actually typed something to avoid
375      // constructing it before it's needed. Note: This event is triggered as
376      // part of startup when the initial tab transitions to the start page.
377      recommended_action =
378          action_predictor->RecommendAction(user_text_, current_match);
379    }
380  }
381
382  UMA_HISTOGRAM_ENUMERATION("AutocompleteActionPredictor.Action",
383                            recommended_action,
384                            AutocompleteActionPredictor::LAST_PREDICT_ACTION);
385
386  // Hide any suggestions we might be showing.
387  view_->SetGrayTextAutocompletion(base::string16());
388
389  switch (recommended_action) {
390    case AutocompleteActionPredictor::ACTION_PRERENDER:
391      // It's possible that there is no current page, for instance if the tab
392      // has been closed or on return from a sleep state.
393      // (http://crbug.com/105689)
394      if (!delegate_->CurrentPageExists())
395        break;
396      // Ask for prerendering if the destination URL is different than the
397      // current URL.
398      if (current_match.destination_url != PermanentURL())
399        delegate_->DoPrerender(current_match);
400      break;
401    case AutocompleteActionPredictor::ACTION_PRECONNECT:
402      omnibox_controller_->DoPreconnect(current_match);
403      break;
404    case AutocompleteActionPredictor::ACTION_NONE:
405      break;
406  }
407
408  controller_->OnChanged();
409}
410
411void OmniboxEditModel::GetDataForURLExport(GURL* url,
412                                           base::string16* title,
413                                           gfx::Image* favicon) {
414  *url = CurrentMatch(NULL).destination_url;
415  if (*url == URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_),
416                                      std::string())) {
417    content::WebContents* web_contents = controller_->GetWebContents();
418    *title = web_contents->GetTitle();
419    *favicon = FaviconTabHelper::FromWebContents(web_contents)->GetFavicon();
420  }
421}
422
423bool OmniboxEditModel::CurrentTextIsURL() const {
424  if (controller_->GetToolbarModel()->WouldReplaceURL())
425    return false;
426
427  // If current text is not composed of replaced search terms and
428  // !user_input_in_progress_, then permanent text is showing and should be a
429  // URL, so no further checking is needed.  By avoiding checking in this case,
430  // we avoid calling into the autocomplete providers, and thus initializing the
431  // history system, as long as possible, which speeds startup.
432  if (!user_input_in_progress_)
433    return true;
434
435  return !AutocompleteMatch::IsSearchType(CurrentMatch(NULL).type);
436}
437
438AutocompleteMatch::Type OmniboxEditModel::CurrentTextType() const {
439  return CurrentMatch(NULL).type;
440}
441
442void OmniboxEditModel::AdjustTextForCopy(int sel_min,
443                                         bool is_all_selected,
444                                         base::string16* text,
445                                         GURL* url,
446                                         bool* write_url) {
447  *write_url = false;
448
449  // Do not adjust if selection did not start at the beginning of the field, or
450  // if the URL was omitted.
451  if ((sel_min != 0) || controller_->GetToolbarModel()->WouldReplaceURL())
452    return;
453
454  if (!user_input_in_progress_ && is_all_selected) {
455    // The user selected all the text and has not edited it. Use the url as the
456    // text so that if the scheme was stripped it's added back, and the url
457    // is unescaped (we escape parts of the url for display).
458    *url = PermanentURL();
459    *text = UTF8ToUTF16(url->spec());
460    *write_url = true;
461    return;
462  }
463
464  // We can't use CurrentTextIsURL() or GetDataForURLExport() because right now
465  // the user is probably holding down control to cause the copy, which will
466  // screw up our calculation of the desired_tld.
467  AutocompleteMatch match;
468  AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(*text,
469      KeywordIsSelected(), true, &match, NULL);
470  if (AutocompleteMatch::IsSearchType(match.type))
471    return;
472  *url = match.destination_url;
473
474  // Prefix the text with 'http://' if the text doesn't start with 'http://',
475  // the text parses as a url with a scheme of http, the user selected the
476  // entire host, and the user hasn't edited the host or manually removed the
477  // scheme.
478  GURL perm_url(PermanentURL());
479  if (perm_url.SchemeIs(content::kHttpScheme) &&
480      url->SchemeIs(content::kHttpScheme) && perm_url.host() == url->host()) {
481    *write_url = true;
482    base::string16 http = ASCIIToUTF16(content::kHttpScheme) +
483        ASCIIToUTF16(content::kStandardSchemeSeparator);
484    if (text->compare(0, http.length(), http) != 0)
485      *text = http + *text;
486  }
487}
488
489void OmniboxEditModel::SetInputInProgress(bool in_progress) {
490  if (in_progress && !user_input_since_focus_) {
491    base::TimeTicks now = base::TimeTicks::Now();
492    DCHECK(last_omnibox_focus_ <= now);
493    UMA_HISTOGRAM_TIMES(kFocusToEditTimeHistogram, now - last_omnibox_focus_);
494    user_input_since_focus_ = true;
495  }
496
497  if (user_input_in_progress_ == in_progress)
498    return;
499
500  user_input_in_progress_ = in_progress;
501  if (user_input_in_progress_) {
502    time_user_first_modified_omnibox_ = base::TimeTicks::Now();
503    content::RecordAction(content::UserMetricsAction("OmniboxInputInProgress"));
504    autocomplete_controller()->ResetSession();
505    // Once the user starts editing, re-enable URL replacement, so that it will
506    // kick in if applicable once the edit is committed or reverted. (While the
507    // edit is in progress, this won't have a visible effect.)
508    controller_->GetToolbarModel()->set_url_replacement_enabled(true);
509  }
510
511  controller_->GetToolbarModel()->set_input_in_progress(in_progress);
512  controller_->Update(NULL);
513
514  delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
515}
516
517void OmniboxEditModel::Revert() {
518  SetInputInProgress(false);
519  paste_state_ = NONE;
520  InternalSetUserText(base::string16());
521  keyword_.clear();
522  is_keyword_hint_ = false;
523  has_temporary_text_ = false;
524  view_->SetWindowTextAndCaretPos(permanent_text_,
525                                  has_focus() ? permanent_text_.length() : 0,
526                                  false, true);
527  AutocompleteActionPredictor* action_predictor =
528      predictors::AutocompleteActionPredictorFactory::GetForProfile(profile_);
529  action_predictor->ClearTransitionalMatches();
530}
531
532void OmniboxEditModel::StartAutocomplete(
533    bool has_selected_text,
534    bool prevent_inline_autocomplete) const {
535  size_t cursor_position;
536  if (inline_autocomplete_text_.empty()) {
537    // Cursor position is equivalent to the current selection's end.
538    size_t start;
539    view_->GetSelectionBounds(&start, &cursor_position);
540    // Adjust cursor position taking into account possible keyword in the user
541    // text.  We rely on DisplayTextFromUserText() method which is consistent
542    // with keyword extraction done in KeywordProvider/SearchProvider.
543    const size_t cursor_offset =
544        user_text_.length() - DisplayTextFromUserText(user_text_).length();
545    cursor_position += cursor_offset;
546  } else {
547    // There are some cases where StartAutocomplete() may be called
548    // with non-empty |inline_autocomplete_text_|.  In such cases, we cannot
549    // use the current selection, because it could result with the cursor
550    // position past the last character from the user text.  Instead,
551    // we assume that the cursor is simply at the end of input.
552    // One example is when user presses Ctrl key while having a highlighted
553    // inline autocomplete text.
554    // TODO: Rethink how we are going to handle this case to avoid
555    // inconsistent behavior when user presses Ctrl key.
556    // See http://crbug.com/165961 and http://crbug.com/165968 for more details.
557    cursor_position = user_text_.length();
558  }
559
560  GURL current_url =
561      (delegate_->CurrentPageExists() && view_->IsIndicatingQueryRefinement()) ?
562      delegate_->GetURL() : GURL();
563  bool keyword_is_selected = KeywordIsSelected();
564  omnibox_controller_->StartAutocomplete(
565      user_text_,
566      cursor_position,
567      current_url,
568      ClassifyPage(),
569      prevent_inline_autocomplete || just_deleted_text_ ||
570      (has_selected_text && inline_autocomplete_text_.empty()) ||
571      (paste_state_ != NONE),
572      keyword_is_selected,
573      keyword_is_selected || allow_exact_keyword_match_);
574}
575
576void OmniboxEditModel::StopAutocomplete() {
577  autocomplete_controller()->Stop(true);
578}
579
580bool OmniboxEditModel::CanPasteAndGo(const base::string16& text) const {
581  if (!view_->command_updater()->IsCommandEnabled(IDC_OPEN_CURRENT_URL))
582    return false;
583
584  AutocompleteMatch match;
585  ClassifyStringForPasteAndGo(text, &match, NULL);
586  return match.destination_url.is_valid();
587}
588
589void OmniboxEditModel::PasteAndGo(const base::string16& text) {
590  DCHECK(CanPasteAndGo(text));
591  UMA_HISTOGRAM_COUNTS("Omnibox.PasteAndGo", 1);
592
593  view_->RevertAll();
594  AutocompleteMatch match;
595  GURL alternate_nav_url;
596  ClassifyStringForPasteAndGo(text, &match, &alternate_nav_url);
597  view_->OpenMatch(match, CURRENT_TAB, alternate_nav_url,
598                   OmniboxPopupModel::kNoMatch);
599}
600
601bool OmniboxEditModel::IsPasteAndSearch(const base::string16& text) const {
602  AutocompleteMatch match;
603  ClassifyStringForPasteAndGo(text, &match, NULL);
604  return AutocompleteMatch::IsSearchType(match.type);
605}
606
607void OmniboxEditModel::AcceptInput(WindowOpenDisposition disposition,
608                                   bool for_drop) {
609  // Get the URL and transition type for the selected entry.
610  GURL alternate_nav_url;
611  AutocompleteMatch match = CurrentMatch(&alternate_nav_url);
612
613  // If CTRL is down it means the user wants to append ".com" to the text he
614  // typed. If we can successfully generate a URL_WHAT_YOU_TYPED match doing
615  // that, then we use this. These matches are marked as generated by the
616  // HistoryURLProvider so we only generate them if this provider is present.
617  if (control_key_state_ == DOWN_WITHOUT_CHANGE && !KeywordIsSelected() &&
618      autocomplete_controller()->history_url_provider()) {
619    // Generate a new AutocompleteInput, copying the latest one but using "com"
620    // as the desired TLD. Then use this autocomplete input to generate a
621    // URL_WHAT_YOU_TYPED AutocompleteMatch. Note that using the most recent
622    // input instead of the currently visible text means we'll ignore any
623    // visible inline autocompletion: if a user types "foo" and is autocompleted
624    // to "foodnetwork.com", ctrl-enter will navigate to "foo.com", not
625    // "foodnetwork.com".  At the time of writing, this behavior matches
626    // Internet Explorer, but not Firefox.
627    const AutocompleteInput& old_input = autocomplete_controller()->input();
628    AutocompleteInput input(
629      has_temporary_text_ ?
630          UserTextFromDisplayText(view_->GetText())  : old_input.text(),
631      old_input.cursor_position(), ASCIIToUTF16("com"),
632      GURL(), old_input.current_page_classification(),
633      old_input.prevent_inline_autocomplete(), old_input.prefer_keyword(),
634      old_input.allow_exact_keyword_match(), old_input.matches_requested());
635    AutocompleteMatch url_match(
636        autocomplete_controller()->history_url_provider()->SuggestExactInput(
637            input.text(), input.canonicalized_url(), false));
638
639    if (url_match.destination_url.is_valid()) {
640      // We have a valid URL, we use this newly generated AutocompleteMatch.
641      match = url_match;
642      alternate_nav_url = GURL();
643    }
644  }
645
646  if (!match.destination_url.is_valid())
647    return;
648
649  if ((match.transition == content::PAGE_TRANSITION_TYPED) &&
650      (match.destination_url ==
651       URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_), std::string()))) {
652    // When the user hit enter on the existing permanent URL, treat it like a
653    // reload for scoring purposes.  We could detect this by just checking
654    // user_input_in_progress_, but it seems better to treat "edits" that end
655    // up leaving the URL unchanged (e.g. deleting the last character and then
656    // retyping it) as reloads too.  We exclude non-TYPED transitions because if
657    // the transition is GENERATED, the user input something that looked
658    // different from the current URL, even if it wound up at the same place
659    // (e.g. manually retyping the same search query), and it seems wrong to
660    // treat this as a reload.
661    match.transition = content::PAGE_TRANSITION_RELOAD;
662  } else if (for_drop || ((paste_state_ != NONE) &&
663                          match.is_history_what_you_typed_match)) {
664    // When the user pasted in a URL and hit enter, score it like a link click
665    // rather than a normal typed URL, so it doesn't get inline autocompleted
666    // as aggressively later.
667    match.transition = content::PAGE_TRANSITION_LINK;
668  }
669
670  const TemplateURL* template_url = match.GetTemplateURL(profile_, false);
671  if (template_url && template_url->url_ref().HasGoogleBaseURLs())
672    GoogleURLTracker::GoogleURLSearchCommitted(profile_);
673
674  view_->OpenMatch(match, disposition, alternate_nav_url,
675                   OmniboxPopupModel::kNoMatch);
676}
677
678void OmniboxEditModel::OpenMatch(AutocompleteMatch match,
679                                 WindowOpenDisposition disposition,
680                                 const GURL& alternate_nav_url,
681                                 size_t index) {
682  const base::TimeTicks& now(base::TimeTicks::Now());
683  base::TimeDelta elapsed_time_since_user_first_modified_omnibox(
684      now - time_user_first_modified_omnibox_);
685  autocomplete_controller()->UpdateMatchDestinationURL(
686      elapsed_time_since_user_first_modified_omnibox, &match);
687
688  const base::string16& user_text =
689      user_input_in_progress_ ? user_text_ : permanent_text_;
690  scoped_ptr<OmniboxNavigationObserver> observer(
691      new OmniboxNavigationObserver(
692          profile_, user_text, match,
693          autocomplete_controller()->history_url_provider()->SuggestExactInput(
694              user_text, alternate_nav_url,
695              AutocompleteInput::HasHTTPScheme(user_text))));
696
697  // We only care about cases where there is a selection (i.e. the popup is
698  // open).
699  if (popup_model() && popup_model()->IsOpen()) {
700    base::TimeDelta elapsed_time_since_last_change_to_default_match(
701        now - autocomplete_controller()->last_time_default_match_changed());
702    // These elapsed times don't really make sense for ZeroSuggest matches
703    // (because the user does not modify the omnibox for ZeroSuggest), so for
704    // those we set the elapsed times to something that will be ignored by
705    // metrics_log.cc.
706    if (match.provider &&
707        (match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST)) {
708      elapsed_time_since_user_first_modified_omnibox =
709          base::TimeDelta::FromMilliseconds(-1);
710      elapsed_time_since_last_change_to_default_match =
711          base::TimeDelta::FromMilliseconds(-1);
712    }
713    OmniboxLog log(
714        user_text,
715        just_deleted_text_,
716        autocomplete_controller()->input().type(),
717        popup_model()->selected_line(),
718        -1,  // don't yet know tab ID; set later if appropriate
719        ClassifyPage(),
720        elapsed_time_since_user_first_modified_omnibox,
721        match.inline_autocompletion.length(),
722        elapsed_time_since_last_change_to_default_match,
723        result());
724
725    DCHECK(user_input_in_progress_ || (match.provider &&
726           (match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST)))
727        << "We didn't get here through the expected series of calls. "
728        << "time_user_first_modified_omnibox_ is not set correctly and other "
729        << "things may be wrong. Match provider: "
730        << (match.provider ? match.provider->GetName() : "NULL");
731    DCHECK(log.elapsed_time_since_user_first_modified_omnibox >=
732           log.elapsed_time_since_last_change_to_default_match)
733        << "We should've got the notification that the user modified the "
734        << "omnibox text at same time or before the most recent time the "
735        << "default match changed.";
736
737    if (index != OmniboxPopupModel::kNoMatch)
738      log.selected_index = index;
739
740    if ((disposition == CURRENT_TAB) && delegate_->CurrentPageExists()) {
741      // If we know the destination is being opened in the current tab,
742      // we can easily get the tab ID.  (If it's being opened in a new
743      // tab, we don't know the tab ID yet.)
744      log.tab_id = delegate_->GetSessionID().id();
745    }
746    autocomplete_controller()->AddProvidersInfo(&log.providers_info);
747    content::NotificationService::current()->Notify(
748        chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
749        content::Source<Profile>(profile_),
750        content::Details<OmniboxLog>(&log));
751    HISTOGRAM_ENUMERATION("Omnibox.EventCount", 1, 2);
752    DCHECK(!last_omnibox_focus_.is_null())
753        << "An omnibox focus should have occurred before opening a match.";
754    UMA_HISTOGRAM_TIMES(kFocusToOpenTimeHistogram, now - last_omnibox_focus_);
755  }
756
757  TemplateURL* template_url = match.GetTemplateURL(profile_, false);
758  if (template_url) {
759    if (match.transition == content::PAGE_TRANSITION_KEYWORD) {
760      // The user is using a non-substituting keyword or is explicitly in
761      // keyword mode.
762
763      // Don't increment usage count for extension keywords.
764      if (delegate_->ProcessExtensionKeyword(template_url, match,
765                                             disposition)) {
766        observer->OnSuccessfulNavigation();
767        if (disposition != NEW_BACKGROUND_TAB)
768          view_->RevertAll();
769        return;
770      }
771
772      content::RecordAction(content::UserMetricsAction("AcceptedKeyword"));
773      TemplateURLServiceFactory::GetForProfile(profile_)->IncrementUsageCount(
774          template_url);
775    } else {
776      DCHECK_EQ(content::PAGE_TRANSITION_GENERATED, match.transition);
777      // NOTE: We purposefully don't increment the usage count of the default
778      // search engine here like we do for explicit keywords above; see comments
779      // in template_url.h.
780    }
781
782    // TODO(pkasting): This histogram obsoletes the next one.  Remove the next
783    // one in Chrome 32 or later.
784    UMA_HISTOGRAM_ENUMERATION("Omnibox.SearchEngineType",
785        TemplateURLPrepopulateData::GetEngineType(*template_url),
786        SEARCH_ENGINE_MAX);
787    // NOTE: Non-prepopulated engines will all have ID 0, which is fine as
788    // the prepopulate IDs start at 1.  Distribution-specific engines will
789    // all have IDs above the maximum, and will be automatically lumped
790    // together in an "overflow" bucket in the histogram.
791    UMA_HISTOGRAM_ENUMERATION("Omnibox.SearchEngine",
792        template_url->prepopulate_id(),
793        TemplateURLPrepopulateData::kMaxPrepopulatedEngineID);
794  }
795
796  // Get the current text before we call RevertAll() which will clear it.
797  base::string16 current_text = view_->GetText();
798
799  if (disposition != NEW_BACKGROUND_TAB) {
800    base::AutoReset<bool> tmp(&in_revert_, true);
801    view_->RevertAll();  // Revert the box to its unedited state.
802  }
803
804  if (match.type == AutocompleteMatchType::EXTENSION_APP) {
805    ExtensionAppProvider::LaunchAppFromOmnibox(match, profile_, disposition);
806    observer->OnSuccessfulNavigation();
807  } else {
808    RecordPercentageMatchHistogram(
809        permanent_text_, current_text,
810        controller_->GetToolbarModel()->WouldReplaceURL(),
811        match.transition, view_->GetWidth());
812
813    // Track whether the destination URL sends us to a search results page
814    // using the default search provider.
815    if (TemplateURLServiceFactory::GetForProfile(profile_)->
816        IsSearchResultsPageFromDefaultSearchProvider(match.destination_url)) {
817      content::RecordAction(
818          content::UserMetricsAction("OmniboxDestinationURLIsSearchOnDSP"));
819    }
820
821    if (match.destination_url.is_valid()) {
822      // This calls RevertAll again.
823      base::AutoReset<bool> tmp(&in_revert_, true);
824      controller_->OnAutocompleteAccept(
825          match.destination_url, disposition,
826          content::PageTransitionFromInt(
827              match.transition | content::PAGE_TRANSITION_FROM_ADDRESS_BAR));
828      if (observer->load_state() != OmniboxNavigationObserver::LOAD_NOT_SEEN)
829        ignore_result(observer.release());  // The observer will delete itself.
830    }
831  }
832
833  if (match.starred)
834    RecordBookmarkLaunch(NULL, BOOKMARK_LAUNCH_LOCATION_OMNIBOX);
835}
836
837bool OmniboxEditModel::AcceptKeyword(EnteredKeywordModeMethod entered_method) {
838  DCHECK(is_keyword_hint_ && !keyword_.empty());
839
840  autocomplete_controller()->Stop(false);
841  is_keyword_hint_ = false;
842
843  if (popup_model() && popup_model()->IsOpen())
844    popup_model()->SetSelectedLineState(OmniboxPopupModel::KEYWORD);
845  else
846    StartAutocomplete(false, true);
847
848  // Ensure the current selection is saved before showing keyword mode
849  // so that moving to another line and then reverting the text will restore
850  // the current state properly.
851  bool save_original_selection = !has_temporary_text_;
852  has_temporary_text_ = true;
853  view_->OnTemporaryTextMaybeChanged(
854      DisplayTextFromUserText(CurrentMatch(NULL).fill_into_edit),
855      save_original_selection, true);
856
857  content::RecordAction(content::UserMetricsAction("AcceptedKeywordHint"));
858  UMA_HISTOGRAM_ENUMERATION(kEnteredKeywordModeHistogram, entered_method,
859                            ENTERED_KEYWORD_MODE_NUM_ITEMS);
860
861  return true;
862}
863
864void OmniboxEditModel::AcceptTemporaryTextAsUserText() {
865  InternalSetUserText(UserTextFromDisplayText(view_->GetText()));
866  has_temporary_text_ = false;
867  delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
868}
869
870void OmniboxEditModel::ClearKeyword(const base::string16& visible_text) {
871  autocomplete_controller()->Stop(false);
872  omnibox_controller_->ClearPopupKeywordMode();
873
874  const base::string16 window_text(keyword_ + visible_text);
875
876  // Only reset the result if the edit text has changed since the
877  // keyword was accepted, or if the popup is closed.
878  if (just_deleted_text_ || !visible_text.empty() ||
879      !(popup_model() && popup_model()->IsOpen())) {
880    view_->OnBeforePossibleChange();
881    view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length(),
882        false, false);
883    keyword_.clear();
884    is_keyword_hint_ = false;
885    view_->OnAfterPossibleChange();
886    just_deleted_text_ = true;  // OnAfterPossibleChange() fails to clear this
887                                // since the edit contents have actually grown
888                                // longer.
889  } else {
890    is_keyword_hint_ = true;
891    view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length(),
892        false, true);
893  }
894}
895
896void OmniboxEditModel::OnSetFocus(bool control_down) {
897  last_omnibox_focus_ = base::TimeTicks::Now();
898  user_input_since_focus_ = false;
899
900  // If the omnibox lost focus while the caret was hidden and then regained
901  // focus, OnSetFocus() is called and should restore visibility. Note that
902  // focus can be regained without an accompanying call to
903  // OmniboxView::SetFocus(), e.g. by tabbing in.
904  SetFocusState(OMNIBOX_FOCUS_VISIBLE, OMNIBOX_FOCUS_CHANGE_EXPLICIT);
905  control_key_state_ = control_down ? DOWN_WITHOUT_CHANGE : UP;
906
907  // Try to get ZeroSuggest suggestions if a page is loaded and the user has
908  // not been typing in the omnibox.  The |user_input_in_progress_| check is
909  // used to detect the case where this function is called after right-clicking
910  // in the omnibox and selecting paste in Linux (in which case we actually get
911  // the OnSetFocus() call after the process of handling the paste has kicked
912  // off).
913  // TODO(hfung): Remove this when crbug/271590 is fixed.
914  if (delegate_->CurrentPageExists() && !user_input_in_progress_) {
915    // TODO(jered): We may want to merge this into Start() and just call that
916    // here rather than having a special entry point for zero-suggest.  Note
917    // that we avoid PermanentURL() here because it's not guaranteed to give us
918    // the actual underlying current URL, e.g. if we're on the NTP and the
919    // |permanent_text_| is empty.
920    autocomplete_controller()->StartZeroSuggest(delegate_->GetURL(),
921                                                ClassifyPage(),
922                                                permanent_text_);
923  }
924
925  delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
926}
927
928void OmniboxEditModel::SetCaretVisibility(bool visible) {
929  // Caret visibility only matters if the omnibox has focus.
930  if (focus_state_ != OMNIBOX_FOCUS_NONE) {
931    SetFocusState(visible ? OMNIBOX_FOCUS_VISIBLE : OMNIBOX_FOCUS_INVISIBLE,
932                  OMNIBOX_FOCUS_CHANGE_EXPLICIT);
933  }
934}
935
936void OmniboxEditModel::OnWillKillFocus(gfx::NativeView view_gaining_focus) {
937  InstantController* instant = GetInstantController();
938  if (instant) {
939    instant->OmniboxFocusChanged(OMNIBOX_FOCUS_NONE,
940                                 OMNIBOX_FOCUS_CHANGE_EXPLICIT,
941                                 view_gaining_focus);
942  }
943
944  // TODO(jered): Rip this out along with StartZeroSuggest.
945  autocomplete_controller()->StopZeroSuggest();
946  delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
947}
948
949void OmniboxEditModel::OnKillFocus() {
950  // TODO(samarth): determine if it is safe to move the call to
951  // OmniboxFocusChanged() from OnWillKillFocus() to here, which would let us
952  // just call SetFocusState() to handle the state change.
953  focus_state_ = OMNIBOX_FOCUS_NONE;
954  focus_source_ = INVALID;
955  control_key_state_ = UP;
956  paste_state_ = NONE;
957}
958
959bool OmniboxEditModel::OnEscapeKeyPressed() {
960  const AutocompleteMatch& match = CurrentMatch(NULL);
961  if (has_temporary_text_) {
962    if (match.destination_url != original_url_) {
963      RevertTemporaryText(true);
964      return true;
965    }
966  }
967
968  // We do not clear the pending entry from the omnibox when a load is first
969  // stopped.  If the user presses Escape while stopped, we clear it.
970  if (delegate_->CurrentPageExists() && !delegate_->IsLoading()) {
971    delegate_->GetNavigationController().DiscardNonCommittedEntries();
972    view_->Update();
973  }
974
975  // If the user wasn't editing, but merely had focus in the edit, allow <esc>
976  // to be processed as an accelerator, so it can still be used to stop a load.
977  // When the permanent text isn't all selected we still fall through to the
978  // SelectAll() call below so users can arrow around in the text and then hit
979  // <esc> to quickly replace all the text; this matches IE.
980  const bool has_zero_suggest_match = match.provider &&
981      (match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST);
982  if (!has_zero_suggest_match && !user_input_in_progress_ &&
983      view_->IsSelectAll())
984    return false;
985
986  if (!user_text_.empty()) {
987    UMA_HISTOGRAM_ENUMERATION(kOmniboxUserTextClearedHistogram,
988                              OMNIBOX_USER_TEXT_CLEARED_WITH_ESCAPE,
989                              OMNIBOX_USER_TEXT_CLEARED_NUM_OF_ITEMS);
990  }
991  view_->RevertAll();
992  view_->SelectAll(true);
993  return true;
994}
995
996void OmniboxEditModel::OnControlKeyChanged(bool pressed) {
997  if (pressed == (control_key_state_ == UP))
998    control_key_state_ = pressed ? DOWN_WITHOUT_CHANGE : UP;
999}
1000
1001void OmniboxEditModel::OnPaste() {
1002  UMA_HISTOGRAM_COUNTS("Omnibox.Paste", 1);
1003  paste_state_ = PASTING;
1004}
1005
1006void OmniboxEditModel::OnUpOrDownKeyPressed(int count) {
1007  // NOTE: This purposefully doesn't trigger any code that resets paste_state_.
1008  if (popup_model() && popup_model()->IsOpen()) {
1009    // The popup is open, so the user should be able to interact with it
1010    // normally.
1011    popup_model()->Move(count);
1012    return;
1013  }
1014
1015  if (!query_in_progress()) {
1016    // The popup is neither open nor working on a query already.  So, start an
1017    // autocomplete query for the current text.  This also sets
1018    // user_input_in_progress_ to true, which we want: if the user has started
1019    // to interact with the popup, changing the permanent_text_ shouldn't change
1020    // the displayed text.
1021    // Note: This does not force the popup to open immediately.
1022    // TODO(pkasting): We should, in fact, force this particular query to open
1023    // the popup immediately.
1024    if (!user_input_in_progress_)
1025      InternalSetUserText(permanent_text_);
1026    view_->UpdatePopup();
1027    return;
1028  }
1029
1030  // TODO(pkasting): The popup is working on a query but is not open.  We should
1031  // force it to open immediately.
1032}
1033
1034void OmniboxEditModel::OnPopupDataChanged(
1035    const base::string16& text,
1036    GURL* destination_for_temporary_text_change,
1037    const base::string16& keyword,
1038    bool is_keyword_hint) {
1039  // The popup changed its data, the match in the controller is no longer valid.
1040  omnibox_controller_->InvalidateCurrentMatch();
1041
1042  // Update keyword/hint-related local state.
1043  bool keyword_state_changed = (keyword_ != keyword) ||
1044      ((is_keyword_hint_ != is_keyword_hint) && !keyword.empty());
1045  if (keyword_state_changed) {
1046    keyword_ = keyword;
1047    is_keyword_hint_ = is_keyword_hint;
1048
1049    // |is_keyword_hint_| should always be false if |keyword_| is empty.
1050    DCHECK(!keyword_.empty() || !is_keyword_hint_);
1051  }
1052
1053  // Handle changes to temporary text.
1054  if (destination_for_temporary_text_change != NULL) {
1055    const bool save_original_selection = !has_temporary_text_;
1056    if (save_original_selection) {
1057      // Save the original selection and URL so it can be reverted later.
1058      has_temporary_text_ = true;
1059      original_url_ = *destination_for_temporary_text_change;
1060      inline_autocomplete_text_.clear();
1061      view_->OnInlineAutocompleteTextCleared();
1062    }
1063    if (control_key_state_ == DOWN_WITHOUT_CHANGE) {
1064      // Arrowing around the popup cancels control-enter.
1065      control_key_state_ = DOWN_WITH_CHANGE;
1066      // Now things are a bit screwy: the desired_tld has changed, but if we
1067      // update the popup, the new order of entries won't match the old, so the
1068      // user's selection gets screwy; and if we don't update the popup, and the
1069      // user reverts, then the selected item will be as if control is still
1070      // pressed, even though maybe it isn't any more.  There is no obvious
1071      // right answer here :(
1072    }
1073    view_->OnTemporaryTextMaybeChanged(DisplayTextFromUserText(text),
1074                                       save_original_selection, true);
1075    return;
1076  }
1077
1078  bool call_controller_onchanged = true;
1079  inline_autocomplete_text_ = text;
1080  if (inline_autocomplete_text_.empty())
1081    view_->OnInlineAutocompleteTextCleared();
1082
1083  base::string16 user_text = user_input_in_progress_ ? user_text_
1084                                                     : permanent_text_;
1085  if (keyword_state_changed && KeywordIsSelected()) {
1086    // If we reach here, the user most likely entered keyword mode by inserting
1087    // a space between a keyword name and a search string (as pressing space or
1088    // tab after the keyword name alone would have been be handled in
1089    // MaybeAcceptKeywordBySpace() by calling AcceptKeyword(), which won't reach
1090    // here).  In this case, we don't want to call
1091    // OnInlineAutocompleteTextMaybeChanged() as normal, because that will
1092    // correctly change the text (to the search string alone) but move the caret
1093    // to the end of the string; instead we want the caret at the start of the
1094    // search string since that's where it was in the original input.  So we set
1095    // the text and caret position directly.
1096    //
1097    // It may also be possible to reach here if we're reverting from having
1098    // temporary text back to a default match that's a keyword search, but in
1099    // that case the RevertTemporaryText() call below will reset the caret or
1100    // selection correctly so the caret positioning we do here won't matter.
1101    view_->SetWindowTextAndCaretPos(DisplayTextFromUserText(user_text), 0,
1102                                                            false, false);
1103  } else if (view_->OnInlineAutocompleteTextMaybeChanged(
1104             DisplayTextFromUserText(user_text + inline_autocomplete_text_),
1105             DisplayTextFromUserText(user_text).length())) {
1106    call_controller_onchanged = false;
1107  }
1108
1109  // If |has_temporary_text_| is true, then we previously had a manual selection
1110  // but now don't (or |destination_for_temporary_text_change| would have been
1111  // non-NULL). This can happen when deleting the selected item in the popup.
1112  // In this case, we've already reverted the popup to the default match, so we
1113  // need to revert ourselves as well.
1114  if (has_temporary_text_) {
1115    RevertTemporaryText(false);
1116    call_controller_onchanged = false;
1117  }
1118
1119  // We need to invoke OnChanged in case the destination url changed (as could
1120  // happen when control is toggled).
1121  if (call_controller_onchanged)
1122    OnChanged();
1123}
1124
1125bool OmniboxEditModel::OnAfterPossibleChange(const base::string16& old_text,
1126                                             const base::string16& new_text,
1127                                             size_t selection_start,
1128                                             size_t selection_end,
1129                                             bool selection_differs,
1130                                             bool text_differs,
1131                                             bool just_deleted_text,
1132                                             bool allow_keyword_ui_change) {
1133  // Update the paste state as appropriate: if we're just finishing a paste
1134  // that replaced all the text, preserve that information; otherwise, if we've
1135  // made some other edit, clear paste tracking.
1136  if (paste_state_ == PASTING)
1137    paste_state_ = PASTED;
1138  else if (text_differs)
1139    paste_state_ = NONE;
1140
1141  if (text_differs || selection_differs) {
1142    // Record current focus state for this input if we haven't already.
1143    if (focus_source_ == INVALID) {
1144      // We should generally expect the omnibox to have focus at this point, but
1145      // it doesn't always on Linux. This is because, unlike other platforms,
1146      // right clicking in the omnibox on Linux doesn't focus it. So pasting via
1147      // right-click can change the contents without focusing the omnibox.
1148      // TODO(samarth): fix Linux focus behavior and add a DCHECK here to
1149      // check that the omnibox does have focus.
1150      focus_source_ = (focus_state_ == OMNIBOX_FOCUS_INVISIBLE) ?
1151          FAKEBOX : OMNIBOX;
1152    }
1153
1154    // Restore caret visibility whenever the user changes text or selection in
1155    // the omnibox.
1156    SetFocusState(OMNIBOX_FOCUS_VISIBLE, OMNIBOX_FOCUS_CHANGE_TYPING);
1157  }
1158
1159  // Modifying the selection counts as accepting the autocompleted text.
1160  const bool user_text_changed =
1161      text_differs || (selection_differs && !inline_autocomplete_text_.empty());
1162
1163  // If something has changed while the control key is down, prevent
1164  // "ctrl-enter" until the control key is released.
1165  if ((text_differs || selection_differs) &&
1166      (control_key_state_ == DOWN_WITHOUT_CHANGE))
1167    control_key_state_ = DOWN_WITH_CHANGE;
1168
1169  if (!user_text_changed)
1170    return false;
1171
1172  // If the user text has not changed, we do not want to change the model's
1173  // state associated with the text.  Otherwise, we can get surprising behavior
1174  // where the autocompleted text unexpectedly reappears, e.g. crbug.com/55983
1175  InternalSetUserText(UserTextFromDisplayText(new_text));
1176  has_temporary_text_ = false;
1177
1178  // Track when the user has deleted text so we won't allow inline
1179  // autocomplete.
1180  just_deleted_text_ = just_deleted_text;
1181
1182  if (user_input_in_progress_ && user_text_.empty()) {
1183    // Log cases where the user started editing and then subsequently cleared
1184    // all the text.  Note that this explicitly doesn't catch cases like
1185    // "hit ctrl-l to select whole edit contents, then hit backspace", because
1186    // in such cases, |user_input_in_progress| won't be true here.
1187    UMA_HISTOGRAM_ENUMERATION(kOmniboxUserTextClearedHistogram,
1188                              OMNIBOX_USER_TEXT_CLEARED_BY_EDITING,
1189                              OMNIBOX_USER_TEXT_CLEARED_NUM_OF_ITEMS);
1190  }
1191
1192  const bool no_selection = selection_start == selection_end;
1193
1194  // Update the popup for the change, in the process changing to keyword mode
1195  // if the user hit space in mid-string after a keyword.
1196  // |allow_exact_keyword_match_| will be used by StartAutocomplete() method,
1197  // which will be called by |view_->UpdatePopup()|; so after that returns we
1198  // can safely reset this flag.
1199  allow_exact_keyword_match_ = text_differs && allow_keyword_ui_change &&
1200      !just_deleted_text && no_selection &&
1201      CreatedKeywordSearchByInsertingSpaceInMiddle(old_text, user_text_,
1202                                                   selection_start);
1203  if (allow_exact_keyword_match_) {
1204    UMA_HISTOGRAM_ENUMERATION(kEnteredKeywordModeHistogram,
1205                              ENTERED_KEYWORD_MODE_VIA_SPACE_IN_MIDDLE,
1206                              ENTERED_KEYWORD_MODE_NUM_ITEMS);
1207  }
1208  view_->UpdatePopup();
1209  allow_exact_keyword_match_ = false;
1210
1211  // Change to keyword mode if the user is now pressing space after a keyword
1212  // name.  Note that if this is the case, then even if there was no keyword
1213  // hint when we entered this function (e.g. if the user has used space to
1214  // replace some selected text that was adjoined to this keyword), there will
1215  // be one now because of the call to UpdatePopup() above; so it's safe for
1216  // MaybeAcceptKeywordBySpace() to look at |keyword_| and |is_keyword_hint_| to
1217  // determine what keyword, if any, is applicable.
1218  //
1219  // If MaybeAcceptKeywordBySpace() accepts the keyword and returns true, that
1220  // will have updated our state already, so in that case we don't also return
1221  // true from this function.
1222  return !(text_differs && allow_keyword_ui_change && !just_deleted_text &&
1223           no_selection && (selection_start == user_text_.length()) &&
1224           MaybeAcceptKeywordBySpace(user_text_));
1225}
1226
1227// TODO(beaudoin): Merge OnPopupDataChanged with this method once the popup
1228// handling has completely migrated to omnibox_controller.
1229void OmniboxEditModel::OnCurrentMatchChanged() {
1230  has_temporary_text_ = false;
1231
1232  const AutocompleteMatch& match = omnibox_controller_->current_match();
1233
1234  // We store |keyword| and |is_keyword_hint| in temporary variables since
1235  // OnPopupDataChanged use their previous state to detect changes.
1236  base::string16 keyword;
1237  bool is_keyword_hint;
1238  match.GetKeywordUIState(profile_, &keyword, &is_keyword_hint);
1239  if (popup_model())
1240    popup_model()->OnResultChanged();
1241  // OnPopupDataChanged() resets OmniboxController's |current_match_| early
1242  // on.  Therefore, copy match.inline_autocompletion to a temp to preserve
1243  // its value across the entire call.
1244  const base::string16 inline_autocompletion(match.inline_autocompletion);
1245  OnPopupDataChanged(inline_autocompletion, NULL, keyword, is_keyword_hint);
1246}
1247
1248InstantController* OmniboxEditModel::GetInstantController() const {
1249  return controller_->GetInstant();
1250}
1251
1252// static
1253const char OmniboxEditModel::kCutOrCopyAllTextHistogram[] =
1254    "Omnibox.CutOrCopyAllText";
1255
1256bool OmniboxEditModel::query_in_progress() const {
1257  return !autocomplete_controller()->done();
1258}
1259
1260void OmniboxEditModel::InternalSetUserText(const base::string16& text) {
1261  user_text_ = text;
1262  just_deleted_text_ = false;
1263  inline_autocomplete_text_.clear();
1264  view_->OnInlineAutocompleteTextCleared();
1265}
1266
1267bool OmniboxEditModel::KeywordIsSelected() const {
1268  return !is_keyword_hint_ && !keyword_.empty();
1269}
1270
1271void OmniboxEditModel::ClearPopupKeywordMode() const {
1272  omnibox_controller_->ClearPopupKeywordMode();
1273}
1274
1275base::string16 OmniboxEditModel::DisplayTextFromUserText(
1276    const base::string16& text) const {
1277  return KeywordIsSelected() ?
1278      KeywordProvider::SplitReplacementStringFromInput(text, false) : text;
1279}
1280
1281base::string16 OmniboxEditModel::UserTextFromDisplayText(
1282    const base::string16& text) const {
1283  return KeywordIsSelected() ? (keyword_ + char16(' ') + text) : text;
1284}
1285
1286void OmniboxEditModel::GetInfoForCurrentText(AutocompleteMatch* match,
1287                                             GURL* alternate_nav_url) const {
1288  DCHECK(match != NULL);
1289
1290  if (controller_->GetToolbarModel()->WouldPerformSearchTermReplacement(
1291      false)) {
1292    // Any time the user hits enter on the unchanged omnibox, we should reload.
1293    // When we're not extracting search terms, AcceptInput() will take care of
1294    // this (see code referring to PAGE_TRANSITION_RELOAD there), but when we're
1295    // extracting search terms, the conditionals there won't fire, so we
1296    // explicitly set up a match that will reload here.
1297
1298    // It's important that we fetch the current visible URL to reload instead of
1299    // just getting a "search what you typed" URL from
1300    // SearchProvider::CreateSearchSuggestion(), since the user may be in a
1301    // non-default search mode such as image search.
1302    match->type = AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED;
1303    match->destination_url =
1304        delegate_->GetNavigationController().GetVisibleEntry()->GetURL();
1305    match->transition = content::PAGE_TRANSITION_RELOAD;
1306  } else if (query_in_progress() ||
1307             (popup_model() && popup_model()->IsOpen())) {
1308    if (query_in_progress()) {
1309      // It's technically possible for |result| to be empty if no provider
1310      // returns a synchronous result but the query has not completed
1311      // synchronously; pratically, however, that should never actually happen.
1312      if (result().empty())
1313        return;
1314      // The user cannot have manually selected a match, or the query would have
1315      // stopped. So the default match must be the desired selection.
1316      *match = *result().default_match();
1317    } else {
1318      // If there are no results, the popup should be closed, so we shouldn't
1319      // have gotten here.
1320      CHECK(!result().empty());
1321      CHECK(popup_model()->selected_line() < result().size());
1322      *match = result().match_at(popup_model()->selected_line());
1323    }
1324    if (alternate_nav_url &&
1325        (!popup_model() || popup_model()->manually_selected_match().empty()))
1326      *alternate_nav_url = result().alternate_nav_url();
1327  } else {
1328    AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(
1329        UserTextFromDisplayText(view_->GetText()), KeywordIsSelected(), true,
1330        match, alternate_nav_url);
1331  }
1332}
1333
1334void OmniboxEditModel::RevertTemporaryText(bool revert_popup) {
1335  // The user typed something, then selected a different item.  Restore the
1336  // text they typed and change back to the default item.
1337  // NOTE: This purposefully does not reset paste_state_.
1338  just_deleted_text_ = false;
1339  has_temporary_text_ = false;
1340
1341  if (revert_popup && popup_model())
1342    popup_model()->ResetToDefaultMatch();
1343  view_->OnRevertTemporaryText();
1344}
1345
1346bool OmniboxEditModel::MaybeAcceptKeywordBySpace(
1347    const base::string16& new_text) {
1348  size_t keyword_length = new_text.length() - 1;
1349  return (paste_state_ == NONE) && is_keyword_hint_ && !keyword_.empty() &&
1350      inline_autocomplete_text_.empty() &&
1351      (keyword_.length() == keyword_length) &&
1352      IsSpaceCharForAcceptingKeyword(new_text[keyword_length]) &&
1353      !new_text.compare(0, keyword_length, keyword_, 0, keyword_length) &&
1354      AcceptKeyword(ENTERED_KEYWORD_MODE_VIA_SPACE_AT_END);
1355}
1356
1357bool OmniboxEditModel::CreatedKeywordSearchByInsertingSpaceInMiddle(
1358    const base::string16& old_text,
1359    const base::string16& new_text,
1360    size_t caret_position) const {
1361  DCHECK_GE(new_text.length(), caret_position);
1362
1363  // Check simple conditions first.
1364  if ((paste_state_ != NONE) || (caret_position < 2) ||
1365      (old_text.length() < caret_position) ||
1366      (new_text.length() == caret_position))
1367    return false;
1368  size_t space_position = caret_position - 1;
1369  if (!IsSpaceCharForAcceptingKeyword(new_text[space_position]) ||
1370      IsWhitespace(new_text[space_position - 1]) ||
1371      new_text.compare(0, space_position, old_text, 0, space_position) ||
1372      !new_text.compare(space_position, new_text.length() - space_position,
1373                        old_text, space_position,
1374                        old_text.length() - space_position)) {
1375    return false;
1376  }
1377
1378  // Then check if the text before the inserted space matches a keyword.
1379  base::string16 keyword;
1380  TrimWhitespace(new_text.substr(0, space_position), TRIM_LEADING, &keyword);
1381  return !keyword.empty() && !autocomplete_controller()->keyword_provider()->
1382      GetKeywordForText(keyword).empty();
1383}
1384
1385//  static
1386bool OmniboxEditModel::IsSpaceCharForAcceptingKeyword(wchar_t c) {
1387  switch (c) {
1388    case 0x0020:  // Space
1389    case 0x3000:  // Ideographic Space
1390      return true;
1391    default:
1392      return false;
1393  }
1394}
1395
1396AutocompleteInput::PageClassification OmniboxEditModel::ClassifyPage() const {
1397  if (!delegate_->CurrentPageExists())
1398    return AutocompleteInput::OTHER;
1399  if (delegate_->IsInstantNTP()) {
1400    // Note that we treat OMNIBOX as the source if focus_source_ is INVALID,
1401    // i.e., if input isn't actually in progress.
1402    return (focus_source_ == FAKEBOX) ?
1403        AutocompleteInput::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS :
1404        AutocompleteInput::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS;
1405  }
1406  const GURL& gurl = delegate_->GetURL();
1407  if (!gurl.is_valid())
1408    return AutocompleteInput::INVALID_SPEC;
1409  const std::string& url = gurl.spec();
1410  if (url == chrome::kChromeUINewTabURL)
1411    return AutocompleteInput::NTP;
1412  if (url == content::kAboutBlankURL)
1413    return AutocompleteInput::BLANK;
1414  if (url == profile()->GetPrefs()->GetString(prefs::kHomePage))
1415    return AutocompleteInput::HOME_PAGE;
1416  if (controller_->GetToolbarModel()->WouldPerformSearchTermReplacement(true))
1417    return AutocompleteInput::SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT;
1418  if (delegate_->IsSearchResultsPage())
1419    return AutocompleteInput::SEARCH_RESULT_PAGE_NO_SEARCH_TERM_REPLACEMENT;
1420  return AutocompleteInput::OTHER;
1421}
1422
1423void OmniboxEditModel::ClassifyStringForPasteAndGo(
1424    const base::string16& text,
1425    AutocompleteMatch* match,
1426    GURL* alternate_nav_url) const {
1427  DCHECK(match);
1428  AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(text,
1429      false, false, match, alternate_nav_url);
1430}
1431
1432void OmniboxEditModel::SetFocusState(OmniboxFocusState state,
1433                                     OmniboxFocusChangeReason reason) {
1434  if (state == focus_state_)
1435    return;
1436
1437  InstantController* instant = GetInstantController();
1438  if (instant)
1439    instant->OmniboxFocusChanged(state, reason, NULL);
1440
1441  // Update state and notify view if the omnibox has focus and the caret
1442  // visibility changed.
1443  const bool was_caret_visible = is_caret_visible();
1444  focus_state_ = state;
1445  if (focus_state_ != OMNIBOX_FOCUS_NONE &&
1446      is_caret_visible() != was_caret_visible)
1447    view_->ApplyCaretVisibility();
1448}
1449