Reland r145993.

chrome/browser/search_engines/template_url_service.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/search_engines/template_url_service.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/guid.h"
@@ skipping 961 matching lines @@
         // may try to continually delete the resurrected entry.
         string16 updated_keyword = UniquifyKeyword(*existing_turl, true);
         TemplateURLData data(existing_turl->data());
         data.SetKeyword(updated_keyword);
         TemplateURL new_turl(existing_turl->profile(), data);
         UIThreadSearchTermsData search_terms_data(existing_turl->profile());
         if (UpdateNoNotify(existing_turl, new_turl, search_terms_data))
           NotifyObservers();
 
         syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(new_turl);
-        new_changes.push_back(
-            syncer::SyncChange(syncer::SyncChange::ACTION_ADD, sync_data));
+        new_changes.push_back(syncer::SyncChange(FROM_HERE,
+                                                 syncer::SyncChange::ACTION_ADD,
+                                                 sync_data));
         // Ignore the delete attempt. This means we never end up reseting the
         // default search provider due to an ACTION_DELETE from sync.
         continue;
       }
 
       Remove(existing_turl);
     } else if (iter->change_type() == syncer::SyncChange::ACTION_ADD) {
       if (existing_turl) {
         NOTREACHED() << "Unexpected sync change state.";
         error = sync_error_factory_->CreateAndUploadError(
@@ skipping 105 matching lines @@
             iter->second, &new_changes));
     if (!sync_turl.get())
       continue;
 
     if (pre_sync_deletes_.find(sync_turl->sync_guid()) !=
         pre_sync_deletes_.end()) {
       // This entry was deleted before the initial sync began (possibly through
       // preprocessing in TemplateURLService's loading code). Ignore it and send
       // an ACTION_DELETE up to the server.
       new_changes.push_back(
-          syncer::SyncChange(syncer::SyncChange::ACTION_DELETE,
+          syncer::SyncChange(FROM_HERE,
+                             syncer::SyncChange::ACTION_DELETE,
                              iter->second));
       continue;
     }
 
     if (local_turl) {
       // 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.
         UIThreadSearchTermsData search_terms_data(local_turl->profile());
         if (UpdateNoNotify(local_turl, *sync_turl, search_terms_data))
           NotifyObservers();
       } 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(syncer::SyncChange::ACTION_UPDATE,
-            local_data_map[local_turl->sync_guid()]));
+            syncer::SyncChange(FROM_HERE,
+                               syncer::SyncChange::ACTION_UPDATE,
+                               local_data_map[local_turl->sync_guid()]));
       }
       local_data_map.erase(iter->first);
     } else {
       // The search engine from the cloud has not been synced locally, but there
       // might be a local search engine that is a duplicate that needs to be
       // merged.
       TemplateURL* dupe_turl = FindDuplicateOfSyncTemplateURL(*sync_turl);
       if (dupe_turl) {
         // Merge duplicates and remove the processed local TURL from the map.
         std::string old_guid = dupe_turl->sync_guid();
@@ skipping 21 matching lines @@
         }
       }
     }
   }
 
   // The remaining SyncData in local_data_map should be everything that needs to
   // be pushed as ADDs to sync.
   for (SyncDataMap::const_iterator iter = local_data_map.begin();
       iter != local_data_map.end(); ++iter) {
     new_changes.push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_ADD, iter->second));
+        syncer::SyncChange(FROM_HERE,
+                           syncer::SyncChange::ACTION_ADD,
+                           iter->second));
   }
 
   // Do some post-processing on the change list to ensure that we are sending
   // valid changes to sync_processor_.
   PruneSyncChanges(&sync_data_map, &new_changes);
 
   syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   if (error.IsSet())
     return error;
 
   // The ACTION_DELETEs from this set are processed. Empty it so we don't try to
   // reuse them on the next call to MergeDataAndStartSyncing.
   pre_sync_deletes_.clear();
 
   models_associated_ = true;
   return syncer::SyncError();
 }
 
 void TemplateURLService::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(type, syncer::SEARCH_ENGINES);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
 }
 
 void TemplateURLService::ProcessTemplateURLChange(
+    const tracked_objects::Location& from_here,
     const TemplateURL* turl,
     syncer::SyncChange::SyncChangeType type) {
   DCHECK_NE(type, syncer::SyncChange::ACTION_INVALID);
   DCHECK(turl);
 
   if (!models_associated_)
     return;  // Not syncing.
 
   if (processing_syncer_changes_)
     return;  // These are changes originating from us. Ignore.
 
   // Avoid syncing Extension keywords.
   // TODO(mpcomplete): If we allow editing extension keywords, then those should
   // be persisted to disk and synced.
   if (turl->IsExtensionKeyword())
     return;
 
   // Avoid syncing keywords managed by policy.
   if (turl->created_by_policy())
     return;
 
   syncer::SyncChangeList changes;
 
   syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
-  changes.push_back(syncer::SyncChange(type, sync_data));
+  changes.push_back(syncer::SyncChange(from_here,
+                                       type,
+                                       sync_data));
 
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 // static
 syncer::SyncData TemplateURLService::CreateSyncDataFromTemplateURL(
     const TemplateURL& turl) {
   sync_pb::EntitySpecifics specifics;
   sync_pb::SearchEngineSpecifics* se_specifics =
       specifics.mutable_search_engine();
@@ skipping 24 matching lines @@
     syncer::SyncChangeList* change_list) {
   DCHECK(change_list);
 
   sync_pb::SearchEngineSpecifics specifics =
       sync_data.GetSpecifics().search_engine();
 
   // Past bugs might have caused either of these fields to be empty.  Just
   // delete this data off the server.
   if (specifics.url().empty() || specifics.sync_guid().empty()) {
     change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
+        syncer::SyncChange(FROM_HERE,
+                           syncer::SyncChange::ACTION_DELETE,
+                           sync_data));
     return NULL;
   }
 
   TemplateURLData data(existing_turl ?
       existing_turl->data() : TemplateURLData());
   data.short_name = UTF8ToUTF16(specifics.short_name());
   data.originating_url = GURL(specifics.originating_url());
   string16 keyword(UTF8ToUTF16(specifics.keyword()));
   // NOTE: Once this code has shipped in a couple of stable releases, we can
   // probably remove the migration portion, comment out the
@@ skipping 22 matching lines @@
   data.prepopulate_id = specifics.prepopulate_id();
   data.sync_guid = specifics.sync_guid();
 
   TemplateURL* turl = new TemplateURL(profile, data);
   DCHECK(!turl->IsExtensionKeyword());
   if (reset_keyword || deduped) {
     if (reset_keyword)
       turl->ResetKeywordIfNecessary(true);
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
     change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
+        syncer::SyncChange(FROM_HERE,
+                           syncer::SyncChange::ACTION_UPDATE,
+                           sync_data));
   } else if (turl->IsGoogleSearchURLWithReplaceableKeyword()) {
     if (!existing_turl) {
       // We're adding a new TemplateURL that uses the Google base URL, so set
       // its keyword appropriately for the local environment.
       turl->ResetKeywordIfNecessary(false);
     } else if (existing_turl->IsGoogleSearchURLWithReplaceableKeyword()) {
       // Ignore keyword changes triggered by the Google base URL changing on
       // another client.  If the base URL changes in this client as well, we'll
       // pick that up separately at the appropriate time.  Otherwise, changing
       // the keyword here could result in having the wrong keyword for the local
@@ skipping 435 matching lines @@
       }
     }
   }
   if (!existing_turl->sync_guid().empty())
     guid_to_template_map_[existing_turl->sync_guid()] = existing_turl;
 
   if (service_.get())
     service_->UpdateKeyword(existing_turl->data());
 
   // Inform sync of the update.
-  ProcessTemplateURLChange(existing_turl, syncer::SyncChange::ACTION_UPDATE);
+  ProcessTemplateURLChange(FROM_HERE,
+                           existing_turl,
+                           syncer::SyncChange::ACTION_UPDATE);
 
   if (default_search_provider_ == existing_turl) {
     bool success = SetDefaultSearchProviderNoNotify(existing_turl);
     DCHECK(success);
   }
   return true;
 }
 
 PrefService* TemplateURLService::GetPrefs() {
   return profile_ ? profile_->GetPrefs() : NULL;
@@ skipping 310 matching lines @@
       GetPrefs()->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                             url->sync_guid());
     }
   }
 
   if (service_.get())
     service_->SetDefaultSearchProvider(url);
 
   // Inform sync the change to the show_in_default_list flag.
   if (url)
-    ProcessTemplateURLChange(url, syncer::SyncChange::ACTION_UPDATE);
+    ProcessTemplateURLChange(FROM_HERE,
+                             url,
+                             syncer::SyncChange::ACTION_UPDATE);
   return true;
 }
 
 bool TemplateURLService::AddNoNotify(TemplateURL* template_url,
                                      bool newly_adding) {
   DCHECK(template_url);
 
   if (newly_adding) {
     DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
     DCHECK(std::find(template_urls_.begin(), template_urls_.end(),
@@ skipping 28 matching lines @@
   if (newly_adding) {
     // Don't persist extension keywords to disk.  They'll get re-added on each
     // launch as the extensions are loaded.
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if (service_.get() && !template_url->IsExtensionKeyword())
       service_->AddKeyword(template_url->data());
 
     // Inform sync of the addition. Note that this will assign a GUID to
     // template_url and add it to the guid_to_template_map_.
-    ProcessTemplateURLChange(template_url, syncer::SyncChange::ACTION_ADD);
+    ProcessTemplateURLChange(FROM_HERE,
+                             template_url,
+                             syncer::SyncChange::ACTION_ADD);
   }
 
   return true;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
   TemplateURLVector::iterator i =
       std::find(template_urls_.begin(), template_urls_.end(), template_url);
   if (i == template_urls_.end())
     return;
 
   if (template_url == default_search_provider_) {
     // Should never delete the default search provider.
     NOTREACHED();
     return;
   }
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
   template_urls_.erase(i);
 
   // Extension keywords are not persisted.
   // TODO(mpcomplete): If we allow editing extension keywords, then those should
   // be persisted to disk and synced.
   if (service_.get() && !template_url->IsExtensionKeyword())
     service_->RemoveKeyword(template_url->id());
 
   // Inform sync of the deletion.
-  ProcessTemplateURLChange(template_url, syncer::SyncChange::ACTION_DELETE);
+  ProcessTemplateURLChange(FROM_HERE,
+                           template_url,
+                           syncer::SyncChange::ACTION_DELETE);
 
   if (profile_) {
     content::Source<Profile> source(profile_);
     TemplateURLID id = template_url->id();
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_TEMPLATE_URL_REMOVED,
         source,
         content::Details<TemplateURLID>(&id));
   }
 
@@ skipping 109 matching lines @@
   DCHECK(!local_turl->IsExtensionKeyword());
   DCHECK(change_list);
 
   const bool local_is_better =
       (local_turl->last_modified() > sync_turl->last_modified()) ||
       local_turl->created_by_policy() ||
       (local_turl == GetDefaultSearchProvider());
   const bool can_replace_local = CanReplace(local_turl);
   if (CanReplace(sync_turl) && (local_is_better || !can_replace_local)) {
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
-    change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
+    change_list->push_back(syncer::SyncChange(FROM_HERE,
+                                              syncer::SyncChange::ACTION_DELETE,
+                                              sync_data));
     return false;
   }
   if (can_replace_local) {
     // Since we're processing sync changes, the upcoming Remove() won't generate
     // an ACTION_DELETE.  We need to do it manually to keep the server in sync
     // with us.  Note that if we're being called from
     // MergeDataAndStartSyncing(), and this TemplateURL was pre-existing rather
     // than having just been brought down, then this is wrong, because the
     // server doesn't yet know about this entity; but in this case,
     // PruneSyncChanges() will prune out the ACTION_DELETE we create here.
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
-    change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
+    change_list->push_back(syncer::SyncChange(FROM_HERE,
+                                              syncer::SyncChange::ACTION_DELETE,
+                                              sync_data));
     Remove(local_turl);
   } else if (local_is_better) {
     string16 new_keyword = UniquifyKeyword(*sync_turl, false);
     DCHECK(!GetTemplateURLForKeyword(new_keyword));
     sync_turl->data_.SetKeyword(new_keyword);
     // If we update the cloud TURL, we need to push an update back to sync
     // informing it that something has changed.
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
-    change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
+    change_list->push_back(syncer::SyncChange(FROM_HERE,
+                                              syncer::SyncChange::ACTION_UPDATE,
+                                              sync_data));
   } else {
     string16 new_keyword = UniquifyKeyword(*local_turl, false);
     TemplateURLData data(local_turl->data());
     data.SetKeyword(new_keyword);
     TemplateURL new_turl(local_turl->profile(), data);
     UIThreadSearchTermsData search_terms_data(local_turl->profile());
     if (UpdateNoNotify(local_turl, new_turl, search_terms_data))
       NotifyObservers();
     // Since we're processing sync changes, the UpdateNoNotify() above didn't
     // generate an ACTION_UPDATE.  We need to do it manually to keep the server
     // in sync with us.  Note that if we're being called from
     // MergeDataAndStartSyncing(), and this TemplateURL was pre-existing rather
     // than having just been brought down, then this is wrong, because the
     // server won't know about this entity until it processes the ACTION_ADD our
     // caller will later generate; but in this case, PruneSyncChanges() will
     // prune out the ACTION_UPDATE we create here.
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
-    change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
+    change_list->push_back(syncer::SyncChange(FROM_HERE,
+                                              syncer::SyncChange::ACTION_UPDATE,
+                                              sync_data));
   }
   return true;
 }
 
 TemplateURL* TemplateURLService::FindDuplicateOfSyncTemplateURL(
     const TemplateURL& sync_turl) {
   TemplateURL* existing_turl = GetTemplateURLForKeyword(sync_turl.keyword());
   return existing_turl && (existing_turl->url() == sync_turl.url()) ?
       existing_turl : NULL;
 }
@@ skipping 13 matching lines @@
     // TemplateURLID. We don't need to sync the new ID back to the server since
     // it's only relevant locally.
     bool delete_default = (local_turl == GetDefaultSearchProvider());
     DCHECK(!delete_default || !is_default_search_managed_);
     if (delete_default)
       default_search_provider_ = NULL;
 
     // See comments in ResolveSyncKeywordConflict() regarding generating an
     // ACTION_DELETE manually since Remove() won't do it.
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
-    change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
+    change_list->push_back(syncer::SyncChange(FROM_HERE,
+                                              syncer::SyncChange::ACTION_DELETE,
+                                              sync_data));
     Remove(local_turl);
 
     // Force the local ID to kInvalidTemplateURLID so we can add it.
     sync_turl->data_.id = kInvalidTemplateURLID;
     Add(scoped_sync_turl.release());
     if (delete_default)
       SetDefaultSearchProvider(sync_turl);
   } else {
     // Change the local TURL's GUID to the server's GUID and push an update to
     // Sync. This ensures that the rest of local_url's fields are sync'd up to
     // the server, and the next time local_url is synced, it is recognized by
     // having the same GUID.
     ResetTemplateURLGUID(local_turl, sync_turl->sync_guid());
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
-    change_list->push_back(
-        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
+    change_list->push_back(syncer::SyncChange(FROM_HERE,
+                                              syncer::SyncChange::ACTION_UPDATE,
+                                              sync_data));
   }
 }
 
 void TemplateURLService::SetDefaultSearchProviderIfNewlySynced(
     const std::string& guid) {
   // If we're not syncing or if default search is managed by policy, ignore.
   if (!sync_processor_.get() || is_default_search_managed_)
     return;
 
   PrefService* prefs = GetPrefs();
@@ skipping 32 matching lines @@
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if (template_url->sync_guid().empty() &&
         !template_url->IsExtensionKeyword()) {
       template_url->data_.sync_guid = base::GenerateGUID();
       if (service_.get())
         service_->UpdateKeyword(template_url->data());
     }
   }
 }