autocomplete: Add AutocompleteMatch::MergeClassifications()

chrome/browser/autocomplete/autocomplete_match.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/autocomplete_match.h"
 
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "content/public/common/url_constants.h"
 #include "grit/theme_resources.h"
 
+namespace {
+
+bool IsTrivialClassification(const ACMatchClassifications& classifications) {
+  return classifications.empty() ||
+      ((classifications.size() == 1) &&
+       (classifications.back().style == ACMatchClassification::NONE));
+}
+
+}  // namespace
+
 // AutocompleteMatch ----------------------------------------------------------
 
 // static
 const char16 AutocompleteMatch::kInvalidChars[] = {
   '\n', '\r', '\t',
   0x2028,  // Line separator
   0x2029,  // Paragraph separator
   0
 };
 
@@ skipping 194 matching lines @@
       (style | ACMatchClassification::MATCH) & ~ACMatchClassification::DIM));
 
   // Mark post-match portion of string (if any).
   const size_t after_match(match_location + match_length);
   if (after_match < overall_length) {
     classification->push_back(ACMatchClassification(after_match, style));
   }
 }
 
 // static
+AutocompleteMatch::ACMatchClassifications
+    AutocompleteMatch::MergeClassifications(
+    const ACMatchClassifications& classifications1,
+    const ACMatchClassifications& classifications2) {
+  // We must return the empty vector only if both inputs are truly empty.
+  // The result of merging an empty vector with a single (0, NONE)
+  // classification is the latter one-entry vector.
+  if (IsTrivialClassification(classifications1))
+    return classifications2.empty() ? classifications1 : classifications2;
+  if (IsTrivialClassification(classifications2))
+    return classifications1;
+
+  ACMatchClassifications output;
+  for (ACMatchClassifications::const_iterator i = classifications1.begin(),
+       j = classifications2.begin(); i != classifications1.end();) {
+    AutocompleteMatch::AddLastClassificationIfNecessary(&output,
+        std::max(i->offset, j->offset), i->style | j->style);
+    const size_t next_i_offset = (i + 1) == classifications1.end() ?
+        static_cast<size_t>(-1) : (i + 1)->offset;
+    const size_t next_j_offset = (j + 1) == classifications2.end() ?
+        static_cast<size_t>(-1) : (j + 1)->offset;
+    if (next_i_offset >= next_j_offset)
+      ++j;
+    if (next_j_offset >= next_i_offset)
+      ++i;
+  }
+
+  return output;
+}
+
+// static
 std::string AutocompleteMatch::ClassificationsToString(
     const ACMatchClassifications& classifications) {
   std::string serialized_classifications;
   for (size_t i = 0; i < classifications.size(); ++i) {
     if (i)
       serialized_classifications += ',';
     serialized_classifications += base::IntToString(classifications[i].offset) +
         ',' + base::IntToString(classifications[i].style);
   }
   return serialized_classifications;
@@ skipping 156 matching lines @@
         << " is unsorted in relation to last offset of " << last_offset
         << ". Provider: " << (provider ? provider->name() : "None") << ".";
     DCHECK_LT(i->offset, text.length())
         << " Classification of [" << i->offset << "," << text.length()
         << "] is out of bounds for \"" << text << "\". Provider: "
         << (provider ? provider->name() : "None") << ".";
     last_offset = i->offset;
   }
 }
 #endif