Convert SupervisedUserResourceThrottle to a NavigationThrottle.

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/child_accounts/child_account_service.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 "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #include "chrome/common/channel_info.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 {
@@ skipping 74 matching lines @@
       return "Whitelist";
     case supervised_user_error_page::NOT_SIGNED_IN:
       // Should never happen, only used for requests from WebView
       NOTREACHED();
   }
   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,
-                          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,
-                    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);
-  }
-
-  scoped_refptr<const SupervisedUserURLFilter> filter_;
-  OnURLCheckedCallback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(IOThreadHelper);
-};
-
 SupervisedUserInternalsMessageHandler::SupervisedUserInternalsMessageHandler()
-    : weak_factory_(this) {
-}
+    : scoped_observer_(this), weak_factory_(this) {}
 
 SupervisedUserInternalsMessageHandler::
     ~SupervisedUserInternalsMessageHandler() {
 }
 
 void SupervisedUserInternalsMessageHandler::RegisterMessages() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   web_ui()->RegisterMessageCallback("registerForEvents",
       base::Bind(&SupervisedUserInternalsMessageHandler::
@@ skipping 16 matching lines @@
 SupervisedUserService*
 SupervisedUserInternalsMessageHandler::GetSupervisedUserService() {
   Profile* profile = Profile::FromWebUI(web_ui());
   return SupervisedUserServiceFactory::GetForProfile(
       profile->GetOriginalProfile());
 }
 
 void SupervisedUserInternalsMessageHandler::HandleRegisterForEvents(
     const base::ListValue* args) {
   DCHECK(args->empty());
+  if (scoped_observer_.IsObservingSources())
+    return;
 
-  if (!io_thread_helper_.get()) {
-    io_thread_helper_ = new IOThreadHelper(
-        GetSupervisedUserService()->GetURLFilterForIOThread(),
-        base::Bind(&SupervisedUserInternalsMessageHandler::OnURLChecked,
-                   weak_factory_.GetWeakPtr()));
-  }
+  scoped_observer_.Add(GetSupervisedUserService()->GetURLFilter());
 }
 
 void SupervisedUserInternalsMessageHandler::HandleGetBasicInfo(
     const base::ListValue* args) {
   SendBasicInfo();
 }
 
 void SupervisedUserInternalsMessageHandler::HandleTryURL(
     const base::ListValue* args) {
   DCHECK_EQ(1u, args->GetSize());
   std::string url_str;
   if (!args->GetString(0, &url_str))
     return;
 
   GURL url = url_formatter::FixupURL(url_str, std::string());
   if (!url.is_valid())
     return;
 
-  SupervisedUserURLFilter* filter =
-      GetSupervisedUserService()->GetURLFilterForUIThread();
+  SupervisedUserURLFilter* filter = GetSupervisedUserService()->GetURLFilter();
   std::map<std::string, base::string16> whitelists =
       filter->GetMatchingWhitelistTitles(url);
   filter->GetFilteringBehaviorForURLWithAsyncChecks(
       url, base::Bind(&SupervisedUserInternalsMessageHandler::OnTryURLResult,
                       weak_factory_.GetWeakPtr(), whitelists));
 }
 
 void SupervisedUserInternalsMessageHandler::SendBasicInfo() {
   std::unique_ptr<base::ListValue> section_list(new base::ListValue);
 
   base::ListValue* section_general = AddSection(section_list.get(), "General");
   AddSectionEntry(section_general, "Chrome version",
                   chrome::GetVersionString());
   AddSectionEntry(section_general, "Child detection enabled",
                   ChildAccountService::IsChildAccountDetectionEnabled());
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
   base::ListValue* section_profile = AddSection(section_list.get(), "Profile");
   AddSectionEntry(section_profile, "Account", profile->GetProfileUserName());
   AddSectionEntry(section_profile, "Legacy Supervised",
                   profile->IsLegacySupervised());
   AddSectionEntry(section_profile, "Child", profile->IsChild());
 
-  SupervisedUserURLFilter* filter =
-      GetSupervisedUserService()->GetURLFilterForUIThread();
+  SupervisedUserURLFilter* filter = GetSupervisedUserService()->GetURLFilter();
 
   base::ListValue* section_filter = AddSection(section_list.get(), "Filter");
   AddSectionEntry(section_filter, "Blacklist active", filter->HasBlacklist());
   AddSectionEntry(section_filter, "Online checks active",
                   filter->HasAsyncURLChecker());
   AddSectionEntry(section_filter, "Default behavior",
                   FilteringBehaviorToString(
                       filter->GetDefaultFilteringBehavior()));
 
   AccountTrackerService* account_tracker =
@@ skipping 49 matching lines @@
   base::DictionaryValue result;
   result.SetString("allowResult",
                    FilteringBehaviorToString(behavior, uncertain));
   result.SetBoolean("manual", reason == supervised_user_error_page::MANUAL &&
                                   behavior == SupervisedUserURLFilter::ALLOW);
   result.SetString("whitelists", whitelists_str);
   web_ui()->CallJavascriptFunctionUnsafe(
       "chrome.supervised_user_internals.receiveTryURLResult", result);
 }
 
+void SupervisedUserInternalsMessageHandler::OnSiteListUpdated() {}
+
 void SupervisedUserInternalsMessageHandler::OnURLChecked(
     const GURL& url,
     SupervisedUserURLFilter::FilteringBehavior behavior,
     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()->CallJavascriptFunctionUnsafe(
       "chrome.supervised_user_internals.receiveFilteringResult", result);
 }