Componentize SafeBrowsingBlockingPage for WebView use

components/safe_browsing/base_ui_manager.h

 // Copyright 2016 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.
 
 #ifndef COMPONENTS_SAFE_BROWSING_BASE_UI_MANAGER_H_
 #define COMPONENTS_SAFE_BROWSING_BASE_UI_MANAGER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/bind_helpers.h"
-#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/observer_list.h"
-#include "base/supports_user_data.h"
 #include "base/time/time.h"
 #include "components/security_interstitials/content/unsafe_resource.h"
 
 class GURL;
 
 namespace content {
 class NavigationEntry;
 class WebContents;
 }  // namespace content
 
+namespace history {
+class HistoryService;
+}  // namespace history
+
 namespace safe_browsing {
 
 // Construction needs to happen on the main thread.
-class BaseSafeBrowsingUIManager
-    : public base::RefCountedThreadSafe<BaseSafeBrowsingUIManager> {
+class BaseUIManager
+    : public base::RefCountedThreadSafe<BaseUIManager> {
  public:
   typedef security_interstitials::UnsafeResource UnsafeResource;
 
-  // Observer class can be used to get notified when a SafeBrowsing hit
-  // was found.
-  class Observer {
-   public:
-    // The |resource| was classified as unsafe by SafeBrowsing, and is
-    // not whitelisted.
-    // The |resource| must not be accessed after OnSafeBrowsingHit returns.
-    // This method will be called on the UI thread.
-    virtual void OnSafeBrowsingHit(const UnsafeResource& resource) = 0;
-
-   protected:
-    Observer() {}
-    virtual ~Observer() {}
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Observer);
-  };
-
-  BaseSafeBrowsingUIManager();
+  BaseUIManager();
 
   // Called to stop or shutdown operations on the io_thread. This may be called
   // multiple times during the life of the UIManager. Should be called
   // on IO thread. If shutdown is true, the manager is disabled permanently.
   virtual void StopOnIOThread(bool shutdown);
 
   // Called on the UI thread to display an interstitial page.
   // |url| is the url of the resource that matches a safe browsing list.
   // If the request contained a chain of redirects, |url| is the last url
   // in the chain, and |original_url| is the first one (the root of the
@@ skipping 45 matching lines @@
   // otherwise. |web_contents| is the WebContents that was displaying
   // the blocking page. |main_frame_url| is the top-level URL on which
   // the blocking page was displayed. If |proceed| is true,
   // |main_frame_url| is whitelisted so that the user will not see
   // another warning for that URL in this WebContents.
   virtual void OnBlockingPageDone(const std::vector<UnsafeResource>& resources,
                                   bool proceed,
                                   content::WebContents* web_contents,
                                   const GURL& main_frame_url);
 
-  // Add and remove observers.  These methods must be invoked on the UI thread.
-  virtual void AddObserver(Observer* observer);
-  virtual void RemoveObserver(Observer* remove);
+  virtual const std::string app_locale() const;
+
+  virtual history::HistoryService* history_service(
+      content::WebContents* web_contents);
+
+  // The default safe page when there is no entry in the history to go back to.
+  // e.g. about::blank page, or chrome's new tab page.
+  virtual const GURL default_safe_page() const;
 
  protected:
-  virtual ~BaseSafeBrowsingUIManager();
+  virtual ~BaseUIManager();
 
   // Updates the whitelist URL set for |web_contents|. Called on the UI thread.
   void AddToWhitelistUrlSet(const GURL& whitelist_url,
                             content::WebContents* web_contents,
                             bool is_pending,
                             SBThreatType threat_type);
 
   // Call protocol manager on IO thread to report hits of unsafe contents.
   virtual void ReportSafeBrowsingHitOnIOThread(
       const safe_browsing::HitReport& hit_report);
 
   // Removes |whitelist_url| from the pending whitelist for
   // |web_contents|. Called on the UI thread.
   void RemoveFromPendingWhitelistUrlSet(const GURL& whitelist_url,
                                         content::WebContents* web_contents);
 
   // Ensures that |web_contents| has its whitelist set in its userdata
   static void EnsureWhitelistCreated(content::WebContents* web_contents);
 
-  base::ObserverList<Observer> observer_list_;
+  // Returns the URL that should be used in a WhitelistUrlSet for the given
+  // |resource|.
+  static GURL GetMainFrameWhitelistUrlForResource(
+      const security_interstitials::UnsafeResource& resource);
 
  private:
-  friend class base::RefCountedThreadSafe<BaseSafeBrowsingUIManager>;
+  friend class base::RefCountedThreadSafe<BaseUIManager>;
 
-  DISALLOW_COPY_AND_ASSIGN(BaseSafeBrowsingUIManager);
+  DISALLOW_COPY_AND_ASSIGN(BaseUIManager);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_BASE_UI_MANAGER_H_