Extract the SafeSearch client to a separate directory

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>
 #include <utility>
 
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.h"
 #include "chrome/browser/supervised_user/experimental/supervised_user_blacklist.h"
 #include "components/policy/core/browser/url_blacklist_manager.h"
 #include "components/url_formatter/url_fixer.h"
 #include "components/url_matcher/url_matcher.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES;
 using net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES;
 using net::registry_controlled_domains::GetRegistryLength;
 using policy::URLBlacklist;
 using url_matcher::URLMatcher;
 using url_matcher::URLMatcherConditionSet;
 
 using HostnameHash = SupervisedUserSiteList::HostnameHash;
 
 namespace {
 
 struct HashHostnameHash {
   size_t operator()(const HostnameHash& value) const {
     return value.hash();
   }
 };
 
+SupervisedUserURLFilter::FilteringBehavior
+GetBehaviorFromSafeSearchClassification(
+    SafeSearchURLChecker::Classification classification) {
+  switch (classification) {
+    case SafeSearchURLChecker::SAFE:
+      return SupervisedUserURLFilter::ALLOW;
+    case SafeSearchURLChecker::UNSAFE:
+      return SupervisedUserURLFilter::BLOCK;
+  }
+  NOTREACHED() << "Every SafeSearchURLChecker::Classification value must have "
+                  "a FilteringBehavior interpretation.";

[Marc Treib, 2016/10/06 13:16:42]

We'll get a compile error anyway if the switch doesn't handle all cases :)

[msramek, 2016/10/06 15:08:41]

I know :) I just meant it as a comment and felt like putting it next to the
NOTREACHED() is a good place.

Let me just remove it, as the message is obvious. But I would keep the
NOTREACHED() to document that the "return" statement below is purely syntactical
and that it doesn't actually mean that BLOCK is the default.

[Marc Treib, 2016/10/06 15:17:15]

Yes, please do keep the NOTREACHED!

+  return SupervisedUserURLFilter::BLOCK;
+}
+
 }  // namespace
 
 struct SupervisedUserURLFilter::Contents {
   URLMatcher url_matcher;
   base::hash_multimap<HostnameHash,
                       scoped_refptr<SupervisedUserSiteList>,
                       HashHostnameHash> hostname_hashes;
   // This only tracks pattern lists.
   std::map<URLMatcherConditionSet::ID, scoped_refptr<SupervisedUserSiteList>>
       site_lists_by_matcher_id;
@@ skipping 384 matching lines @@
 }
 
 void SupervisedUserURLFilter::SetManualURLs(
     const std::map<GURL, bool>* url_map) {
   DCHECK(CalledOnValidThread());
   url_map_ = *url_map;
 }
 
 void SupervisedUserURLFilter::InitAsyncURLChecker(
     net::URLRequestContextGetter* context) {
-  async_url_checker_.reset(new SupervisedUserAsyncURLChecker(context));
+  async_url_checker_.reset(new SafeSearchURLChecker(context));
 }
 
 void SupervisedUserURLFilter::ClearAsyncURLChecker() {
   async_url_checker_.reset();
 }
 
 bool SupervisedUserURLFilter::HasAsyncURLChecker() const {
   return !!async_url_checker_;
 }
 
@@ skipping 21 matching lines @@
 
 void SupervisedUserURLFilter::SetContents(std::unique_ptr<Contents> contents) {
   DCHECK(CalledOnValidThread());
   contents_ = std::move(contents);
   FOR_EACH_OBSERVER(Observer, observers_, OnSiteListUpdated());
 }
 
 void SupervisedUserURLFilter::CheckCallback(
     const FilteringBehaviorCallback& callback,
     const GURL& url,
-    FilteringBehavior behavior,
+    SafeSearchURLChecker::Classification classification,
     bool uncertain) const {
   DCHECK(default_behavior_ != BLOCK);
 
+  FilteringBehavior behavior =
+      GetBehaviorFromSafeSearchClassification(classification);
+
   callback.Run(behavior, supervised_user_error_page::ASYNC_CHECKER, uncertain);
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnURLChecked(url, behavior, supervised_user_error_page::ASYNC_CHECKER,
                    uncertain));
 }