Add field to monitor last visited time for each search engine

components/search_engines/template_url_service.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/search_engines/template_url_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 712 matching lines @@
     DefaultSearchManager::Source source;
     const TemplateURLData* new_dse =
         default_search_manager_.GetDefaultSearchEngine(&source);
     // ApplyDefaultSearchChange will notify observers once it is done.
     ApplyDefaultSearchChange(new_dse, source);
   } else {
     NotifyObservers();
   }
 }
 
+void TemplateURLService::UpdateTemplateURLVisitTime(TemplateURL* url) {
+  TemplateURLData data(url->data());
+  data.last_visited = clock_->Now();
+  Update(url, TemplateURL(data));
+}
+
 void TemplateURLService::AddObserver(TemplateURLServiceObserver* observer) {
   model_observers_.AddObserver(observer);
 }
 
 void TemplateURLService::RemoveObserver(TemplateURLServiceObserver* observer) {
   model_observers_.RemoveObserver(observer);
 }
 
 void TemplateURLService::Load() {
   if (loaded_ || load_handle_ || disable_load_)
@@ skipping 249 matching lines @@
         // unexpectedly swapped to something else. The user can safely delete
         // the extra entry again later, if they choose. Most users who do not
         // look at the search engines UI will not notice this.
         // Note that we append a special character to the end of the keyword in
         // an attempt to avoid a ping-poinging situation where receiving clients
         // may try to continually delete the resurrected entry.
         base::string16 updated_keyword = UniquifyKeyword(*existing_turl, true);
         TemplateURLData data(existing_turl->data());
         data.SetKeyword(updated_keyword);
         TemplateURL new_turl(data);
-        if (UpdateNoNotify(existing_turl, new_turl))
-          NotifyObservers();
+        Update(existing_turl, new_turl);
 
         syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(new_turl);
         new_changes.push_back(syncer::SyncChange(FROM_HERE,
                                                  syncer::SyncChange::ACTION_ADD,
                                                  sync_data));
         // Ignore the delete attempt. This means we never end up resetting the
         // default search provider due to an ACTION_DELETE from sync.
         continue;
       }
 
@@ skipping 27 matching lines @@
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_UPDATE");
         continue;
       }
       if (existing_keyword_turl && (existing_keyword_turl != existing_turl)) {
         // Resolve any conflicts with other entries so we can safely update the
         // keyword.
         ResolveSyncKeywordConflict(turl.get(), existing_keyword_turl,
                                    &new_changes);
       }
-      if (UpdateNoNotify(existing_turl, *turl)) {
-        NotifyObservers();
+      if (Update(existing_turl, *turl))
         MaybeUpdateDSEAfterSync(existing_turl);
-      }
     } else {
       // We've unexpectedly received an ACTION_INVALID.
       error = sync_error_factory_->CreateAndUploadError(
           FROM_HERE,
           "ProcessSyncChanges received an ACTION_INVALID");
     }
   }
 
   // If something went wrong, we want to prematurely exit to avoid pushing
   // inconsistent data to Sync. We return the last error we received.
@@ skipping 76 matching lines @@
       DCHECK(IsFromSync(local_turl, sync_data_map));
       // This local search engine is already synced. If the timestamp differs
       // from Sync, we need to update locally or to the cloud. Note that if the
       // timestamps are equal, we touch neither.
       if (sync_turl->last_modified() > local_turl->last_modified()) {
         // We've received an update from Sync. We should replace all synced
         // fields in the local TemplateURL. Note that this includes the
         // TemplateURLID and the TemplateURL may have to be reparsed. This
         // also makes the local data's last_modified timestamp equal to Sync's,
         // avoiding an Update on the next MergeData call.
-        if (UpdateNoNotify(local_turl, *sync_turl))
-          NotifyObservers();
+        Update(local_turl, *sync_turl);
         merge_result.set_num_items_modified(
             merge_result.num_items_modified() + 1);
       } else if (sync_turl->last_modified() < local_turl->last_modified()) {
         // Otherwise, we know we have newer data, so update Sync with our
         // data fields.
         new_changes.push_back(
             syncer::SyncChange(FROM_HERE,
                                syncer::SyncChange::ACTION_UPDATE,
                                local_data_map[local_turl->sync_guid()]));
       }
@@ skipping 572 matching lines @@
       FROM_HERE, existing_turl, syncer::SyncChange::ACTION_UPDATE);
 
   if (default_search_provider_ == existing_turl &&
       default_search_provider_source_ == DefaultSearchManager::FROM_USER) {
     default_search_manager_.SetUserSelectedDefaultSearchEngine(
         default_search_provider_->data());
   }
   return true;
 }
 
+bool TemplateURLService::Update(TemplateURL* existing_turl,
+                                        const TemplateURL& new_values) {
+  const bool updated = UpdateNoNotify(existing_turl, new_values);
+  if (updated)
+    NotifyObservers();
+  return updated;
+}
+
 // static
 void TemplateURLService::UpdateTemplateURLIfPrepopulated(
     TemplateURL* template_url,
     PrefService* prefs) {
   int prepopulate_id = template_url->prepopulate_id();
   if (template_url->prepopulate_id() == 0)
     return;
 
   size_t default_search_index;
   std::vector<std::unique_ptr<TemplateURLData>> prepopulated_urls =
@@ skipping 20 matching lines @@
 void TemplateURLService::UpdateKeywordSearchTermsForURL(
     const URLVisitedDetails& details) {
   if (!details.url.is_valid())
     return;
 
   const TemplateURLSet* urls_for_host =
       provider_map_->GetURLsForHost(details.url.host());
   if (!urls_for_host)
     return;
 
+  TemplateURL* visited_url = nullptr;
   for (TemplateURLSet::const_iterator i = urls_for_host->begin();
        i != urls_for_host->end(); ++i) {
     base::string16 search_terms;
     if ((*i)->ExtractSearchTermsFromURL(details.url, search_terms_data(),
                                         &search_terms) &&
         !search_terms.empty()) {
       if (details.is_keyword_transition) {
         // The visit is the result of the user entering a keyword, generate a
         // KEYWORD_GENERATED visit for the KEYWORD so that the keyword typed
         // count is boosted.
         AddTabToSearchVisit(**i);
       }
       if (client_) {
         client_->SetKeywordSearchTermsForURL(
             details.url, (*i)->id(), search_terms);
       }
+      // Caches the matched TemplateURL so its last_visited could be updated
+      // later after iteration.
+      // Note: UpdateNoNotify() will replace the entry from the container of
+      // this iterator, so update here directly will cause an error about it.
+      visited_url = *i;
     }
   }
+  if (visited_url)
+    UpdateTemplateURLVisitTime(visited_url);
 }
 
 void TemplateURLService::AddTabToSearchVisit(const TemplateURL& t_url) {
   // Only add visits for entries the user hasn't modified. If the user modified
   // the entry the keyword may no longer correspond to the host name. It may be
   // possible to do something more sophisticated here, but it's so rare as to
   // not be worth it.
   if (!t_url.safe_for_autoreplace())
     return;
 
@@ skipping 436 matching lines @@
   base::string16 new_keyword = UniquifyKeyword(*loser, false);
   DCHECK(!GetTemplateURLForKeyword(new_keyword));
   if (applied_turl_is_better) {
     // Just set the keyword of |unapplied_sync_turl|. The caller is responsible
     // for adding or updating unapplied_sync_turl in the local model.
     unapplied_sync_turl->data_.SetKeyword(new_keyword);
   } else {
     // Update |applied_sync_turl| in the local model with the new keyword.
     TemplateURLData data(applied_sync_turl->data());
     data.SetKeyword(new_keyword);
-    if (UpdateNoNotify(applied_sync_turl, TemplateURL(data)))
-      NotifyObservers();
+    Update(applied_sync_turl, TemplateURL(data));
   }
   // The losing TemplateURL should have their keyword updated. Send a change to
   // the server to reflect this change.
   syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*loser);
   change_list->push_back(syncer::SyncChange(FROM_HERE,
       syncer::SyncChange::ACTION_UPDATE,
       sync_data));
 }
 
 void TemplateURLService::MergeInSyncTemplateURL(
@@ skipping 209 matching lines @@
 
   if (most_recently_intalled_default) {
     base::AutoReset<DefaultSearchChangeOrigin> change_origin(
         &dsp_change_origin_, DSP_CHANGE_OVERRIDE_SETTINGS_EXTENSION);
     default_search_manager_.SetExtensionControlledDefaultSearchEngine(
         most_recently_intalled_default->data());
   } else {
     default_search_manager_.ClearExtensionControlledDefaultSearchEngine();
   }
 }