Remove NOTIFICATION_HISTORY_URLS_DELETED

chrome/browser/predictors/resource_prefetch_predictor.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 "chrome/browser/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_db_task.h"
-#include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/browser/notification_types.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/mime_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
@@ skipping 385 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Result* result = new Result(key_type, requests);
   // Add the results to the results map.
   if (!results_map_.insert(std::make_pair(navigation_id, result)).second) {
     DLOG(FATAL) << "Returning results for existing navigation.";
     delete result;
   }
 }
 
-void ResourcePrefetchPredictor::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  switch (type) {
-    case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
-      DCHECK_EQ(initialization_state_, INITIALIZED);
-      const content::Details<const history::URLsDeletedDetails>
-          urls_deleted_details =
-              content::Details<const history::URLsDeletedDetails>(details);
-      if (urls_deleted_details->all_history) {
-        DeleteAllUrls();
-        UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ReportingEvent",
-                                  REPORTING_EVENT_ALL_HISTORY_CLEARED,
-                                  REPORTING_EVENT_COUNT);
-      } else {
-        DeleteUrls(urls_deleted_details->rows);
-        UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ReportingEvent",
-                                  REPORTING_EVENT_PARTIAL_HISTORY_CLEARED,
-                                  REPORTING_EVENT_COUNT);
-      }
-      break;
-    }
-
-    default:
-      NOTREACHED() << "Unexpected notification observed.";
-      break;
-  }
-}
-
 void ResourcePrefetchPredictor::Shutdown() {
   if (prefetch_manager_.get()) {
     prefetch_manager_->ShutdownOnUIThread();
     prefetch_manager_ = NULL;
   }
+  history_service_observer_.RemoveAll();
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
   RecordNavigationEvent(NAVIGATION_EVENT_REQUEST_STARTED);
 
   StartPrefetching(request.navigation_id);
@@ skipping 215 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeRemovePrefetch,
                  prefetch_manager_,
                  navigation_id));
 }
 
 void ResourcePrefetchPredictor::StartInitialization() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  DCHECK_EQ(initialization_state_, NOT_INITIALIZED);
+  DCHECK_EQ(NOT_INITIALIZED, initialization_state_);
   initialization_state_ = INITIALIZING;
 
   // Create local caches using the database as loaded.
   scoped_ptr<PrefetchDataMap> url_data_map(new PrefetchDataMap());
   scoped_ptr<PrefetchDataMap> host_data_map(new PrefetchDataMap());
   PrefetchDataMap* url_data_ptr = url_data_map.get();
   PrefetchDataMap* host_data_ptr = host_data_map.get();
 
   BrowserThread::PostTaskAndReply(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::GetAllData,
                  tables_, url_data_ptr, host_data_ptr),
       base::Bind(&ResourcePrefetchPredictor::CreateCaches, AsWeakPtr(),
                  base::Passed(&url_data_map), base::Passed(&host_data_map)));
 }
 
 void ResourcePrefetchPredictor::CreateCaches(
     scoped_ptr<PrefetchDataMap> url_data_map,
     scoped_ptr<PrefetchDataMap> host_data_map) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  DCHECK_EQ(initialization_state_, INITIALIZING);
+  DCHECK_EQ(INITIALIZING, initialization_state_);
   DCHECK(!url_table_cache_);
   DCHECK(!host_table_cache_);
   DCHECK(inflight_navigations_.empty());
 
   url_table_cache_.reset(url_data_map.release());
   host_table_cache_.reset(host_data_map.release());
 
   UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.UrlTableMainFrameUrlCount",
                        url_table_cache_->size());
   UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HostTableHostCount",
                        host_table_cache_->size());
 
   ConnectToHistoryService();
 }
 
 void ResourcePrefetchPredictor::OnHistoryAndCacheLoaded() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_EQ(initialization_state_, INITIALIZING);
-
-  notification_registrar_.Add(this,
-                              chrome::NOTIFICATION_HISTORY_URLS_DELETED,
-                              content::Source<Profile>(profile_));
+  DCHECK_EQ(INITIALIZING, initialization_state_);
 
   // Initialize the prefetch manager only if prefetching is enabled.
   if (config_.IsPrefetchingEnabled(profile_)) {
     prefetch_manager_ = new ResourcePrefetcherManager(
         this, config_, profile_->GetRequestContext());
   }
-
-  history_service_observer_.RemoveAll();
   initialization_state_ = INITIALIZED;
 }
 
 void ResourcePrefetchPredictor::CleanupAbandonedNavigations(
     const NavigationID& navigation_id) {
   static const base::TimeDelta max_navigation_age =
       base::TimeDelta::FromSeconds(config_.max_navigation_lifetime_seconds);
 
   base::TimeTicks time_now = base::TimeTicks::Now();
   for (NavigationMap::iterator it = inflight_navigations_.begin();
@@ skipping 25 matching lines @@
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::DeleteAllData, tables_));
 }
 
 void ResourcePrefetchPredictor::DeleteUrls(const history::URLRows& urls) {
   // Check all the urls in the database and pick out the ones that are present
   // in the cache.
   std::vector<std::string> urls_to_delete, hosts_to_delete;
 
-  for (history::URLRows::const_iterator it = urls.begin(); it != urls.end();
-       ++it) {
-    const std::string url_spec = it->url().spec();
+  for (const auto& it : urls) {
+    const std::string& url_spec = it.url().spec();
     if (url_table_cache_->find(url_spec) != url_table_cache_->end()) {
       urls_to_delete.push_back(url_spec);
       url_table_cache_->erase(url_spec);
     }
 
-    const std::string host = it->url().host();
+    const std::string& host = it.url().host();
     if (host_table_cache_->find(host) != host_table_cache_->end()) {
       hosts_to_delete.push_back(host);
       host_table_cache_->erase(host);
     }
   }
 
   if (!urls_to_delete.empty() || !hosts_to_delete.empty()) {
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&ResourcePrefetchPredictorTables::DeleteData,
                    tables_,
@@ skipping 503 matching lines @@
     RPP_PREDICTED_HISTOGRAM_PERCENTAGE(
         "PrefetchFromNetworkPercentOfTotalFromNetwork",
         prefetch_network * 100.0 / total_resources_fetched_from_network);
   }
 
 #undef RPP_HISTOGRAM_MEDIUM_TIMES
 #undef RPP_PREDICTED_HISTOGRAM_PERCENTAGE
 #undef RPP_PREDICTED_HISTOGRAM_COUNTS
 }
 
+void ResourcePrefetchPredictor::OnURLsDeleted(
+    HistoryService* history_service,
+    bool all_history,
+    bool expired,
+    const history::URLRows& deleted_rows,
+    const std::set<GURL>& favicon_urls) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_EQ(INITIALIZED, initialization_state_);

[sky, 2014/12/13 00:29:18]

Similar comment here.

[nshaik, 2014/12/13 01:49:21]

True, I can modify the code to check for initialization_state_ and return if it
is not.

+  if (all_history) {
+    DeleteAllUrls();
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ReportingEvent",
+                              REPORTING_EVENT_ALL_HISTORY_CLEARED,
+                              REPORTING_EVENT_COUNT);
+  } else {
+    DeleteUrls(deleted_rows);
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ReportingEvent",
+                              REPORTING_EVENT_PARTIAL_HISTORY_CLEARED,
+                              REPORTING_EVENT_COUNT);
+  }
+}
+
 void ResourcePrefetchPredictor::OnHistoryServiceLoaded(
     HistoryService* history_service) {
   OnHistoryAndCacheLoaded();
   history_service_observer_.Remove(history_service);
 }
 
 void ResourcePrefetchPredictor::ConnectToHistoryService() {
   // Register for HistoryServiceLoading if it is not ready.
   HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
   if (!history_service)
     return;
   if (history_service->BackendLoaded()) {
     // HistoryService is already loaded. Continue with Initialization.
     OnHistoryAndCacheLoaded();
     return;
   }
   DCHECK(!history_service_observer_.IsObserving(history_service));
   history_service_observer_.Add(history_service);
   return;
 }
 
 }  // namespace predictors