Move the supervised user error page to a component

chrome/browser/ui/webui/supervised_user_internals_message_handler.cc

 // Copyright 2015 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/ui/webui/supervised_user_internals_message_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/account_tracker_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
 #include "components/signin/core/browser/account_tracker_service.h"
+#include "components/supervised_user_error_page/supervised_user_error_page.h"
 #include "components/url_formatter/url_fixer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Creates a 'section' for display on about:supervised-user-internals,
 // consisting of a title and a list of fields. Returns a pointer to the new
@@ skipping 50 matching lines @@
 
 std::string FilteringBehaviorToString(
     SupervisedUserURLFilter::FilteringBehavior behavior, bool uncertain) {
   std::string result = FilteringBehaviorToString(behavior);
   if (uncertain)
     result += " (Uncertain)";
   return result;
 }
 
 std::string FilteringBehaviorReasonToString(
-    SupervisedUserURLFilter::FilteringBehaviorReason reason) {
+    supervised_user_error_page::FilteringBehaviorReason reason) {
   switch (reason) {
-    case SupervisedUserURLFilter::DEFAULT:
+    case supervised_user_error_page::DEFAULT:
       return "Default";
-    case SupervisedUserURLFilter::ASYNC_CHECKER:
+    case supervised_user_error_page::ASYNC_CHECKER:
       return "AsyncChecker";
-    case SupervisedUserURLFilter::BLACKLIST:
+    case supervised_user_error_page::BLACKLIST:
       return "Blacklist";
-    case SupervisedUserURLFilter::MANUAL:
+    case supervised_user_error_page::MANUAL:
       return "Manual";
-    case SupervisedUserURLFilter::WHITELIST:
+    case supervised_user_error_page::WHITELIST:
       return "Whitelist";
   }
   return "Unknown/invalid";
 }
 
 }  // namespace
 
 // Helper class that lives on the IO thread, listens to the
 // SupervisedUserURLFilter there, and posts results back to the UI thread.
 class SupervisedUserInternalsMessageHandler::IOThreadHelper
     : public base::RefCountedThreadSafe<IOThreadHelper,
                                         BrowserThread::DeleteOnIOThread>,
       public SupervisedUserURLFilter::Observer {
  public:
   using OnURLCheckedCallback =
       base::Callback<void(const GURL&,
                           SupervisedUserURLFilter::FilteringBehavior,
-                          SupervisedUserURLFilter::FilteringBehaviorReason,
+                          supervised_user_error_page::FilteringBehaviorReason,
                           bool uncertain)>;
 
   IOThreadHelper(scoped_refptr<const SupervisedUserURLFilter> filter,
                  const OnURLCheckedCallback& callback)
       : filter_(filter), callback_(callback) {
     BrowserThread::PostTask(BrowserThread::IO,
                             FROM_HERE,
                             base::Bind(&IOThreadHelper::InitOnIOThread, this));
   }
 
  private:
   friend class base::DeleteHelper<IOThreadHelper>;
   friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
   virtual ~IOThreadHelper() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     filter_->RemoveObserver(this);
   }
 
   // SupervisedUserURLFilter::Observer:
   void OnSiteListUpdated() override {}
   void OnURLChecked(const GURL& url,
                     SupervisedUserURLFilter::FilteringBehavior behavior,
-                    SupervisedUserURLFilter::FilteringBehaviorReason reason,
+                    supervised_user_error_page::FilteringBehaviorReason reason,
                     bool uncertain) override {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(callback_,
                                        url, behavior, reason, uncertain));
   }
 
   void InitOnIOThread() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     filter_->AddObserver(this);
@@ skipping 132 matching lines @@
 void SupervisedUserInternalsMessageHandler::SendSupervisedUserSettings(
     const base::DictionaryValue* settings) {
   web_ui()->CallJavascriptFunction(
       "chrome.supervised_user_internals.receiveUserSettings",
       *(settings ? settings : base::Value::CreateNullValue().get()));
 }
 
 void SupervisedUserInternalsMessageHandler::OnTryURLResult(
     const std::map<std::string, base::string16>& whitelists,
     SupervisedUserURLFilter::FilteringBehavior behavior,
-    SupervisedUserURLFilter::FilteringBehaviorReason reason,
+    supervised_user_error_page::FilteringBehaviorReason reason,
     bool uncertain) {
   std::vector<std::string> whitelists_list;
   for (const auto& whitelist : whitelists) {
     whitelists_list.push_back(
         base::StringPrintf("%s: %s", whitelist.first.c_str(),
                            base::UTF16ToUTF8(whitelist.second).c_str()));
   }
   std::string whitelists_str = base::JoinString(whitelists_list, "; ");
   base::DictionaryValue result;
   result.SetString("allowResult",
                    FilteringBehaviorToString(behavior, uncertain));
-  result.SetBoolean("manual", reason == SupervisedUserURLFilter::MANUAL &&
+  result.SetBoolean("manual", reason == supervised_user_error_page::MANUAL &&
                                   behavior == SupervisedUserURLFilter::ALLOW);
   result.SetString("whitelists", whitelists_str);
   web_ui()->CallJavascriptFunction(
       "chrome.supervised_user_internals.receiveTryURLResult", result);
 }
 
 void SupervisedUserInternalsMessageHandler::OnURLChecked(
     const GURL& url,
     SupervisedUserURLFilter::FilteringBehavior behavior,
-    SupervisedUserURLFilter::FilteringBehaviorReason reason,
+    supervised_user_error_page::FilteringBehaviorReason reason,
     bool uncertain) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::DictionaryValue result;
   result.SetString("url", url.possibly_invalid_spec());
   result.SetString("result", FilteringBehaviorToString(behavior, uncertain));
   result.SetString("reason", FilteringBehaviorReasonToString(reason));
   web_ui()->CallJavascriptFunction(
       "chrome.supervised_user_internals.receiveFilteringResult", result);
 }