[ABANDONED] [WIP] Refactor SafeBrowsingResourceThrottle in preparation for WebSocket

chrome/browser/loader/safe_browsing_resource_throttle.cc

Index: chrome/browser/loader/safe_browsing_resource_throttle.cc
diff --git a/chrome/browser/loader/safe_browsing_resource_throttle.cc b/chrome/browser/loader/safe_browsing_resource_throttle.cc
index 440be9d1a050cd6095c60afb225518150a1d04e5..6f73f18f31e526db3b2c9f6bed36d760ee0e85c3 100644
--- a/chrome/browser/loader/safe_browsing_resource_throttle.cc
+++ b/chrome/browser/loader/safe_browsing_resource_throttle.cc
@@ -6,17 +6,17 @@
 
 #include <iterator>
 #include <utility>
+#include <vector>
 
+#include "base/bind.h"
 #include "base/logging.h"
-#include "base/trace_event/trace_event.h"
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/safe_browsing/ui_manager.h"
 #include "components/safe_browsing/base_ui_manager.h"
-#include "components/safe_browsing_db/util.h"
-#include "components/safe_browsing_db/v4_feature_list.h"
-#include "components/safe_browsing_db/v4_local_database_manager.h"
+#include "components/safe_browsing/resource_throttle.h"
 #include "components/security_interstitials/content/unsafe_resource.h"
-#include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
@@ -40,56 +40,10 @@ void DestroyPrerenderContents(
   }
 }
 
-}  // namespace
-
-// static
-SafeBrowsingResourceThrottle* SafeBrowsingResourceThrottle::MaybeCreate(
-    net::URLRequest* request,
-    content::ResourceType resource_type,
-    safe_browsing::SafeBrowsingService* sb_service) {
-  if (sb_service->database_manager()->IsSupported()) {
-    return new SafeBrowsingResourceThrottle(request, resource_type, sb_service);
-  }
-  return nullptr;
-}
-
-SafeBrowsingResourceThrottle::SafeBrowsingResourceThrottle(
-    const net::URLRequest* request,
-    content::ResourceType resource_type,
-    safe_browsing::SafeBrowsingService* sb_service)
-    : safe_browsing::BaseResourceThrottle(request,
-                                          resource_type,
-                                          sb_service->database_manager(),
-                                          sb_service->ui_manager()) {}
-
-SafeBrowsingResourceThrottle::~SafeBrowsingResourceThrottle() {}
-
-const char* SafeBrowsingResourceThrottle::GetNameForLogging() const {
-  return "SafeBrowsingResourceThrottle";
-}
-
-void SafeBrowsingResourceThrottle::MaybeDestroyPrerenderContents(
-    const content::ResourceRequestInfo* info) {
-  // Destroy the prefetch with FINAL_STATUS_SAFEBROSWING.
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&DestroyPrerenderContents,
-                     info->GetWebContentsGetterForRequest()));
-}
-
-void SafeBrowsingResourceThrottle::StartDisplayingBlockingPageHelper(
-    security_interstitials::UnsafeResource resource) {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&SafeBrowsingResourceThrottle::StartDisplayingBlockingPage,
-                     AsWeakPtr(), ui_manager(), resource));
-}
-
-// Static
-void SafeBrowsingResourceThrottle::StartDisplayingBlockingPage(
-    const base::WeakPtr<safe_browsing::BaseResourceThrottle>& throttle,
+void StartDisplayingBlockingPageOnUIThread(
     scoped_refptr<BaseUIManager> ui_manager,
-    const security_interstitials::UnsafeResource& resource) {
+    const security_interstitials::UnsafeResource& resource,
+    base::OnceClosure cancel_on_io_thread) {
   content::WebContents* web_contents = resource.web_contents_getter.Run();
   if (web_contents) {
     prerender::PrerenderContents* prerender_contents =
@@ -103,7 +57,51 @@ void SafeBrowsingResourceThrottle::StartDisplayingBlockingPage(
   }
 
   // Tab is gone or it's being prerendered.
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&SafeBrowsingResourceThrottle::Cancel, throttle));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   std::move(cancel_on_io_thread));
+}
+
+class SafeBrowsingResourceThrottleDelegate final
+    : public safe_browsing::ResourceThrottle::Delegate {
+ public:
+  SafeBrowsingResourceThrottleDelegate() {}
+  ~SafeBrowsingResourceThrottleDelegate() override {}
+
+  void MaybeDestroyPrerenderContents(
+      const WebContentsGetter& web_contents_getter) final {
+    // Destroy the prefetch with FINAL_STATUS_SAFEBROWSING.
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&DestroyPrerenderContents, web_contents_getter));
+  }
+
+  void StartDisplayingBlockingPage(
+      const security_interstitials::UnsafeResource& resource,
+      scoped_refptr<BaseUIManager> ui_manager,
+      base::OnceClosure cancel_on_io_thread) final {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&StartDisplayingBlockingPageOnUIThread,
+                       std::move(ui_manager), resource,
+                       std::move(cancel_on_io_thread)));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingResourceThrottleDelegate);
+};
+
+}  // namespace
+
+std::unique_ptr<content::ResourceThrottle>
+MaybeCreateSafeBrowsingResourceThrottle(
+    net::URLRequest* request,
+    content::ResourceType resource_type,
+    safe_browsing::SafeBrowsingService* sb_service) {
+  if (!sb_service->database_manager()->IsSupported())
+    return nullptr;
+  return base::MakeUnique<safe_browsing::ResourceThrottle>(
+      request, resource_type, sb_service->database_manager(),
+      sb_service->ui_manager(),
+      base::MakeUnique<SafeBrowsingResourceThrottleDelegate>());
+  return nullptr;
 }