Misc. cleanup found while mucking with search engines code:

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 <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 870 matching lines @@
     if (!loaded_)
       visits_to_add_.push_back(*visit_details.ptr());
     else
       UpdateKeywordSearchTermsForURL(*visit_details.ptr());
   } else if (type == chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED) {
     // Policy has been updated, so the default search prefs may be different.
     // Reload the default search provider from them.
     // TODO(pkasting): Rather than communicating via prefs, we should eventually
     // observe policy changes directly.
     UpdateDefaultSearch();
-  } else if (type == chrome::NOTIFICATION_GOOGLE_URL_UPDATED) {
+  } else {
+    DCHECK_EQ(chrome::NOTIFICATION_GOOGLE_URL_UPDATED, type);
     if (loaded_) {
       GoogleBaseURLChanged(
           content::Details<GoogleURLTracker::UpdatedDetails>(details)->first);
     }
-  } else {
-    NOTREACHED();
   }
 }
 
 void TemplateURLService::Shutdown() {
   // This check has to be done at Shutdown() instead of in the dtor to ensure
   // that no clients of WebDataService are holding ptrs to it after the first
   // phase of the KeyedService Shutdown() process.
   if (load_handle_) {
     DCHECK(service_.get());
     service_->CancelRequest(load_handle_);
@@ skipping 77 matching lines @@
 
     // Explicitly don't check for conflicts against extension keywords; in this
     // case the functions which modify the keyword map know how to handle the
     // conflicts.
     // TODO(mpcomplete): If we allow editing extension keywords, then those will
     // need to undergo conflict resolution.
     TemplateURL* existing_keyword_turl =
         FindNonExtensionTemplateURLForKeyword(turl->keyword());
     if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
       if (!existing_turl) {
-        NOTREACHED() << "Unexpected sync change state.";
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_DELETE");
-        LOG(ERROR) << "Trying to delete a non-existent TemplateURL.";
         continue;
       }
       if (existing_turl == GetDefaultSearchProvider()) {
         // The only way Sync can attempt to delete the default search provider
         // is if we had changed the kSyncedDefaultSearchProviderGUID
         // preference, but perhaps it has not yet been received. To avoid
         // situations where this has come in erroneously, we will un-delete
         // the current default search from the Sync data. If the pref really
         // does arrive later, then default search will change to the correct
         // entry, but we'll have this extra entry sitting around. The result is
@@ skipping 17 matching lines @@
                                                  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(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_ADD");
-        LOG(ERROR) << "Trying to add an existing TemplateURL.";
         continue;
       }
       const std::string guid = turl->sync_guid();
       if (existing_keyword_turl) {
         // Resolve any conflicts so we can safely add the new entry.
         ResolveSyncKeywordConflict(turl.get(), existing_keyword_turl,
                                    &new_changes);
       }
       // Force the local ID to kInvalidTemplateURLID so we can add it.
       TemplateURLData data(turl->data());
       data.id = kInvalidTemplateURLID;
       Add(new TemplateURL(profile_, data));
 
       // Possibly set the newly added |turl| as the default search provider.
       SetDefaultSearchProviderIfNewlySynced(guid);
     } else if (iter->change_type() == syncer::SyncChange::ACTION_UPDATE) {
       if (!existing_turl) {
-        NOTREACHED() << "Unexpected sync change state.";
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_UPDATE");
-        LOG(ERROR) << "Trying to update a non-existent TemplateURL.";
         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);
       }
       UIThreadSearchTermsData search_terms_data(existing_turl->profile());
       if (UpdateNoNotify(existing_turl, *turl, search_terms_data))
         NotifyObservers();
     } else {
       // We've unexpectedly received an ACTION_INVALID.
-      NOTREACHED() << "Unexpected sync change state.";
       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.
   if (error.IsSet())
     return error;
@@ skipping 358 matching lines @@
                                 profile_source);
     notification_registrar_.Add(this, chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
                                 profile_source);
     pref_change_registrar_.Init(GetPrefs());
     pref_change_registrar_.Add(
         prefs::kSyncedDefaultSearchProviderGUID,
         base::Bind(
             &TemplateURLService::OnSyncedDefaultSearchProviderGUIDChanged,
             base::Unretained(this)));
   }
-  notification_registrar_.Add(this,
-      chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED,
+  notification_registrar_.Add(
+      this, chrome::NOTIFICATION_DEFAULT_SEARCH_POLICY_CHANGED,
       content::NotificationService::AllSources());
 
   if (num_initializers > 0) {
     // This path is only hit by test code and is used to simulate a loaded
     // TemplateURLService.
     ChangeToLoadedState();
 
     // Add specific initializers, if any.
     for (int i(0); i < num_initializers; ++i) {
       DCHECK(initializers[i].keyword);
@@ skipping 712 matching lines @@
     // likely to race with the update from the other client, resulting in
     // a possibly random default search provider.
     if (sync_processor_.get() && url && !url->sync_guid().empty() &&
         GetPrefs() && !processing_syncer_changes_) {
       GetPrefs()->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                             url->sync_guid());
     }
   }
 
   if (service_.get())
-    service_->SetDefaultSearchProvider(url);
+    service_->SetDefaultSearchProviderID(url ? url->id() : 0);
 
   // Inform sync the change to the show_in_default_list flag.
   if (url)
     ProcessTemplateURLChange(FROM_HERE,
                              url,
                              syncer::SyncChange::ACTION_UPDATE);
   return true;
 }
 
 bool TemplateURLService::AddNoNotify(TemplateURL* template_url,
@@ skipping 44 matching lines @@
     // template_url and add it to the guid_to_template_map_.
     ProcessTemplateURLChange(FROM_HERE,
                              template_url,
                              syncer::SyncChange::ACTION_ADD);
   }
 
   return true;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
+  DCHECK(template_url != default_search_provider_);
+
   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);
 
   if (template_url->GetType() != TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) {
     if (service_.get())
       service_->RemoveKeyword(template_url->id());
 
     // Inform sync of the deletion.
@@ skipping 459 matching lines @@
           new_dse = *i;
           break;
         }
       }
     }
   }
   if (!new_dse)
     new_dse = FindNewDefaultSearchProvider();
   SetDefaultSearchProviderNoNotify(new_dse);
 }