Show interstitial on a password on focus ping with PHISHING verdict.

components/safe_browsing/password_protection/password_protection_service.h

 // Copyright 2017 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_PASSWORD_PROTECTION_PASSWORD_PROTECTION_SERVICE_H_
 #define COMPONENTS_SAFE_BROWSING_PASSWORD_PROTECTION_PASSWORD_PROTECTION_SERVICE_H_
 
 #include <set>
 
 #include "base/callback.h"
@@ skipping 21 matching lines @@
 class GURL;
 class HostContentSettingsMap;
 
 namespace safe_browsing {
 
 class SafeBrowsingDatabaseManager;
 class PasswordProtectionRequest;
 
 extern const base::Feature kPasswordFieldOnFocusPinging;
 extern const base::Feature kProtectedPasswordEntryPinging;
+extern const base::Feature kPasswordProtectionInterstitial;
 extern const char kPasswordOnFocusRequestOutcomeHistogramName[];
 extern const char kPasswordEntryRequestOutcomeHistogramName[];
 
 // Manage password protection pings and verdicts. There is one instance of this
 // class per profile. Therefore, every PasswordProtectionService instance is
 // associated with a unique HistoryService instance and a unique
 // HostContentSettingsMap instance.
 class PasswordProtectionService : public history::HistoryServiceObserver {
  public:
   // The outcome of the request. These values are used for UMA.
   // DO NOT CHANGE THE ORDERING OF THESE VALUES.
   enum RequestOutcome {
     UNKNOWN = 0,
     SUCCEEDED = 1,
     CANCELED = 2,
     TIMEDOUT = 3,
     MATCHED_WHITELIST = 4,
     RESPONSE_ALREADY_CACHED = 5,
     DEPRECATED_NO_EXTENDED_REPORTING = 6,
     DISABLED_DUE_TO_INCOGNITO = 7,
     REQUEST_MALFORMED = 8,
     FETCH_FAILED = 9,
     RESPONSE_MALFORMED = 10,
     SERVICE_DESTROYED = 11,
     DISABLED_DUE_TO_FEATURE_DISABLED = 12,
     DISABLED_DUE_TO_USER_POPULATION = 13,
     URL_NOT_VALID_FOR_REPUTATION_COMPUTING = 14,
     MAX_OUTCOME
   };
+
   PasswordProtectionService(
       const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       history::HistoryService* history_service,
       HostContentSettingsMap* host_content_settings_map);
 
   ~PasswordProtectionService() override;
 
   base::WeakPtr<PasswordProtectionService> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
   // Looks up |settings| to find the cached verdict response. If verdict is not
   // available or is expired, return VERDICT_TYPE_UNSPECIFIED. Can be called on
   // any thread.
   LoginReputationClientResponse::VerdictType GetCachedVerdict(
       const GURL& url,
       LoginReputationClientResponse* out_response);
 
   // Stores |verdict| in |settings| based on |url|, |verdict| and
   // |receive_time|.
-  void CacheVerdict(const GURL& url,
-                    LoginReputationClientResponse* verdict,
-                    const base::Time& receive_time);
+  virtual void CacheVerdict(const GURL& url,
+                            LoginReputationClientResponse* verdict,
+                            const base::Time& receive_time);
 
   // Removes all the expired verdicts from cache.
   void CleanUpExpiredVerdicts();
 
   // Creates an instance of PasswordProtectionRequest and call Start() on that
   // instance. This function also insert this request object in |requests_| for
   // record keeping.
   void StartRequest(content::WebContents* web_contents,
                     const GURL& main_frame_url,
                     const GURL& password_form_action,
@@ skipping 29 matching lines @@
   // Chrome can send password protection ping if it is allowed by Finch config
   // and if Safe Browsing can compute reputation of |main_frame_url| (e.g.
   // Safe Browsing is not able to compute reputation of a private IP or
   // a local host.)
   bool CanSendPing(const base::Feature& feature, const GURL& main_frame_url);
 
   // Called by a PasswordProtectionRequest instance when it finishes to remove
   // itself from |requests_|.
   virtual void RequestFinished(
       PasswordProtectionRequest* request,
+      bool already_cached,
       std::unique_ptr<LoginReputationClientResponse> response);
 
   // Cancels all requests in |requests_|, empties it, and releases references to
   // the requests.
   void CancelPendingRequests();
 
   // Gets the total number of verdict (no matter expired or not) we cached for
   // current active profile.
   virtual int GetStoredVerdictCount();
 
@@ skipping 20 matching lines @@
 
   virtual bool IsExtendedReporting() = 0;
 
   virtual bool IsIncognito() = 0;
 
   virtual bool IsPingingEnabled(const base::Feature& feature,
                                 RequestOutcome* reason) = 0;
 
   virtual bool IsHistorySyncEnabled() = 0;
 
+  virtual void ShowPhishingInterstitial(const GURL& phishing_url,
+                                        const std::string& token,
+                                        content::WebContents* web_contents) = 0;
+
   void CheckCsdWhitelistOnIOThread(const GURL& url, bool* check_result);
 
   HostContentSettingsMap* content_settings() const { return content_settings_; }
 
  private:
   friend class PasswordProtectionServiceTest;
   friend class TestPasswordProtectionService;
   FRIEND_TEST_ALL_PREFIXES(PasswordProtectionServiceTest,
                            TestParseInvalidVerdictEntry);
   FRIEND_TEST_ALL_PREFIXES(PasswordProtectionServiceTest,
@@ skipping 65 matching lines @@
   // we need CancelableTaskTracker to cancel tasks posted to IO thread.
   base::CancelableTaskTracker tracker_;
 
   base::WeakPtrFactory<PasswordProtectionService> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(PasswordProtectionService);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_PASSWORD_PROTECTION_PASSWORD_PROTECTION_SERVICE_H_