Log real time lookup pings to chrome://safe-browsing

This is the follow up CL for crrev.com/c/1856804.

Bug: 1013370
Change-Id: I1170f8875a509e8231761981bb65c6f54bd53fe3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1856908
Commit-Queue: Xinghui Lu <xinghuilu@chromium.org>
Reviewed-by: Daniel Rubery <drubery@chromium.org>
Cr-Commit-Position: refs/heads/master@{#705771}

components/safe_browsing/browser/safe_browsing_url_checker_impl.cc

@@ -13,6 +13,7 @@
 #include "components/safe_browsing/realtime/policy_engine.h"
 #include "components/safe_browsing/realtime/url_lookup_service.h"
 #include "components/safe_browsing/web_ui/constants.h"
+#include "components/safe_browsing/web_ui/safe_browsing_ui.h"
 #include "components/security_interstitials/content/unsafe_resource.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
@@ -431,11 +432,32 @@ void SafeBrowsingUrlCheckerImpl::OnCheckUrlForHighConfidenceAllowlist(
     return;
   }
 
-  RTLookupResponseCallback result_callback =
+  RTLookupRequestCallback request_callback =
+      base::Bind(&SafeBrowsingUrlCheckerImpl::OnRTLookupRequest,
+                 weak_factory_.GetWeakPtr());
+
+  RTLookupResponseCallback response_callback =
       base::Bind(&SafeBrowsingUrlCheckerImpl::OnRTLookupResponse,
                  weak_factory_.GetWeakPtr());
+
   auto* rt_lookup_service = database_manager_->GetRealTimeUrlLookupService();
-  rt_lookup_service->StartLookup(url, std::move(result_callback));
+  rt_lookup_service->StartLookup(url, std::move(request_callback),
+                                 std::move(response_callback));
+}
+
+void SafeBrowsingUrlCheckerImpl::OnRTLookupRequest(
+    std::unique_ptr<RTLookupRequest> request) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  // The following is to log this RTLookupRequest on any open
+  // chrome://safe-browsing pages.
+  base::PostTaskAndReplyWithResult(
+      FROM_HERE, {content::BrowserThread::UI},
+      base::BindOnce(&WebUIInfoSingleton::AddToRTLookupPings,
+                     base::Unretained(WebUIInfoSingleton::GetInstance()),
+                     *request),
+      base::BindOnce(&SafeBrowsingUrlCheckerImpl::SetWebUIToken,
+                     weak_factory_.GetWeakPtr()));
 }
 
 void SafeBrowsingUrlCheckerImpl::OnRTLookupResponse(
@@ -443,6 +465,16 @@ void SafeBrowsingUrlCheckerImpl::OnRTLookupResponse(
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK_EQ(content::ResourceType::kMainFrame, resource_type_);
 
+  if (url_web_ui_token_ != -1) {
+    // The following is to log this RTLookupResponse on any open
+    // chrome://safe-browsing pages.
+    base::PostTask(
+        FROM_HERE, {content::BrowserThread::UI},
+        base::BindOnce(&WebUIInfoSingleton::AddToRTLookupResponses,
+                       base::Unretained(WebUIInfoSingleton::GetInstance()),
+                       url_web_ui_token_, *response));
+  }
+
   const GURL& url = urls_[next_index_].url;
   if (response && (response->threat_info_size() > 0) &&
       (response->threat_info(0).verdict_type() ==
@@ -454,8 +486,10 @@ void SafeBrowsingUrlCheckerImpl::OnRTLookupResponse(
   } else {
     OnUrlResult(url, SB_THREAT_TYPE_SAFE, ThreatMetadata());
   }
+}
 
-  // TODO(crbug.com/1013370): Log |response| to chrome://safe-browsing
+void SafeBrowsingUrlCheckerImpl::SetWebUIToken(int token) {
+  url_web_ui_token_ = token;
 }
 
 }  // namespace safe_browsing

components/safe_browsing/browser/safe_browsing_url_checker_impl.h

@@ -141,9 +141,14 @@ class SafeBrowsingUrlCheckerImpl : public mojom::SafeBrowsingUrlChecker,
   // case none of the members of this object should be touched again.
   bool RunNextCallback(bool proceed, bool showed_interstitial);
 
+  // Called when the |request| from the real-time lookup service is sent.
+  void OnRTLookupRequest(std::unique_ptr<RTLookupRequest> request);
+
   // Called when the |response| from the real-time lookup service is received.
   void OnRTLookupResponse(std::unique_ptr<RTLookupResponse> response);
 
+  void SetWebUIToken(int token);
+
   enum State {
     // Haven't started checking or checking is complete.
     STATE_NONE,
@@ -181,6 +186,10 @@ class SafeBrowsingUrlCheckerImpl : public mojom::SafeBrowsingUrlChecker,
   // than the size of |urls_|, the URL at |next_index_| is being processed.
   size_t next_index_ = 0;
 
+  // Token used for displaying url real time lookup pings. A single token is
+  // sufficient since real time check only happens on main frame url.
+  int url_web_ui_token_ = -1;
+
   State state_ = STATE_NONE;
 
   // Timer to abort the SafeBrowsing check if it takes too long.

components/safe_browsing/realtime/url_lookup_service.cc

@@ -35,8 +35,10 @@ RealTimeUrlLookupService::RealTimeUrlLookupService(
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory)
     : url_loader_factory_(url_loader_factory) {}
 
-void RealTimeUrlLookupService::StartLookup(const GURL& url,
-                                           RTLookupResponseCallback callback) {
+void RealTimeUrlLookupService::StartLookup(
+    const GURL& url,
+    RTLookupRequestCallback request_callback,
+    RTLookupResponseCallback response_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(url.is_valid());
 
@@ -98,7 +100,9 @@ void RealTimeUrlLookupService::StartLookup(const GURL& url,
       base::BindOnce(&RealTimeUrlLookupService::OnURLLoaderComplete,
                      GetWeakPtr(), loader));
 
-  pending_requests_[owned_loader.release()] = std::move(callback);
+  pending_requests_[owned_loader.release()] = std::move(response_callback);
+
+  std::move(request_callback).Run(std::make_unique<RTLookupRequest>(request));
 }
 
 RealTimeUrlLookupService::~RealTimeUrlLookupService() {

components/safe_browsing/realtime/url_lookup_service.h

@@ -23,6 +23,9 @@ class SharedURLLoaderFactory;
 
 namespace safe_browsing {
 
+using RTLookupRequestCallback =
+    base::OnceCallback<void(std::unique_ptr<RTLookupRequest>)>;
+
 using RTLookupResponseCallback =
     base::OnceCallback<void(std::unique_ptr<RTLookupResponse>)>;
 
@@ -42,9 +45,12 @@ class RealTimeUrlLookupService {
   // local hash-based method.
   bool IsInBackoffMode();
 
-  // Start the full URL lookup for |url| and call |callback| on the same thread
-  // when done.
-  void StartLookup(const GURL& url, RTLookupResponseCallback callback);
+  // Start the full URL lookup for |url|, call |request_callback| on the same
+  // thread when request is sent, call |response_callback| on the same thread
+  // when response is received.
+  void StartLookup(const GURL& url,
+                   RTLookupRequestCallback request_callback,
+                   RTLookupResponseCallback response_callback);
 
   // Returns the SBThreatType for a given
   // RTLookupResponse::ThreatInfo::ThreatType