Don't trigger Phishguard pings if we cannot compute URL reputation.

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"
 #include "base/feature_list.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/values.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/safe_browsing/csd.pb.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/protobuf/src/google/protobuf/repeated_field.h"
 
+namespace content {
+class WebContents;
+}
+
 namespace history {
 class HistoryService;
 }
 
 class GURL;
 class HostContentSettingsMap;
 
 namespace safe_browsing {
 
 class SafeBrowsingDatabaseManager;
@@ skipping 20 matching lines @@
     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;
 
@@ skipping 13 matching lines @@
   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(const GURL& main_frame_url,
+  void StartRequest(content::WebContents* web_contents,
+                    const GURL& main_frame_url,
                     const GURL& password_form_action,
                     const GURL& password_form_frame_url,
                     const std::string& saved_domain,
                     LoginReputationClientRequest::TriggerType type);
 
   virtual void MaybeStartPasswordFieldOnFocusRequest(
+      content::WebContents* web_contents,
       const GURL& main_frame_url,
       const GURL& password_form_action,
       const GURL& password_form_frame_url);
 
   virtual void MaybeStartProtectedPasswordEntryRequest(
+      content::WebContents* web_contents,
       const GURL& main_frame_url,
       const std::string& saved_domain);
 
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager();
 
+  // Safe Browsing backend cannot get a reliable reputation of a URL if
+  // (1) URL is not valid
+  // (2) URL doesn't have http or https scheme
+  // (3) It maps to a local host.
+  // (4) Its hostname is an IP Address in an IANA-reserved range.
+  // (5) Its hostname is a not-yet-assigned by ICANN gTLD.
+  // (6) Its hostname is a dotless domain.
+  static bool CanGetReputationOfURL(const GURL& url);
+
  protected:
   friend class PasswordProtectionRequest;
 
+  // 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,
       std::unique_ptr<LoginReputationClientResponse> response);
 
   // Cancels all requests in |requests_|, empties it, and releases references to
   // the requests.
   void CancelPendingRequests();
 
@@ skipping 77 matching lines @@
   static void GeneratePathVariantsWithoutQuery(const GURL& url,
                                                std::vector<std::string>* paths);
 
   static std::string GetCacheExpressionPath(
       const std::string& cache_expression);
 
   static std::unique_ptr<base::DictionaryValue> CreateDictionaryFromVerdict(
       const LoginReputationClientResponse* verdict,
       const base::Time& receive_time);
 
-  static void RecordPingingDisabledReason(const base::Feature& feature,
-                                          RequestOutcome reason);
+  static void RecordNoPingingReason(const base::Feature& feature,
+                                    RequestOutcome reason);
   // Number of verdict stored for this profile.
   int stored_verdict_count_;
 
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
 
   // The context we use to issue network requests. This request_context_getter
   // is obtained from SafeBrowsingService so that we can use the Safe Browsing
   // cookie store.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
@@ skipping 10 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_