autocomplete: Make ContactProvider rank contacts by affinity

chrome/browser/autocomplete/contact_provider_chromeos.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/contact_provider_chromeos.h"
 
 #include <algorithm>
+#include <cmath>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/string_search.h"
 #include "base/string_split.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/chromeos/contacts/contact.pb.h"
 #include "chrome/browser/chromeos/contacts/contact_manager.h"
 #include "chrome/browser/profiles/profile.h"
 
 namespace {
 
+// Default affinity assigned to contacts whose |affinity| field is unset.
+// TODO(derat): Set this to something reasonable (probably 0.0) once we're
+// getting affinity for contacts.
+float kDefaultAffinity = 1.0;
+
+// Base match relevance assigned to a contact with an affinity of 0.0.
+int kBaseRelevance = 1300;
+
+// Maximum boost to relevance for a contact with an affinity of 1.0.
+int kAffinityRelevanceBoost = 200;
+
 // Returns true if |word_to_find| is a prefix of |name_to_search| and marks the
 // matching text in |classifications| (which corresponds to the contact's full
 // name).  |name_index_in_full_name| contains |name_to_search|'s index within
 // the full name or string16::npos if it doesn't appear in it.
 bool WordIsNamePrefix(const string16& word_to_find,
                       const string16& name_to_search,
                       size_t name_index_in_full_name,
                       size_t full_name_length,
                       ACMatchClassifications* classifications) {
   DCHECK(classifications);
@@ skipping 18 matching lines @@
 }  // namespace
 
 // static
 const char ContactProvider::kMatchContactIdKey[] = "contact_id";
 
 // Cached information about a contact.
 struct ContactProvider::ContactData {
   ContactData(const string16& full_name,
               const string16& given_name,
               const string16& family_name,
-              const std::string& contact_id)
+              const std::string& contact_id,
+              float affinity)
       : full_name(full_name),
         given_name(given_name),
         family_name(family_name),
         given_name_index(string16::npos),
         family_name_index(string16::npos),
-        contact_id(contact_id) {
+        contact_id(contact_id),
+        affinity(affinity) {
     base::i18n::StringSearchIgnoringCaseAndAccents(
         given_name, full_name, &given_name_index, NULL);
     base::i18n::StringSearchIgnoringCaseAndAccents(
         family_name, full_name, &family_name_index, NULL);
   }
 
   string16 full_name;
   string16 given_name;
   string16 family_name;
 
   // Indices into |full_name| where |given_name| and |family_name| first appear,
   // or string16::npos if they don't appear in it.
   size_t given_name_index;
   size_t family_name_index;
 
   // Unique ID used to look up additional contact information.
   std::string contact_id;
+
+  // Affinity between the user and this contact, in the range [0.0, 1.0].
+  float affinity;
 };
 
 ContactProvider::ContactProvider(
     AutocompleteProviderListener* listener,
     Profile* profile,
     base::WeakPtr<contacts::ContactManagerInterface> contact_manager)
     : AutocompleteProvider(listener, profile, TYPE_CONTACT),
       contact_manager_(contact_manager) {
   contact_manager_->AddObserver(this, profile);
   RefreshContacts();
@@ skipping 15 matching lines @@
   base::i18n::BreakIterator break_iterator(
       input.text(),
       base::i18n::BreakIterator::BREAK_WORD);
   if (break_iterator.Init()) {
     while (break_iterator.Advance()) {
       if (break_iterator.IsWord())
         input_words.push_back(break_iterator.GetString());
     }
   }
 
+  // |contacts_| is ordered by descending affinity.  Since affinity is currently
+  // the only signal used for computing relevance, we can stop after we've found
+  // kMaxMatches results.
   for (ContactDataVector::const_iterator it = contacts_.begin();
-       it != contacts_.end(); ++it)
+       it != contacts_.end() && matches_.size() < kMaxMatches; ++it)
     AddContactIfMatched(input, input_words, *it);
 }
 
 void ContactProvider::OnContactsUpdated(Profile* profile) {
   DCHECK_EQ(profile, profile_);
   RefreshContacts();
 }
 
 ContactProvider::~ContactProvider() {
   // Like ContactProvider, ContactManager gets destroyed at profile destruction.
   // Make sure that this class doesn't try to access ContactManager after
   // ContactManager is gone.
   if (contact_manager_.get())
     contact_manager_->RemoveObserver(this, profile_);
 }
 
+// static
+bool ContactProvider::CompareAffinity(const ContactData& a,
+                                      const ContactData& b) {
+  return a.affinity > b.affinity;
+}
+
 void ContactProvider::RefreshContacts() {
   if (!contact_manager_.get())
     return;
 
   scoped_ptr<contacts::ContactPointers> contacts =
       contact_manager_->GetAllContacts(profile_);
 
   contacts_.clear();
+  contacts_.reserve(contacts->size());
   for (contacts::ContactPointers::const_iterator it = contacts->begin();
        it != contacts->end(); ++it) {
     const contacts::Contact& contact = **it;
     string16 full_name =
         AutocompleteMatch::SanitizeString(UTF8ToUTF16(contact.full_name()));
     string16 given_name =
         AutocompleteMatch::SanitizeString(UTF8ToUTF16(contact.given_name()));
     string16 family_name =
         AutocompleteMatch::SanitizeString(UTF8ToUTF16(contact.family_name()));
+    float affinity =
+        contact.has_affinity() ? contact.affinity() : kDefaultAffinity;
 
     if (!full_name.empty()) {
       contacts_.push_back(
-          ContactData(
-              full_name, given_name, family_name, contact.contact_id()));
+          ContactData(full_name, given_name, family_name, contact.contact_id(),
+                      affinity));
     }
   }
+  std::sort(contacts_.begin(), contacts_.end(), CompareAffinity);
 }
 
 void ContactProvider::AddContactIfMatched(
     const AutocompleteInput& input,
     const std::vector<string16>& input_words,
     const ContactData& contact) {
   // First, check if the whole input string is a prefix of the full name.
   // TODO(derat): Consider additionally segmenting the full name so we can match
   // e.g. middle names or initials even when they aren't typed as a prefix of
   // the full name.
@@ skipping 23 matching lines @@
   matches_.back().contents_class = classifications;
 }
 
 AutocompleteMatch ContactProvider::CreateAutocompleteMatch(
     const AutocompleteInput& input,
     const ContactData& contact) {
   AutocompleteMatch match(this, 0, false, AutocompleteMatch::CONTACT);
   match.inline_autocomplete_offset = string16::npos;
   match.contents = contact.full_name;
   match.fill_into_edit = match.contents;
-  // TODO(derat): Implement ranking.
-  match.relevance = 1;
+  match.relevance = kBaseRelevance +
+      static_cast<int>(roundf(kAffinityRelevanceBoost * contact.affinity));
   match.RecordAdditionalInfo(kMatchContactIdKey, contact.contact_id);
   return match;
 }