Remove NOTIFICATION_HISTORY_URLS_DELETED

chrome/browser/predictors/resource_prefetch_predictor.h

 // 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.
 
 #ifndef CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_
 #define CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "chrome/browser/predictors/resource_prefetch_common.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 #include "chrome/browser/predictors/resource_prefetcher.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/keyed_service/core/keyed_service.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "content/public/common/resource_type.h"
 #include "url/gurl.h"
 
 class PredictorsHandler;
 class Profile;
 
-namespace content {
-class WebContents;
-}
-
 namespace net {
 class URLRequest;
 }
 
 namespace predictors {
 
 class ResourcePrefetcherManager;
 
 // Contains logic for learning what can be prefetched and for kicking off
 // speculative prefetching.
@@ skipping 22 matching lines @@
 // * ResourcePrefetcher - Lives entirely on the IO thread, owned by the
 //   ResourcePrefetcherManager, and issues net::URLRequest to fetch resources.
 //
 // TODO(shishir): Do speculative prefetching for https resources and/or https
 // main frame urls.
 // TODO(zhenw): Currently only main frame requests/redirects/responses are
 // recorded. Consider recording sub-frame responses independently or together
 // with main frame.
 class ResourcePrefetchPredictor
     : public KeyedService,
-      public content::NotificationObserver,
       public history::HistoryServiceObserver,
       public base::SupportsWeakPtr<ResourcePrefetchPredictor> {
  public:
   // Stores the data that we need to get from the URLRequest.
   struct URLRequestSummary {
     URLRequestSummary();
     URLRequestSummary(const URLRequestSummary& other);
     ~URLRequestSummary();
 
     NavigationID navigation_id;
@@ skipping 89 matching lines @@
 
   // Returns true if the main page request is supported for prediction.
   static bool IsHandledMainPage(net::URLRequest* request);
 
   // Returns true if the subresource request is supported for prediction.
   static bool IsHandledSubresource(net::URLRequest* request);
 
   // Returns true if the request (should have a response in it) is cacheable.
   static bool IsCacheable(const net::URLRequest* request);
 
-  // content::NotificationObserver methods override.
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
-
   // KeyedService methods override.
   void Shutdown() override;
 
   // Functions called on different network events pertaining to the loading of
   // main frame resource or sub resources.
   void OnMainFrameRequest(const URLRequestSummary& request);
   void OnMainFrameResponse(const URLRequestSummary& response);
   void OnMainFrameRedirect(const URLRequestSummary& response);
   void OnSubresourceResponse(const URLRequestSummary& response);
 
@@ skipping 86 matching lines @@
       const std::vector<URLRequestSummary>& actual,
       const ResourcePrefetcher::RequestVector& predicted) const;
   void ReportPredictedAccuracyStatsHelper(
       PrefetchKeyType key_type,
       const ResourcePrefetcher::RequestVector& predicted,
       const std::map<GURL, bool>& actual,
       size_t total_resources_fetched_from_network,
       size_t max_assumed_prefetched) const;
 
   // history::HistoryServiceObserver:
+  void OnURLsDeleted(HistoryService* history_service,
+                     bool all_history,
+                     bool expired,
+                     const history::URLRows& deleted_rows,
+                     const std::set<GURL>& favicon_urls) override;
   void OnHistoryServiceLoaded(HistoryService* history_service) override;
 
   // Used to connect to HistoryService or register for service loaded
   // notificatioan.
   void ConnectToHistoryService();
 
   // Used for testing to inject mock tables.
   void set_mock_tables(scoped_refptr<ResourcePrefetchPredictorTables> tables) {
     tables_ = tables;
   }
 
   Profile* const profile_;
   ResourcePrefetchPredictorConfig const config_;
   InitializationState initialization_state_;
   scoped_refptr<ResourcePrefetchPredictorTables> tables_;
   scoped_refptr<ResourcePrefetcherManager> prefetch_manager_;
-  content::NotificationRegistrar notification_registrar_;
   base::CancelableTaskTracker history_lookup_consumer_;
 
   // Map of all the navigations in flight to their resource requests.
   NavigationMap inflight_navigations_;
 
   // Copy of the data in the predictor tables.
   scoped_ptr<PrefetchDataMap> url_table_cache_;
   scoped_ptr<PrefetchDataMap> host_table_cache_;
 
   ResultsMap results_map_;
   STLValueDeleter<ResultsMap> results_map_deleter_;
 
   ScopedObserver<HistoryService, history::HistoryServiceObserver>
       history_service_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourcePrefetchPredictor);
 };
 
 }  // namespace predictors
 
 #endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_