Move the supervised user error page to a component

chrome/browser/supervised_user/supervised_user_resource_throttle.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_resource_throttle.h"
 
 #include "base/bind.h"
 #include "base/metrics/sparse_histogram.h"
 #include "chrome/browser/supervised_user/supervised_user_interstitial.h"
 #include "chrome/browser/supervised_user/supervised_user_navigation_observer.h"
@@ skipping 31 matching lines @@
 
 static_assert(kHistogramPageTransitionMaxKnownValue <
                   kHistogramPageTransitionFallbackValue,
               "HistogramPageTransition MaxKnownValue must be < FallbackValue");
 static_assert(FILTERING_BEHAVIOR_MAX * kHistogramFilteringBehaviorSpacing +
                   kHistogramPageTransitionFallbackValue < kHistogramMax,
               "Invalid HistogramMax value");
 
 int GetHistogramValueForFilteringBehavior(
     SupervisedUserURLFilter::FilteringBehavior behavior,
-    SupervisedUserURLFilter::FilteringBehaviorReason reason,
+    supervised_user_error_page::FilteringBehaviorReason reason,
     bool uncertain) {
   switch (behavior) {
     case SupervisedUserURLFilter::ALLOW:
     case SupervisedUserURLFilter::WARN:
-      if (reason == SupervisedUserURLFilter::WHITELIST)
+      if (reason == supervised_user_error_page::WHITELIST)
         return FILTERING_BEHAVIOR_ALLOW_WHITELIST;
       return uncertain ? FILTERING_BEHAVIOR_ALLOW_UNCERTAIN
                        : FILTERING_BEHAVIOR_ALLOW;
     case SupervisedUserURLFilter::BLOCK:
       switch (reason) {
-        case SupervisedUserURLFilter::BLACKLIST:
+        case supervised_user_error_page::BLACKLIST:
           return FILTERING_BEHAVIOR_BLOCK_BLACKLIST;
-        case SupervisedUserURLFilter::ASYNC_CHECKER:
+        case supervised_user_error_page::ASYNC_CHECKER:
           return FILTERING_BEHAVIOR_BLOCK_SAFESITES;
-        case SupervisedUserURLFilter::WHITELIST:
+        case supervised_user_error_page::WHITELIST:
           NOTREACHED();
           break;
-        case SupervisedUserURLFilter::MANUAL:
+        case supervised_user_error_page::MANUAL:
           return FILTERING_BEHAVIOR_BLOCK_MANUAL;
-        case SupervisedUserURLFilter::DEFAULT:
+        case supervised_user_error_page::DEFAULT:
           return FILTERING_BEHAVIOR_BLOCK_DEFAULT;
       }
     case SupervisedUserURLFilter::INVALID:
       NOTREACHED();
   }
   return 0;
 }
 
 int GetHistogramValueForTransitionType(ui::PageTransition transition_type) {
   int value =
       static_cast<int>(ui::PageTransitionStripQualifier(transition_type));
   if (0 <= value && value <= kHistogramPageTransitionMaxKnownValue)
     return value;
   NOTREACHED();
   return kHistogramPageTransitionFallbackValue;
 }
 
 void RecordFilterResultEvent(
     bool safesites_histogram,
     SupervisedUserURLFilter::FilteringBehavior behavior,
-    SupervisedUserURLFilter::FilteringBehaviorReason reason,
+    supervised_user_error_page::FilteringBehaviorReason reason,
     bool uncertain,
     ui::PageTransition transition_type) {
   int value =
       GetHistogramValueForFilteringBehavior(behavior, reason, uncertain) *
           kHistogramFilteringBehaviorSpacing +
       GetHistogramValueForTransitionType(transition_type);
   DCHECK_LT(value, kHistogramMax);
   // Note: We can't pass in the histogram name as a parameter to this function
   // because of how the macro works (look up the histogram on the first
   // invocation and cache it in a static variable).
@@ skipping 34 matching lines @@
   DCHECK_EQ(got_result, behavior_ != SupervisedUserURLFilter::INVALID);
   // If we got a "not blocked" result synchronously, don't defer.
   *defer = deferred_ = !got_result ||
                        (behavior_ == SupervisedUserURLFilter::BLOCK);
   if (got_result)
     behavior_ = SupervisedUserURLFilter::INVALID;
 }
 
 void SupervisedUserResourceThrottle::ShowInterstitial(
     const GURL& url,
-    SupervisedUserURLFilter::FilteringBehaviorReason reason) {
+    supervised_user_error_page::FilteringBehaviorReason reason) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &SupervisedUserNavigationObserver::OnRequestBlocked,
           info->GetWebContentsGetterForRequest(), url, reason,
           base::Bind(&SupervisedUserResourceThrottle::OnInterstitialResult,
                      weak_ptr_factory_.GetWeakPtr())));
 }
 
 void SupervisedUserResourceThrottle::WillStartRequest(bool* defer) {
   ShowInterstitialIfNeeded(false, request_->url(), defer);
 }
 
 void SupervisedUserResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   ShowInterstitialIfNeeded(true, redirect_info.new_url, defer);
 }
 
 const char* SupervisedUserResourceThrottle::GetNameForLogging() const {
   return "SupervisedUserResourceThrottle";
 }
 
 void SupervisedUserResourceThrottle::OnCheckDone(
     const GURL& url,
     SupervisedUserURLFilter::FilteringBehavior behavior,
-    SupervisedUserURLFilter::FilteringBehaviorReason reason,
+    supervised_user_error_page::FilteringBehaviorReason reason,
     bool uncertain) {
   DCHECK_EQ(SupervisedUserURLFilter::INVALID, behavior_);
   // If we got a result synchronously, pass it back to ShowInterstitialIfNeeded.
   if (!deferred_)
     behavior_ = behavior;
 
   ui::PageTransition transition =
       content::ResourceRequestInfo::ForRequest(request_)->GetPageTransition();
 
   RecordFilterResultEvent(false, behavior, reason, uncertain, transition);
 
   // If both the static blacklist and the async checker are enabled, also record
   // SafeSites-only UMA events.
   if (url_filter_->HasBlacklist() && url_filter_->HasAsyncURLChecker() &&
-      (reason == SupervisedUserURLFilter::ASYNC_CHECKER ||
-       reason == SupervisedUserURLFilter::BLACKLIST)) {
+      (reason == supervised_user_error_page::ASYNC_CHECKER ||
+       reason == supervised_user_error_page::BLACKLIST)) {
     RecordFilterResultEvent(true, behavior, reason, uncertain, transition);
   }
 
   if (behavior == SupervisedUserURLFilter::BLOCK)
     ShowInterstitial(url, reason);
   else if (deferred_)
     controller()->Resume();
 }
 
 void SupervisedUserResourceThrottle::OnInterstitialResult(
     bool continue_request) {
   if (continue_request)
     controller()->Resume();
   else
     controller()->Cancel();
 }