Remove Omnibox Disallow Inlining Field Trial

components/omnibox/autocomplete_result.cc

 // Copyright 2014 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 "components/omnibox/autocomplete_result.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
-#include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_input.h"
 #include "components/omnibox/autocomplete_match.h"
 #include "components/omnibox/autocomplete_provider.h"
 #include "components/omnibox/omnibox_field_trial.h"
 #include "components/search/search.h"
 #include "components/url_fixer/url_fixer.h"
 
@@ skipping 68 matching lines @@
   // first, so that when we call std::unique(), these are the ones that get
   // preserved.
   if (AutocompleteMatch::DestinationsEqual(elem1, elem2) ||
       (elem1.stripped_destination_url.is_empty() &&
        elem2.stripped_destination_url.is_empty())) {
     return demote_by_type_(elem1, elem2);
   }
   return elem1.stripped_destination_url < elem2.stripped_destination_url;
 }
 
-// Returns true if |match| is allowed to the default match taking into account
-// whether we're supposed to (and able to) demote all matches with inline
-// autocompletions.
-bool AllowedToBeDefaultMatchAccountingForDisableInliningExperiment(
-    const AutocompleteMatch& match,
-    const bool has_legal_default_match_without_completion) {
-  return match.allowed_to_be_default_match &&
-      (!OmniboxFieldTrial::DisableInlining() ||
-       !has_legal_default_match_without_completion ||
-       match.inline_autocompletion.empty());
-}
-
 };  // namespace
 
 // static
 const size_t AutocompleteResult::kMaxMatches = 6;
 
 void AutocompleteResult::Selection::Clear() {
   destination_url = GURL();
   provider_affinity = NULL;
   is_history_what_you_typed_match = false;
 }
@@ skipping 67 matching lines @@
 
 void AutocompleteResult::SortAndCull(
     const AutocompleteInput& input,
     TemplateURLService* template_url_service) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i)
     i->ComputeStrippedDestinationURL(template_url_service);
 
   DedupMatchesByDestination(input.current_page_classification(), true,
                             &matches_);
 
-  // If the result set has at least one legal default match without an inline
-  // autocompletion, then in the disable inlining experiment it will be okay
-  // to demote all matches with inline autocompletions.  On the other hand, if
-  // the experiment is active but there is no legal match without an inline
-  // autocompletion, then we'll pretend the experiment is not active and not
-  // demote the matches with an inline autocompletion.  In other words, an
-  // alternate name for this variable is
-  // allowed_to_demote_matches_with_inline_autocompletion.
-  bool has_legal_default_match_without_completion = false;
-  for (AutocompleteResult::iterator it = matches_.begin();
-       (it != matches_.end()) && !has_legal_default_match_without_completion;
-       ++it) {
-    if (it->allowed_to_be_default_match && it->inline_autocompletion.empty())
-      has_legal_default_match_without_completion = true;
-  }
-  UMA_HISTOGRAM_BOOLEAN("Omnibox.HasLegalDefaultMatchWithoutCompletion",
-                        has_legal_default_match_without_completion);
-
   // Sort and trim to the most relevant kMaxMatches matches.
   size_t max_num_matches = std::min(kMaxMatches, matches_.size());
   CompareWithDemoteByType comparing_object(input.current_page_classification());
   std::sort(matches_.begin(), matches_.end(), comparing_object);
-  if (!matches_.empty() &&
-      !AllowedToBeDefaultMatchAccountingForDisableInliningExperiment(
-          *matches_.begin(), has_legal_default_match_without_completion)) {
+  if (!matches_.empty() && !matches_.begin()->allowed_to_be_default_match) {
     // Top match is not allowed to be the default match.  Find the most
     // relevant legal match and shift it to the front.
     for (AutocompleteResult::iterator it = matches_.begin() + 1;
          it != matches_.end(); ++it) {
-      if (AllowedToBeDefaultMatchAccountingForDisableInliningExperiment(
-              *it, has_legal_default_match_without_completion)) {
+      if (it->allowed_to_be_default_match) {
         std::rotate(matches_.begin(), it, it + 1);
         break;
       }
     }
   }
   // In the process of trimming, drop all matches with a demoted relevance
   // score of 0.
   size_t num_matches;
   for (num_matches = 0u; (num_matches < max_num_matches) &&
        (comparing_object.GetDemotedRelevance(*match_at(num_matches)) > 0);
@@ skipping 217 matching lines @@
        i != old_matches.rend() && delta > 0; ++i) {
     if (!HasMatchByDestination(*i, new_matches)) {
       AutocompleteMatch match = *i;
       match.relevance = std::min(max_relevance, match.relevance);
       match.from_previous = true;
       matches_.push_back(match);
       delta--;
     }
   }
 }