Eliminate NOTIFICATION_HISTORY_LOADED notification

chrome/browser/prerender/prerender_local_predictor.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/prerender/prerender_local_predictor.h"
 
 #include <ctype.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 510 matching lines @@
   }
 
   base::hash_map<string, ListEntry*> entries_;
   std::list<ListEntry*> entry_list_;
   DISALLOW_COPY_AND_ASSIGN(PrefetchList);
 };
 
 PrerenderLocalPredictor::PrerenderLocalPredictor(
     PrerenderManager* prerender_manager)
     : prerender_manager_(prerender_manager),
-      is_history_service_observer_(false),
       weak_factory_(this),
-      prefetch_list_(new PrefetchList()) {
+      prefetch_list_(new PrefetchList()),
+      history_service_observer_(this) {
   RecordEvent(EVENT_CONSTRUCTED);
   if (base::MessageLoop::current()) {
     timer_.Start(FROM_HERE,
                  base::TimeDelta::FromMilliseconds(kInitDelayMs),
                  this,
                  &PrerenderLocalPredictor::Init);
     RecordEvent(EVENT_INIT_SCHEDULED);
   }
 
   static const size_t kChecksumHashSize = 32;
@@ skipping 32 matching lines @@
     if (p->prerender_handle)
       p->prerender_handle->OnCancel();
   }
   STLDeleteContainerPairPointers(
       outstanding_prerender_service_requests_.begin(),
       outstanding_prerender_service_requests_.end());
 }
 
 void PrerenderLocalPredictor::Shutdown() {
   timer_.Stop();
-  if (is_history_service_observer_) {
-    HistoryService* history = GetHistoryIfExists();
-    CHECK(history);
-    history->RemoveObserver(this);
-    is_history_service_observer_ = false;
-  }
+  history_service_observer_.RemoveAll();
 }
 
 void PrerenderLocalPredictor::OnAddVisit(HistoryService* history_service,
                                          const history::BriefVisitInfo& info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RecordEvent(EVENT_ADD_VISIT);
   if (!visit_history_.get())
     return;
   visit_history_->push_back(info);
   if (static_cast<int>(visit_history_->size()) > kVisitHistoryPruneThreshold) {
@@ skipping 530 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RecordEvent(EVENT_INIT_STARTED);
   Profile* profile = prerender_manager_->profile();
   if (!profile ||
       ShouldDisableLocalPredictorBasedOnSyncAndConfiguration(profile)) {
     RecordEvent(EVENT_INIT_FAILED_UNENCRYPTED_SYNC_NOT_ENABLED);
     return;
   }
   HistoryService* history = GetHistoryIfExists();
   if (history) {
-    CHECK(!is_history_service_observer_);
+    CHECK(!history_service_observer_.IsObserving(history));
     history->ScheduleDBTask(
         scoped_ptr<history::HistoryDBTask>(
             new GetVisitHistoryTask(this, kMaxVisitHistory)),
         &history_db_tracker_);
-    history->AddObserver(this);
-    is_history_service_observer_ = true;
+    history_service_observer_.Add(history);
   } else {
     RecordEvent(EVENT_INIT_FAILED_NO_HISTORY);
   }
 }
 
 void PrerenderLocalPredictor::OnPLTEventForURL(const GURL& url,
                                                base::TimeDelta page_load_time) {
   if (prefetch_list_->MarkPLTSeen(url, page_load_time)) {
     UMA_HISTOGRAM_CUSTOM_TIMES("Prerender.LocalPredictorPrefetchMatchPLT",
                                page_load_time,
@@ skipping 414 matching lines @@
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_MERGEABLE:
       RecordEvent(EVENT_NAMESPACE_MISMATCH_MERGE_RESULT_MERGEABLE);
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace prerender