Move most TemplateURL data members to a new struct, TemplateURLData. This allows us to eliminate t…

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/i18n/case_conversion.h"
@@ skipping 297 matching lines @@
 const TemplateURL* TemplateURLService::GetTemplateURLForHost(
     const std::string& host) const {
   return provider_map_.GetTemplateURLForHost(host);
 }
 
 void TemplateURLService::Add(TemplateURL* template_url) {
   AddNoNotify(template_url);
   NotifyObservers();
 }
 
+void TemplateURLService::AddWithOverrides(const TemplateURL* template_url,
+                                          const string16& short_name,
+                                          const string16& keyword,
+                                          const std::string& url) {
+  TemplateURL* modifiable_url = const_cast<TemplateURL*>(template_url);
+  modifiable_url->data_.short_name = short_name;
+  modifiable_url->data_.SetKeyword(keyword);
+  modifiable_url->SetURL(url);
+  Add(modifiable_url);
+}
+
 void TemplateURLService::Remove(const TemplateURL* template_url) {
   RemoveNoNotify(template_url);
   NotifyObservers();
 }
 
 void TemplateURLService::RemoveAutoGeneratedSince(base::Time created_after) {
   RemoveAutoGeneratedBetween(created_after, base::Time());
 }
 
 void TemplateURLService::RemoveAutoGeneratedBetween(base::Time created_after,
@@ skipping 32 matching lines @@
 
   Load();
   if (!loaded_) {
     pending_extension_ids_.push_back(extension->id());
     return;
   }
 
   const TemplateURL* existing_url = GetTemplateURLForExtension(extension);
   string16 keyword = UTF8ToUTF16(extension->omnibox_keyword());
 
-  scoped_ptr<TemplateURL> template_url(new TemplateURL);
-  template_url->set_short_name(UTF8ToUTF16(extension->name()));
-  template_url->set_keyword(keyword);
+  TemplateURLData data;
+  data.short_name = UTF8ToUTF16(extension->name());
+  data.SetKeyword(UTF8ToUTF16(extension->omnibox_keyword()));
   // This URL is not actually used for navigation. It holds the extension's
   // ID, as well as forcing the TemplateURL to be treated as a search keyword.
-  template_url->SetURL(
-      std::string(chrome::kExtensionScheme) + "://" +
-      extension->id() + "/?q={searchTerms}");
-  template_url->set_safe_for_autoreplace(false);
+  data.SetURL(std::string(chrome::kExtensionScheme) + "://" + extension->id() +
+      "/?q={searchTerms}");
+  scoped_ptr<TemplateURL> template_url(new TemplateURL(data));
 
   if (existing_url) {
     // TODO(mpcomplete): only replace if the user hasn't changed the keyword.
     // (We don't have UI for that yet).
     UpdateNoNotify(existing_url, *template_url);
   } else {
     AddNoNotify(template_url.release());
   }
   NotifyObservers();
 }
@@ skipping 17 matching lines @@
   return NULL;
 }
 
 std::vector<const TemplateURL*> TemplateURLService::GetTemplateURLs() const {
   return template_urls_;
 }
 
 void TemplateURLService::IncrementUsageCount(const TemplateURL* url) {
   DCHECK(url && std::find(template_urls_.begin(), template_urls_.end(), url) !=
          template_urls_.end());
-  const_cast<TemplateURL*>(url)->set_usage_count(url->usage_count() + 1);
+  ++const_cast<TemplateURL*>(url)->data_.usage_count;
   if (service_.get())
-    service_.get()->UpdateKeyword(*url);
+    service_->UpdateKeyword(*url);
 }
 
 void TemplateURLService::ResetTemplateURL(const TemplateURL* url,
                                           const string16& title,
                                           const string16& keyword,
                                           const std::string& search_url) {
-  TemplateURL new_url(*url);
-  new_url.set_short_name(title);
-  new_url.set_keyword(keyword);
-  if (new_url.url() != search_url) {
-    new_url.SetURL(search_url);
+  TemplateURLData data(url->data());
+  data.short_name = title;
+  data.SetKeyword(keyword);
+  if (search_url != data.url()) {
+    data.SetURL(search_url);
     // The urls have changed, reset the favicon url.
-    new_url.set_favicon_url(GURL());
+    data.favicon_url = GURL();
   }
-  new_url.set_safe_for_autoreplace(false);
-  new_url.set_last_modified(time_provider_());
+  data.safe_for_autoreplace = false;
+  data.last_modified = time_provider_();
+  TemplateURL new_url(data);
   UpdateNoNotify(url, new_url);
   NotifyObservers();
 }
 
 bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
   return url != GetDefaultSearchProvider() &&
       url->url_ref().SupportsReplacement() && !is_default_search_managed();
 }
 
 void TemplateURLService::SetDefaultSearchProvider(const TemplateURL* url) {
@@ skipping 115 matching lines @@
 
   if (is_default_search_managed_) {
     SetTemplateURLs(template_urls);
 
     if (TemplateURLsHaveSamePrefs(default_search_provider,
                                   default_from_prefs.get())) {
       // The value from the preferences was previously stored in the database.
       // Reuse it.
     } else {
       // The value from the preferences takes over.
-      //
-      // AddNoNotify will take ownership of default_from_prefs so it is safe to
-      // release. If it's null, there's no ownership to worry about :-)
-      TemplateURL* managed_default = default_from_prefs.release();
-      if (managed_default) {
-        managed_default->set_created_by_policy(true);
-        managed_default->set_id(kInvalidTemplateURLID);
+      default_search_provider = NULL;
+      if (default_from_prefs.get()) {
+        TemplateURLData data(default_from_prefs->data());
+        data.created_by_policy = true;
+        data.id = kInvalidTemplateURLID;
+        TemplateURL* managed_default = new TemplateURL(data);
         AddNoNotify(managed_default);
+        default_search_provider = managed_default;
       }
-      default_search_provider = managed_default;
     }
     // Note that this saves the default search provider to prefs.
     SetDefaultSearchProviderNoNotify(default_search_provider);
   } else {
     // If we had a managed default, replace it with the synced default if
     // applicable, or the first provider of the list.
     const TemplateURL* synced_default = GetPendingSyncedDefaultSearchProvider();
     if (synced_default) {
       default_search_provider = synced_default;
       pending_synced_default_search_ = false;
     } else if (database_specified_a_default &&
-               NULL == default_search_provider &&
+               default_search_provider == NULL &&
                !template_urls.empty()) {
       default_search_provider = template_urls[0];
     }
 
     // If the default search provider existed previously, then just
     // set the member variable. Otherwise, we'll set it using the method
     // to ensure that it is saved properly after its id is set.
     if (default_search_provider &&
         (default_search_provider->id() != kInvalidTemplateURLID)) {
       default_search_provider_ = default_search_provider;
@@ skipping 141 matching lines @@
   }
 
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   SyncChangeList new_changes;
   SyncError error;
   for (SyncChangeList::const_iterator iter = change_list.begin();
       iter != change_list.end(); ++iter) {
     DCHECK_EQ(syncable::SEARCH_ENGINES, iter->sync_data().GetDataType());
 
-    scoped_ptr<TemplateURL> turl(
-        CreateTemplateURLFromSyncData(iter->sync_data()));
-    if (!turl.get()) {
-      NOTREACHED() << "Failed to read search engine.";
-      continue;
-    }
+    std::string guid =
+        iter->sync_data().GetSpecifics().search_engine().sync_guid();
+    const TemplateURL* existing_turl = GetTemplateURLForGUID(guid);
+    scoped_ptr<TemplateURL> turl(CreateTemplateURLFromTemplateURLAndSyncData(
+        existing_turl, iter->sync_data()));
 
-    const TemplateURL* existing_turl = GetTemplateURLForGUID(turl->sync_guid());
     const TemplateURL* existing_keyword_turl =
         GetTemplateURLForKeyword(turl->keyword());
 
     if (iter->change_type() == SyncChange::ACTION_DELETE && existing_turl) {
       bool delete_default = (existing_turl == GetDefaultSearchProvider());
 
       if (delete_default && is_default_search_managed_) {
         NOTREACHED() << "Tried to delete managed default search provider";
       } else {
         if (delete_default)
           default_search_provider_ = NULL;
 
         Remove(existing_turl);
 
         if (delete_default)
           SetDefaultSearchProvider(FindNewDefaultSearchProvider());
       }
     } else if (iter->change_type() == SyncChange::ACTION_ADD &&
                !existing_turl) {
       std::string guid = turl->sync_guid();
       if (existing_keyword_turl)
         ResolveSyncKeywordConflict(turl.get(), &new_changes);
       // Force the local ID to kInvalidTemplateURLID so we can add it.
-      turl->set_id(kInvalidTemplateURLID);
-      Add(turl.release());
+      TemplateURLData data(turl->data());
+      data.id = kInvalidTemplateURLID;
+      Add(new TemplateURL(data));
 
       // Possibly set the newly added |turl| as the default search provider.
       SetDefaultSearchProviderIfNewlySynced(guid);
     } else if (iter->change_type() == SyncChange::ACTION_UPDATE &&
                existing_turl) {
       // Possibly resolve a keyword conflict if they have the same keywords but
       // are not the same entry.
-      TemplateURL updated_turl(*existing_turl);
-      UpdateTemplateURLWithSyncData(&updated_turl, iter->sync_data());
       if (existing_keyword_turl && existing_keyword_turl != existing_turl)
-        ResolveSyncKeywordConflict(&updated_turl, &new_changes);
-      UpdateNoNotify(existing_turl, updated_turl);
+        ResolveSyncKeywordConflict(turl.get(), &new_changes);
+      UpdateNoNotify(existing_turl, *turl);
       NotifyObservers();
     } else {
       // Something really unexpected happened. Either we received an
       // ACTION_INVALID, or Sync is in a crazy state:
       //  . Trying to DELETE or UPDATE a non-existent search engine.
       //  . Trying to ADD a search engine that already exists.
       NOTREACHED() << "Unexpected sync change state.";
       error = SyncError(FROM_HERE, "ProcessSyncChanges failed on ChangeType " +
           SyncChange::ChangeTypeToString(iter->change_type()),
           syncable::SEARCH_ENGINES);
@@ skipping 38 matching lines @@
 
   SyncChangeList new_changes;
 
   // Build maps of our sync GUIDs to SyncData.
   SyncDataMap local_data_map = CreateGUIDToSyncDataMap(
       GetAllSyncData(syncable::SEARCH_ENGINES));
   SyncDataMap sync_data_map = CreateGUIDToSyncDataMap(initial_sync_data);
 
   for (SyncDataMap::const_iterator iter = sync_data_map.begin();
       iter != sync_data_map.end(); ++iter) {
+    const TemplateURL* local_turl = GetTemplateURLForGUID(iter->first);
     scoped_ptr<TemplateURL> sync_turl(
-        CreateTemplateURLFromSyncData(iter->second));
-    DCHECK(sync_turl.get());
-    const TemplateURL* local_turl = GetTemplateURLForGUID(iter->first);
+        CreateTemplateURLFromTemplateURLAndSyncData(local_turl, iter->second));
 
     if (sync_turl->sync_guid().empty()) {
       // Due to a bug, older search engine entries with no sync GUID
       // may have been uploaded to the server.  This is bad data, so
       // just delete it.
       new_changes.push_back(
           SyncChange(SyncChange::ACTION_DELETE, iter->second));
     } else 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.
-        TemplateURL updated_turl(*local_turl);
-        UpdateTemplateURLWithSyncData(&updated_turl, iter->second);
-        UpdateNoNotify(local_turl, updated_turl);
+        UpdateNoNotify(local_turl, *sync_turl);
         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(SyncChange(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
@@ skipping 10 matching lines @@
                                        &new_changes);
         local_data_map.erase(old_guid);
       } else {
         std::string guid = sync_turl->sync_guid();
         // Keyword conflict is possible in this case. Resolve it first before
         // adding the new TemplateURL. Note that we don't remove the local TURL
         // from local_data_map in this case as it may still need to be pushed to
         // the cloud.
         ResolveSyncKeywordConflict(sync_turl.get(), &new_changes);
         // Force the local ID to kInvalidTemplateURLID so we can add it.
-        sync_turl->set_id(kInvalidTemplateURLID);
-        Add(sync_turl.release());
+        TemplateURLData data(sync_turl->data());
+        data.id = kInvalidTemplateURLID;
+        Add(new TemplateURL(data));
 
         // Possibly set the newly added |turl| as the default search provider.
         SetDefaultSearchProviderIfNewlySynced(guid);
       }
     }
   }  // for
 
   // 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();
@@ skipping 63 matching lines @@
   se_specifics->set_autogenerate_keyword(turl.autogenerate_keyword());
   se_specifics->set_instant_url(turl.instant_url());
   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
   se_specifics->set_sync_guid(turl.sync_guid());
   return SyncData::CreateLocalData(se_specifics->sync_guid(),
                                    se_specifics->keyword(),
                                    specifics);
 }
 
 // static
-TemplateURL* TemplateURLService::CreateTemplateURLFromSyncData(
+TemplateURL* TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
+    const TemplateURL* existing_turl,
     const SyncData& sync_data) {
-  TemplateURL* turl = new TemplateURL();
-  UpdateTemplateURLWithSyncData(turl, sync_data);
-  return turl;
+  sync_pb::SearchEngineSpecifics specifics =
+      sync_data.GetSpecifics().search_engine();
+
+  TemplateURLData data;
+  data.short_name = UTF8ToUTF16(specifics.short_name());
+  data.originating_url = GURL(specifics.originating_url());
+  data.SetKeyword(UTF8ToUTF16(specifics.keyword()));
+  data.SetAutogenerateKeyword(specifics.autogenerate_keyword());
+  data.SetURL(specifics.url());
+  data.suggestions_url = specifics.suggestions_url();
+  data.instant_url = specifics.instant_url();
+  data.favicon_url = GURL(specifics.favicon_url());
+  data.show_in_default_list = specifics.show_in_default_list();
+  data.safe_for_autoreplace = specifics.safe_for_autoreplace();
+  base::SplitString(specifics.input_encodings(), ';', &data.input_encodings);
+  data.date_created = base::Time::FromInternalValue(specifics.date_created());
+  data.last_modified = base::Time::FromInternalValue(specifics.last_modified());
+  data.prepopulate_id = specifics.prepopulate_id();
+  data.sync_guid = specifics.sync_guid();
+  if (existing_turl) {
+    data.id = existing_turl->id();
+    data.created_by_policy = existing_turl->created_by_policy();
+    data.usage_count = existing_turl->usage_count();
+  }
+  return new TemplateURL(data);
 }
 
 // static
 SyncDataMap TemplateURLService::CreateGUIDToSyncDataMap(
     const SyncDataList& sync_data) {
   SyncDataMap data_map;
   SyncDataList::const_iterator iter;
   for (iter = sync_data.begin(); iter != sync_data.end(); ++iter) {
     data_map[iter->GetSpecifics().search_engine().sync_guid()] = *iter;
   }
@@ skipping 40 matching lines @@
 
       size_t template_position =
           std::string(initializers[i].url).find(kTemplateParameter);
       DCHECK(template_position != std::string::npos);
       std::string osd_url(initializers[i].url);
       osd_url.replace(template_position, arraysize(kTemplateParameter) - 1,
                       kSearchTermParameter);
 
       // TemplateURLService ends up owning the TemplateURL, don't try and free
       // it.
-      TemplateURL* template_url = new TemplateURL();
-      template_url->set_keyword(UTF8ToUTF16(initializers[i].keyword));
-      template_url->set_short_name(UTF8ToUTF16(initializers[i].content));
-      template_url->SetURL(osd_url);
-      AddNoNotify(template_url);
+      TemplateURLData data;
+      data.short_name = UTF8ToUTF16(initializers[i].content);
+      data.SetKeyword(UTF8ToUTF16(initializers[i].keyword));
+      data.SetURL(osd_url);
+      AddNoNotify(new TemplateURL(data));
     }
   }
 
   // Initialize default search.
   UpdateDefaultSearch();
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine, not in headless mode and not in Chrome Frame.
   if (initial_default_search_provider_.get() &&
     initial_default_search_provider_->url_ref().HasGoogleBaseURLs()) {
@@ skipping 160 matching lines @@
   string16 keyword =
       UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderKeyword));
   std::string icon_url =
       prefs->GetString(prefs::kDefaultSearchProviderIconURL);
   std::string encodings =
       prefs->GetString(prefs::kDefaultSearchProviderEncodings);
   std::string id_string = prefs->GetString(prefs::kDefaultSearchProviderID);
   std::string prepopulate_id =
       prefs->GetString(prefs::kDefaultSearchProviderPrepopulateID);
 
-  default_provider->reset(new TemplateURL());
-  (*default_provider)->set_short_name(name);
-  (*default_provider)->SetURL(search_url);
-  (*default_provider)->SetSuggestionsURL(suggest_url);
-  (*default_provider)->SetInstantURL(instant_url);
-  (*default_provider)->set_keyword(keyword);
-  (*default_provider)->set_favicon_url(GURL(icon_url));
-  std::vector<std::string> encodings_vector;
-  base::SplitString(encodings, ';', &encodings_vector);
-  (*default_provider)->set_input_encodings(encodings_vector);
+  TemplateURLData data;
+  data.short_name = name;
+  data.SetKeyword(keyword);
+  data.SetURL(search_url);
+  data.suggestions_url = suggest_url;
+  data.instant_url = instant_url;
+  data.favicon_url = GURL(icon_url);
+  data.show_in_default_list = true;
+  base::SplitString(encodings, ';', &data.input_encodings);
   if (!id_string.empty() && !*is_managed) {
     int64 value;
     base::StringToInt64(id_string, &value);
-    (*default_provider)->set_id(value);
+    data.id = value;
   }
   if (!prepopulate_id.empty() && !*is_managed) {
     int value;
     base::StringToInt(prepopulate_id, &value);
-    (*default_provider)->SetPrepopulateId(value);
+    data.prepopulate_id = value;
   }
-  (*default_provider)->set_show_in_default_list(true);
+  default_provider->reset(new TemplateURL(data));
   return true;
 }
 
 bool TemplateURLService::CanReplaceKeywordForHost(
     const std::string& host,
     const TemplateURL** to_replace) {
   const TemplateURLSet* urls = provider_map_.GetURLsForHost(host);
   if (urls) {
     for (TemplateURLSet::const_iterator i = urls->begin();
          i != urls->end(); ++i) {
@@ skipping 21 matching lines @@
   DCHECK(loaded_);
   DCHECK(existing_turl);
   DCHECK(std::find(template_urls_.begin(), template_urls_.end(), existing_turl)
          != template_urls_.end());
 
   if (!existing_turl->keyword().empty())
     keyword_to_template_map_.erase(existing_turl->keyword());
   if (!existing_turl->sync_guid().empty())
     guid_to_template_map_.erase(existing_turl->sync_guid());
 
-  // This call handles copying over the values (while retaining the id).
+  provider_map_.Remove(existing_turl);
+  TemplateURLID previous_id = existing_turl->id();
+  TemplateURL* modifiable_turl = const_cast<TemplateURL*>(existing_turl);
+  *modifiable_turl = new_values;
+  modifiable_turl->data_.id = previous_id;
   UIThreadSearchTermsData search_terms_data;
-  provider_map_.Update(existing_turl, new_values, search_terms_data);
+  provider_map_.Add(existing_turl, search_terms_data);
 
   if (!existing_turl->keyword().empty())
     keyword_to_template_map_[existing_turl->keyword()] = existing_turl;
   if (!existing_turl->sync_guid().empty())
     guid_to_template_map_[existing_turl->sync_guid()] = existing_turl;
 
   if (service_.get())
     service_->UpdateKeyword(*existing_turl);
 
   // Inform sync of the update.
@@ skipping 184 matching lines @@
                                   new_default_from_prefs.get()))
       return;
     if (new_default_from_prefs.get() == NULL) {
       // default_search_provider_ can't be NULL otherwise
       // TemplateURLsHaveSamePrefs would have returned true.  Remove this now
       // invalid value.
       const TemplateURL* old_default = default_search_provider_;
       SetDefaultSearchProviderNoNotify(NULL);
       RemoveNoNotify(old_default);
     } else if (default_search_provider_) {
-      new_default_from_prefs->set_created_by_policy(true);
-      UpdateNoNotify(default_search_provider_, *new_default_from_prefs.get());
+      TemplateURLData data(new_default_from_prefs->data());
+      data.created_by_policy = true;
+      TemplateURL new_values(data);
+      UpdateNoNotify(default_search_provider_, new_values);
     } else {
       // AddNoNotify will take ownership of new_template, so it's safe to
       // release.
-      TemplateURL* new_template = new_default_from_prefs.release();
-      if (new_template) {
-        new_template->set_created_by_policy(true);
+      TemplateURL* new_template = NULL;
+      if (new_default_from_prefs.get()) {
+        TemplateURLData data(new_default_from_prefs->data());
+        data.created_by_policy = true;
+        new_template = new TemplateURL(data);
         AddNoNotify(new_template);
       }
       SetDefaultSearchProviderNoNotify(new_template);
     }
   } else if (!is_default_search_managed_ && new_is_default_managed) {
     // The default used to be unmanaged and is now managed.  Add the new
     // managed default to the list of URLs and set it as default.
     is_default_search_managed_ = new_is_default_managed;
     // AddNoNotify will take ownership of new_template, so it's safe to
     // release.
-    TemplateURL* new_template = new_default_from_prefs.release();
-    if (new_template) {
-      new_template->set_created_by_policy(true);
+    TemplateURL* new_template = NULL;
+    if (new_default_from_prefs.get()) {
+      TemplateURLData data(new_default_from_prefs->data());
+      data.created_by_policy = true;
+      new_template = new TemplateURL(data);
       AddNoNotify(new_template);
     }
     SetDefaultSearchProviderNoNotify(new_template);
   } else {
     // The default was managed and is no longer.
     DCHECK(is_default_search_managed_ && !new_is_default_managed);
     is_default_search_managed_ = new_is_default_managed;
     // If we had a default, delete the previous default if created by policy
     // and set a likely default.
     if (NULL != default_search_provider_ &&
         default_search_provider_->created_by_policy()) {
       const TemplateURL* old_default = default_search_provider_;
       default_search_provider_ = NULL;
       RemoveNoNotify(old_default);
     }
 
     // The likely default should be from Sync if we were waiting on Sync.
     // Otherwise, it should be FindNewDefaultSearchProvider.
     const TemplateURL* synced_default = GetPendingSyncedDefaultSearchProvider();
     if (synced_default)
       pending_synced_default_search_ = false;
     SetDefaultSearchProviderNoNotify(synced_default ? synced_default :
         FindNewDefaultSearchProvider());
   }
   NotifyObservers();
 }
 
 void TemplateURLService::SetDefaultSearchProviderNoNotify(
     const TemplateURL* url) {
-  DCHECK(!url || std::find(template_urls_.begin(), template_urls_.end(), url)
-         != template_urls_.end());
+  DCHECK(!url || std::find(template_urls_.begin(), template_urls_.end(), url) !=
+      template_urls_.end());
   default_search_provider_ = url;
 
   if (url) {
     TemplateURL* modifiable_url = const_cast<TemplateURL*>(url);
     // Don't mark the url as edited, otherwise we won't be able to rev the
     // template urls we ship with.
-    modifiable_url->set_show_in_default_list(true);
+    modifiable_url->data_.show_in_default_list = true;
     if (service_.get())
-      service_.get()->UpdateKeyword(*url);
+      service_->UpdateKeyword(*url);
 
     if (url->url_ref().HasGoogleBaseURLs()) {
       GoogleURLTracker::RequestServerCheck();
 #if defined(ENABLE_RLZ)
       // Needs to be evaluated. See http://crbug.com/62328.
       base::ThreadRestrictions::ScopedAllowIO allow_io;
       RLZTracker::RecordProductEvent(rlz_lib::CHROME,
                                      rlz_lib::CHROME_OMNIBOX,
                                      rlz_lib::SET_TO_GOOGLE);
 #endif
@@ skipping 18 matching lines @@
   // Inform sync the change to the show_in_default_list flag.
   if (url)
     ProcessTemplateURLChange(url, SyncChange::ACTION_UPDATE);
 }
 
 void TemplateURLService::AddNoNotify(TemplateURL* template_url) {
   DCHECK(template_url);
   DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
   DCHECK(std::find(template_urls_.begin(), template_urls_.end(), template_url)
          == template_urls_.end());
-  template_url->set_id(++next_id_);
+  template_url->data_.id = ++next_id_;
   template_urls_.push_back(template_url);
   AddToMaps(template_url);
 
   if (service_.get())
     service_->AddKeyword(*template_url);
 
   // 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, SyncChange::ACTION_ADD);
 }
@@ skipping 10 matching lines @@
     NOTREACHED();
     return;
   }
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
   template_urls_.erase(i);
 
   if (service_.get())
-    service_->RemoveKeyword(*template_url);
+    service_->RemoveKeyword(template_url->id());
 
   // Inform sync of the deletion.
   ProcessTemplateURLChange(template_url, 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,
@@ skipping 44 matching lines @@
 
       // The database loaded a managed |default_search_provider|, but it has
       // been updated in the prefs. Remove it from the database, and update the
       // |default_search_provider| pointer here.
       if (*default_search_provider &&
           (*default_search_provider)->id() == template_url->id())
         *default_search_provider = NULL;
 
       i = template_urls->erase(i);
       if (service_.get())
-        service_->RemoveKeyword(*template_url);
+        service_->RemoveKeyword(template_url->id());
       delete template_url;
     } else {
       ++i;
     }
   }
 }
 
 void TemplateURLService::ResetTemplateURLGUID(const TemplateURL* url,
                                               const std::string& guid) {
   DCHECK(!guid.empty());
 
-  TemplateURL new_url(*url);
-  new_url.set_sync_guid(guid);
+  TemplateURLData data(url->data());
+  data.sync_guid = guid;
+  TemplateURL new_url(data);
   UpdateNoNotify(url, new_url);
 }
 
 string16 TemplateURLService::UniquifyKeyword(const TemplateURL& turl) const {
   // Already unique.
   if (!GetTemplateURLForKeyword(turl.keyword()))
     return turl.keyword();
 
   // First, try to return the generated keyword for the TemplateURL.
   GURL gurl(turl.url());
@@ skipping 23 matching lines @@
   const TemplateURL* existing_turl =
       GetTemplateURLForKeyword(sync_turl->keyword());
   // If there is no conflict, or it's just conflicting with itself, return.
   if (!existing_turl || existing_turl->sync_guid() == sync_turl->sync_guid())
     return false;
 
   if (existing_turl->last_modified() > sync_turl->last_modified() ||
       existing_turl->created_by_policy()) {
     string16 new_keyword = UniquifyKeyword(*sync_turl);
     DCHECK(!GetTemplateURLForKeyword(new_keyword));
-    sync_turl->set_keyword(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.
     SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
     change_list->push_back(SyncChange(SyncChange::ACTION_UPDATE, sync_data));
   } else {
     string16 new_keyword = UniquifyKeyword(*existing_turl);
-    TemplateURL new_turl(*existing_turl);
-    new_turl.set_keyword(new_keyword);
+    TemplateURLData data(existing_turl->data());
+    data.SetKeyword(new_keyword);
+    TemplateURL new_turl(data);
     UpdateNoNotify(existing_turl, new_turl);
     NotifyObservers();
   }
   return true;
 }
 
 const TemplateURL* TemplateURLService::FindDuplicateOfSyncTemplateURL(
     const TemplateURL& sync_turl) {
   const TemplateURL* existing_turl =
       GetTemplateURLForKeyword(sync_turl.keyword());
   if (!existing_turl)
     return NULL;
 
   if (!existing_turl->url().empty() &&
       existing_turl->url() == sync_turl.url()) {
     return existing_turl;
   }
   return NULL;
 }
 
 void TemplateURLService::MergeSyncAndLocalURLDuplicates(
     TemplateURL* sync_turl,
     TemplateURL* local_turl,
     SyncChangeList* change_list) {
   DCHECK(sync_turl);
   DCHECK(local_turl);
   DCHECK(change_list);
-
-  scoped_ptr<TemplateURL> scoped_sync_turl(sync_turl);
-
-  if (scoped_sync_turl->last_modified() > local_turl->last_modified()) {
+  if (sync_turl->last_modified() > local_turl->last_modified()) {
     // Fully replace local_url with Sync's copy. Note that because use Add
     // rather than ResetTemplateURL, |sync_url| is added with a fresh
     // 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());
     if (delete_default && is_default_search_managed_) {
       NOTREACHED() << "Tried to delete managed default search provider";
     } else {
       if (delete_default)
         default_search_provider_ = NULL;
 
       Remove(local_turl);
 
       // Force the local ID to kInvalidTemplateURLID so we can add it.
-      scoped_sync_turl->set_id(kInvalidTemplateURLID);
-      TemplateURL* temp = scoped_sync_turl.release();
-      Add(temp);
+      sync_turl->data_.id = kInvalidTemplateURLID;
+      Add(sync_turl);
       if (delete_default)
-        SetDefaultSearchProvider(temp);
+        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());
     SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
     change_list->push_back(SyncChange(SyncChange::ACTION_UPDATE, sync_data));
+    delete sync_turl;
   }
 }
 
 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 19 matching lines @@
 }
 
 void TemplateURLService::PatchMissingSyncGUIDs(
     std::vector<TemplateURL*>* template_urls) {
   DCHECK(template_urls);
   for (std::vector<TemplateURL*>::iterator i = template_urls->begin();
        i != template_urls->end(); ++i) {
     TemplateURL* template_url = *i;
     DCHECK(template_url);
     if (template_url->sync_guid().empty()) {
-      template_url->set_sync_guid(guid::GenerateGUID());
+      template_url->data_.sync_guid = guid::GenerateGUID();
       if (service_.get())
         service_->UpdateKeyword(*template_url);
     }
   }
 }
-
-// static
-void TemplateURLService::UpdateTemplateURLWithSyncData(
-    TemplateURL* dst,
-    const SyncData& sync_data) {
-  sync_pb::SearchEngineSpecifics specifics =
-      sync_data.GetSpecifics().search_engine();
-  dst->set_short_name(UTF8ToUTF16(specifics.short_name()));
-  dst->set_keyword(UTF8ToUTF16(specifics.keyword()));
-  dst->set_favicon_url(GURL(specifics.favicon_url()));
-  dst->SetURL(specifics.url());
-  dst->set_safe_for_autoreplace(specifics.safe_for_autoreplace());
-  dst->set_originating_url(GURL(specifics.originating_url()));
-  dst->set_date_created(
-      base::Time::FromInternalValue(specifics.date_created()));
-  std::vector<std::string> input_encodings;
-  base::SplitString(specifics.input_encodings(), ';', &input_encodings);
-  dst->set_input_encodings(input_encodings);
-  dst->set_show_in_default_list(specifics.show_in_default_list());
-  dst->SetSuggestionsURL(specifics.suggestions_url());
-  dst->SetPrepopulateId(specifics.prepopulate_id());
-  dst->set_autogenerate_keyword(specifics.autogenerate_keyword());
-  dst->SetInstantURL(specifics.instant_url());
-  dst->set_last_modified(
-      base::Time::FromInternalValue(specifics.last_modified()));
-  dst->set_sync_guid(specifics.sync_guid());
-}