Remove Dangerous indicator after going back from interstitial

chrome/browser/safe_browsing/ui_manager.h

 // Copyright (c) 2012 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.
 //
 // The Safe Browsing service is responsible for downloading anti-phishing and
 // anti-malware tables and checking urls against them.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_UI_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_UI_MANAGER_H_
 
@@ skipping 110 matching lines @@
   // 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
   // chain). Otherwise, |original_url| = |url|.
   virtual void DisplayBlockingPage(const UnsafeResource& resource);
 
   // A convenience wrapper method for IsUrlWhitelistedOrPendingForWebContents.
   bool IsWhitelisted(const UnsafeResource& resource);
 
-  // Checks if we already displayed an interstitial for that top-level
-  // site in a given WebContents. If |whitelist_only|, it returns true only if
-  // the user chose to ignore the interstitial; otherwise it returns true as
-  // long as the user has seen an interstitial (regardless of response).
-  // Called on the UI thread.
+  // Checks if we already displayed or are displaying an interstitial
+  // for the top-level site |url| in a given WebContents. If
+  // |whitelist_only|, it returns true only if the user chose to ignore
+  // the interstitial. Otherwise, it returns true if an interstitial for
+  // |url| is already displaying *or* if the user has seen an
+  // interstitial for |url| before in this WebContents and proceeded
+  // through it. Called on the UI thread.
   bool IsUrlWhitelistedOrPendingForWebContents(
       const GURL& url,
       bool is_subresource,
       content::NavigationEntry* entry,
       content::WebContents* web_contents,
       bool whitelist_only);
 
-  // The blocking page on the UI thread has completed.
+  // The blocking page for |web_contents| on the UI thread has

[Nathan Parker, 2016/10/31 23:54:38]

Excellent comments, thank you.

+  // completed, with |proceed| set to true if the user has chosen to
+  // proceed through the blocking page and false
+  // 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.
   void OnBlockingPageDone(const std::vector<UnsafeResource>& resources,
-                          bool proceed);
+                          bool proceed,
+                          content::WebContents* web_contents,
+                          const GURL& main_frame_url);
 
   // Log the user perceived delay caused by SafeBrowsing. This delay is the time
   // delta starting from when we would have started reading data from the
   // network, and ending when the SafeBrowsing check completes indicating that
   // the current page is 'safe'.
   void LogPauseDelay(base::TimeDelta time);
 
   // Called on the IO thread by the ThreatDetails with the serialized
   // protocol buffer, so the service can send it over.
   virtual void SendSerializedThreatDetails(const std::string& serialized);
@@ skipping 11 matching lines @@
                                      const base::Closure& callback);
 
   // Report permission action to SafeBrowsing servers. Can only be called on UI
   // thread.
   void ReportPermissionAction(const PermissionReportInfo& report_info);
 
   // Add and remove observers.  These methods must be invoked on the UI thread.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* remove);
 
+  // Creates the whitelist URL set for tests that create a blocking page
+  // themselves and then simulate OnBlockingPageDone(). OnBlockingPageDone()
+  // expects the whitelist to exist, but the tests don't necessarily call
+  // DisplayBlockingPage(), which creates it.
+  static void CreateWhitelistForTesting(content::WebContents* web_contents);
+
  protected:
   virtual ~SafeBrowsingUIManager();
 
  private:
   friend class base::RefCountedThreadSafe<SafeBrowsingUIManager>;
   friend class SafeBrowsingUIManagerTest;
   friend class TestSafeBrowsingUIManager;
 
   // Call protocol manager on IO thread to report hits of unsafe contents.
   void ReportSafeBrowsingHitOnIOThread(
       const safe_browsing::HitReport& hit_report);
 
   // Sends an invalid certificate chain report over the network.
   void ReportInvalidCertificateChainOnIOThread(
       const std::string& serialized_report);
 
   // Report permission action to SafeBrowsing servers.
   void ReportPermissionActionOnIOThread(
       const PermissionReportInfo& report_info);
 
-  // Updates the whitelist URL set.  Called on the UI thread.
-  void AddToWhitelistUrlSet(const UnsafeResource& resource, bool is_pending);
+  // Updates the whitelist URL set for |web_contents|. Called on the UI thread.
+  void AddToWhitelistUrlSet(const GURL& whitelist_url,

[estark, 2016/10/28 18:01:33]

I changed this from taking a |resource| to taking a |whitelist_url| to be
consistent with RemoveFromPendingWhitelistUrlSet below.

+                            content::WebContents* web_contents,
+                            bool is_pending);
+
+  // 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);
+
+  static GURL GetMainFrameWhitelistUrlForResourceForTesting(
+      const safe_browsing::SafeBrowsingUIManager::UnsafeResource& resource);
 
   // Safebrowsing service.
   scoped_refptr<SafeBrowsingService> sb_service_;
 
   base::ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingUIManager);
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_UI_MANAGER_H_