Convert SupervisedUserResourceThrottle to a NavigationThrottle.

chrome/browser/supervised_user/supervised_user_url_filter.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/supervised_user/supervised_user_url_filter.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 223 matching lines @@
     : default_behavior_(ALLOW),
       contents_(new Contents()),
       blacklist_(nullptr),
       amp_cache_path_regex_(kAmpCachePathPattern),
       google_amp_viewer_path_regex_(kGoogleAmpViewerPathPattern),
       google_web_cache_query_regex_(kGoogleWebCacheQueryPattern),
       blocking_task_runner_(
           BrowserThread::GetBlockingPool()
               ->GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
-              .get()) {
+              .get()),
+      weak_ptr_factory_(this) {
   DCHECK(amp_cache_path_regex_.ok());
   DCHECK(google_amp_viewer_path_regex_.ok());
   DCHECK(google_web_cache_query_regex_.ok());
   // Detach from the current thread so we can be constructed on a different
   // thread than the one where we're used.
   DetachFromThread();
 }
 
-SupervisedUserURLFilter::~SupervisedUserURLFilter() {
-  DCHECK(CalledOnValidThread());
-}
+SupervisedUserURLFilter::~SupervisedUserURLFilter() {}
 
 // static
 SupervisedUserURLFilter::FilteringBehavior
 SupervisedUserURLFilter::BehaviorFromInt(int behavior_value) {
   DCHECK_GE(behavior_value, ALLOW);
   DCHECK_LE(behavior_value, BLOCK);
   return static_cast<FilteringBehavior>(behavior_value);
 }
 
 // static
@@ skipping 208 matching lines @@
 SupervisedUserURLFilter::FilteringBehavior
 SupervisedUserURLFilter::GetDefaultFilteringBehavior() const {
   return default_behavior_;
 }
 
 void SupervisedUserURLFilter::LoadWhitelists(
     const std::vector<scoped_refptr<SupervisedUserSiteList>>& site_lists) {
   DCHECK(CalledOnValidThread());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_.get(),
-      FROM_HERE,
+      blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&LoadWhitelistsOnBlockingPoolThread, site_lists),
-      base::Bind(&SupervisedUserURLFilter::SetContents, this));
+      base::Bind(&SupervisedUserURLFilter::SetContents,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void SupervisedUserURLFilter::SetBlacklist(
     const SupervisedUserBlacklist* blacklist) {
   blacklist_ = blacklist;
 }
 
 bool SupervisedUserURLFilter::HasBlacklist() const {
   return !!blacklist_;
 }
 
 void SupervisedUserURLFilter::SetFromPatternsForTesting(
     const std::vector<std::string>& patterns) {
   DCHECK(CalledOnValidThread());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_.get(),
-      FROM_HERE,
+      blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&CreateWhitelistFromPatternsForTesting, patterns),
-      base::Bind(&SupervisedUserURLFilter::SetContents, this));
+      base::Bind(&SupervisedUserURLFilter::SetContents,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void SupervisedUserURLFilter::SetFromSiteListsForTesting(
     const std::vector<scoped_refptr<SupervisedUserSiteList>>& site_lists) {
   DCHECK(CalledOnValidThread());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&CreateWhitelistsFromSiteListsForTesting, site_lists),
-      base::Bind(&SupervisedUserURLFilter::SetContents, this));
+      base::Bind(&SupervisedUserURLFilter::SetContents,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void SupervisedUserURLFilter::SetManualHosts(
-    const std::map<std::string, bool>* host_map) {
+    std::map<std::string, bool> host_map) {
   DCHECK(CalledOnValidThread());
-  host_map_ = *host_map;
+  host_map_ = std::move(host_map);
 }
 
-void SupervisedUserURLFilter::SetManualURLs(
-    const std::map<GURL, bool>* url_map) {
+void SupervisedUserURLFilter::SetManualURLs(std::map<GURL, bool> url_map) {
   DCHECK(CalledOnValidThread());
-  url_map_ = *url_map;
+  url_map_ = std::move(url_map);
 }
 
 void SupervisedUserURLFilter::InitAsyncURLChecker(
     net::URLRequestContextGetter* context) {
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("supervised_user_url_filter", R"(
         semantics {
           sender: "Supervised Users"
           description:
             "Checks whether a given URL (or set of URLs) is considered safe by "
@@ skipping 140 matching lines @@
 
   FilteringBehavior behavior =
       GetBehaviorFromSafeSearchClassification(classification);
 
   callback.Run(behavior, supervised_user_error_page::ASYNC_CHECKER, uncertain);
   for (Observer& observer : observers_) {
     observer.OnURLChecked(url, behavior,
                           supervised_user_error_page::ASYNC_CHECKER, uncertain);
   }
 }