Omnibox: Add Field Trial to Create UWYT When Inlining

chrome/browser/autocomplete/history_url_provider.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/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 356 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(VisitClassifier);
 };
 
 HistoryURLProvider::VisitClassifier::VisitClassifier(
     HistoryURLProvider* provider,
     const AutocompleteInput& input,
     history::URLDatabase* db)
     : provider_(provider),
       db_(db),
       type_(INVALID) {
+  if (!db_)
+    return;
+
   const GURL& url = input.canonicalized_url();
   // Detect email addresses.  These cases will look like "http://user@site/",
   // and because the history backend strips auth creds, we'll get a bogus exact
   // match below if the user has visited "site".
   if (!url.is_valid() ||
       ((input.type() == metrics::OmniboxInputType::UNKNOWN) &&
        input.parts().username.is_nonempty() &&
        !input.parts().password.is_nonempty() &&
        !input.parts().path.is_nonempty()))
     return;
@@ skipping 129 matching lines @@
   // url_db can be NULL if it hasn't finished initializing (or failed to
   // initialize).  In this case all we can do is fall back on the second
   // pass.
   //
   // TODO(pkasting): We should just block here until this loads.  Any time
   // someone unloads the history backend, we'll get inconsistent inline
   // autocomplete behavior here.
   if (url_db) {
     DoAutocomplete(NULL, url_db, params.get());
     matches_.clear();
-    PromoteMatchIfNecessary(*params);
+    PromoteMatchesIfNecessary(*params);
     UpdateStarredStateOfMatches();
     // NOTE: We don't reset |params| here since at least the |promote_type|
     // field on it will be read by the second pass -- see comments in
     // DoAutocomplete().
   }
 
   // Pass 2: Ask the history service to call us back on the history thread,
   // where we can read the full on-disk DB.
   if (input.want_asynchronous_matches()) {
     done_ = false;
@@ skipping 171 matching lines @@
           *j, i->prefix.length(), !i->num_components,
           i->num_components >= best_prefix->num_components));
     }
   }
 
   // Create sorted list of suggestions.
   CullPoorMatches(params);
   SortAndDedupMatches(&params->matches);
 
   // Try to create a shorter suggestion from the best match.
-  // We allow the what you typed match to be displayed when there's a reasonable
-  // chance the user actually cares:
-  // * Their input can be opened as a URL, and
-  // * We parsed the input as a URL, or it starts with an explicit "http:" or
-  //   "https:".
-  // Otherwise, this is just low-quality noise.  In the cases where we've parsed
-  // as UNKNOWN, we'll still show an accidental search infobar if need be.
   VisitClassifier classifier(this, params->input, db);
-  bool have_what_you_typed_match =
-      (params->input.type() != metrics::OmniboxInputType::QUERY) &&
-      ((params->input.type() != metrics::OmniboxInputType::UNKNOWN) ||
-       (classifier.type() == VisitClassifier::UNVISITED_INTRANET) ||
-       !params->trim_http ||
-       (AutocompleteInput::NumNonHostComponents(params->input.parts()) > 0));
+  const bool have_what_you_typed_match =
+      HaveWhatYouTypedMatch(classifier, *params);
   const bool have_shorter_suggestion_suitable_for_inline_autocomplete =
       PromoteOrCreateShorterSuggestion(db, have_what_you_typed_match, params);
 
   // Check whether what the user typed appears in history.
   const bool can_check_history_for_exact_match =
       // Checking what_you_typed_match.is_history_what_you_typed_match tells us
       // whether SuggestExactInput() succeeded in constructing a valid match.
       params->what_you_typed_match.is_history_what_you_typed_match &&
       // Additionally, in the case where the user has typed "foo.com" and
       // visited (but not typed) "foo/", and the input is "foo", the first pass
@@ skipping 33 matching lines @@
     // Remove redirects and trim list to size.  We want to provide up to
     // kMaxMatches results plus the What You Typed result, if it was added to
     // params->matches above.
     CullRedirects(backend, &params->matches, max_results);
   } else if (params->matches.size() > max_results) {
     // Simply trim the list to size.
     params->matches.resize(max_results);
   }
 }
 
-void HistoryURLProvider::PromoteMatchIfNecessary(
+void HistoryURLProvider::PromoteMatchesIfNecessary(
     const HistoryURLProviderParams& params) {
-  if (params.promote_type == HistoryURLProviderParams::NEITHER)
-    return;
-  matches_.push_back(
-      (params.promote_type == HistoryURLProviderParams::WHAT_YOU_TYPED_MATCH) ?
-          params.what_you_typed_match :
-          HistoryMatchToACMatch(params, 0, INLINE_AUTOCOMPLETE,
-                                CalculateRelevance(INLINE_AUTOCOMPLETE, 0)));
+  if (params.promote_type == HistoryURLProviderParams::FRONT_HISTORY_MATCH) {
+    matches_.push_back(HistoryMatchToACMatch(params, 0, INLINE_AUTOCOMPLETE,
+        CalculateRelevance(INLINE_AUTOCOMPLETE, 0)));
+    if (OmniboxFieldTrial::AddUWYTMatchEvenIfPromotedURLs()) {
+      HistoryService* const history_service =
+          HistoryServiceFactory::GetForProfile(profile_,
+                                               Profile::EXPLICIT_ACCESS);
+      if (history_service &&
+          HaveWhatYouTypedMatch(VisitClassifier(
+              this, params.input, history_service->InMemoryDatabase()),
+                                params)) {
+        matches_.push_back(params.what_you_typed_match);
+      }
+    }
+  } else if (params.promote_type ==
+      HistoryURLProviderParams::WHAT_YOU_TYPED_MATCH) {
+    matches_.push_back(params.what_you_typed_match);
+  }
 }
 
 void HistoryURLProvider::QueryComplete(
     HistoryURLProviderParams* params_gets_deleted) {
   // Ensure |params_gets_deleted| gets deleted on exit.
   scoped_ptr<HistoryURLProviderParams> params(params_gets_deleted);
 
   // If the user hasn't already started another query, clear our member pointer
   // so we can't write into deleted memory.
   if (params_ == params_gets_deleted)
     params_ = NULL;
 
   // Don't send responses for queries that have been canceled.
   if (params->cancel_flag.IsSet())
     return;  // Already set done_ when we canceled, no need to set it again.
 
   // Don't modify |matches_| if the query failed, since it might have a default
   // match in it, whereas |params->matches| will be empty.
   if (!params->failed) {
     matches_.clear();
-    PromoteMatchIfNecessary(*params);
+    PromoteMatchesIfNecessary(*params);
 
     // Determine relevance of highest scoring match, if any.
     int relevance = matches_.empty() ?
         CalculateRelevance(NORMAL,
                            static_cast<int>(params->matches.size() - 1)) :
         matches_[0].relevance;
 
     // Convert the history matches to autocomplete matches.  If we promoted the
     // first match, skip over it.
     const size_t first_match =
@@ skipping 11 matching lines @@
       matches_.push_back(HistoryMatchToACMatch(*params, i, NORMAL, relevance));
     }
 
     UpdateStarredStateOfMatches();
   }
 
   done_ = true;
   listener_->OnProviderUpdate(true);
 }
 
+// static
+bool HistoryURLProvider::HaveWhatYouTypedMatch(
+    const VisitClassifier& classifier,
+    const HistoryURLProviderParams& params) {
+  // We consider the what you typed match to be eligible to be displayed when
+  // there's a reasonable chance the user actually cares:
+  // * Their input can be opened as a URL, and
+  // * We parsed the input as a URL, or it starts with an explicit "http:" or
+  // "https:".
+  // Otherwise, this is just low-quality noise.  In the cases where we've parsed
+  // as UNKNOWN, we'll still show an accidental search infobar if need be.
+  return (params.input.type() != metrics::OmniboxInputType::QUERY) &&
+      ((params.input.type() != metrics::OmniboxInputType::UNKNOWN) ||
+       (classifier.type() == VisitClassifier::UNVISITED_INTRANET) ||
+       !params.trim_http ||
+       (AutocompleteInput::NumNonHostComponents(params.input.parts()) > 0));
+}
+
 bool HistoryURLProvider::FixupExactSuggestion(
     history::URLDatabase* db,
     const VisitClassifier& classifier,
     HistoryURLProviderParams* params) const {
   MatchType type = INLINE_AUTOCOMPLETE;
   switch (classifier.type()) {
     case VisitClassifier::INVALID:
       return false;
     case VisitClassifier::UNVISITED_INTRANET:
       type = UNVISITED_INTRANET;
@@ skipping 281 matching lines @@
     AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }