Adding NetLog support to SafeBrowsingPingManager.

chrome/browser/safe_browsing/ping_manager.cc

 // 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.
 
 #include "chrome/browser/safe_browsing/ping_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/values.h"
 #include "chrome/browser/safe_browsing/permission_reporter.h"
 #include "components/certificate_reporting/error_reporter.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
+#include "net/log/net_log_source_type.h"
 #include "net/ssl/ssl_info.h"
 #include "net/url_request/report_sender.h"
 #include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace {
 // URL to upload invalid certificate chain reports. An HTTP URL is
 // used because a client seeing an invalid cert might not be able to
 // make an HTTPS connection to report it.
 const char kExtendedReportingUploadUrlInsecure[] =
     "http://safebrowsing.googleusercontent.com/safebrowsing/clientreport/"
     "chrome-certs";
+
+// Return a dictionary with "url"=|url-spec| and "data"=|payload| for

[sadrul, 2016/09/23 16:38:21]

*Returns

[lpz, 2016/09/23 18:11:58]

Done.

+// netlogging the start phase of a ping.
+std::unique_ptr<base::Value> NetLogPingStartCallback(
+    const net::NetLogWithSource& net_log,
+    const GURL& url,
+    const std::string& payload,
+    net::NetLogCaptureMode) {
+  std::unique_ptr<base::DictionaryValue> event_params(
+      new base::DictionaryValue());
+  event_params->SetString("url", url.spec());
+  event_params->SetString("payload", payload);
+  net_log.source().AddToEventParameters(event_params.get());
+  return std::move(event_params);
+}
+
+// Return a dictionary with "url"=|url-spec|, "status"=|status| and

[sadrul, 2016/09/23 16:38:21]

ditto

[lpz, 2016/09/23 18:11:58]

Done.

+// "error"=|error| for netlogging the end phase of a ping.
+std::unique_ptr<base::Value> NetLogPingEndCallback(
+    const net::NetLogWithSource& net_log,
+    const GURL& url,
+    const net::URLRequestStatus& status,
+    net::NetLogCaptureMode) {
+  std::unique_ptr<base::DictionaryValue> event_params(
+      new base::DictionaryValue());
+  event_params->SetString("url", url.spec());
+  event_params->SetInteger("status", status.status());
+  event_params->SetInteger("error", status.error());
+  net_log.source().AddToEventParameters(event_params.get());
+  return std::move(event_params);
+}
+
 }  // namespace
 
 namespace safe_browsing {
 
 // SafeBrowsingPingManager implementation ----------------------------------
 
 // static
 std::unique_ptr<SafeBrowsingPingManager> SafeBrowsingPingManager::Create(
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config) {
@@ skipping 15 matching lines @@
     GURL certificate_upload_url;
     cookies_preference = net::ReportSender::DO_NOT_SEND_COOKIES;
     certificate_upload_url = GURL(kExtendedReportingUploadUrlInsecure);
 
     certificate_error_reporter_.reset(new certificate_reporting::ErrorReporter(
         request_context_getter->GetURLRequestContext(), certificate_upload_url,
         cookies_preference));
 
     permission_reporter_.reset(
         new PermissionReporter(request_context_getter->GetURLRequestContext()));
+
+    net_log_ = net::NetLogWithSource::Make(
+        request_context_getter->GetURLRequestContext()->net_log(),
+        net::NetLogSourceType::SAFE_BROWSING);
   }
 
   version_ = SafeBrowsingProtocolManagerHelper::Version();
 }
 
 SafeBrowsingPingManager::~SafeBrowsingPingManager() {
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // All SafeBrowsing request responses are handled here.
 void SafeBrowsingPingManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   auto it =
       std::find_if(safebrowsing_reports_.begin(), safebrowsing_reports_.end(),
                    [source](const std::unique_ptr<net::URLFetcher>& ptr) {
                      return ptr.get() == source;
                    });
   DCHECK(it != safebrowsing_reports_.end());
   safebrowsing_reports_.erase(it);
+
+  net_log_.EndEvent(
+      net::NetLogEventType::SAFE_BROWSING_PING,
+      base::Bind(&NetLogPingEndCallback, net_log_, source->GetURL(),
+                 source->GetStatus()));
 }
 
 // Sends a SafeBrowsing "hit" report.
 void SafeBrowsingPingManager::ReportSafeBrowsingHit(
     const safe_browsing::HitReport& hit_report) {
   GURL report_url = SafeBrowsingHitUrl(hit_report);
   std::unique_ptr<net::URLFetcher> report_ptr = net::URLFetcher::Create(
       report_url, hit_report.post_data.empty() ? net::URLFetcher::GET
                                                : net::URLFetcher::POST,
       this);
   net::URLFetcher* report = report_ptr.get();
   report_ptr->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   report_ptr->SetRequestContext(request_context_getter_.get());
   if (!hit_report.post_data.empty())
     report_ptr->SetUploadData("text/plain", hit_report.post_data);
+
+  net_log_.BeginEvent(
+      net::NetLogEventType::SAFE_BROWSING_PING,
+      base::Bind(&NetLogPingStartCallback, net_log_, report_ptr->GetURL(),
+                 hit_report.post_data));
+
+  report->Start();
   safebrowsing_reports_.insert(std::move(report_ptr));
-  report->Start();
 }
 
 // Sends threat details for users who opt-in.
 void SafeBrowsingPingManager::ReportThreatDetails(const std::string& report) {
   GURL report_url = ThreatDetailsUrl();
   std::unique_ptr<net::URLFetcher> fetcher =
       net::URLFetcher::Create(report_url, net::URLFetcher::POST, this);
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("application/octet-stream", report);
   // Don't try too hard to send reports on failures.
   fetcher->SetAutomaticallyRetryOn5xx(false);
+
+  net_log_.BeginEvent(
+      net::NetLogEventType::SAFE_BROWSING_PING,
+      base::Bind(&NetLogPingStartCallback, net_log_, fetcher->GetURL(),
+                 report));

[sadrul, 2016/09/23 16:38:21]

Are these callbacks always expected to run synchronously? (because if not, then
there may be some lifetime issues here)

[lpz, 2016/09/23 18:11:58]

Yes the docs suggest that this is guaranteed - the callback will finish before
BeginEvent/EndEvent returns
(http://dev.chromium.org/developers/design-documents/network-stack/netlog, see
"How custom parameters are attached to events").

+
   fetcher->Start();
   safebrowsing_reports_.insert(std::move(fetcher));
+
 }
 
 void SafeBrowsingPingManager::ReportInvalidCertificateChain(
     const std::string& serialized_report) {
   DCHECK(certificate_error_reporter_);
   certificate_error_reporter_->SendExtendedReportingReport(serialized_report);
 }
 
 void SafeBrowsingPingManager::SetCertificateErrorReporterForTesting(
     std::unique_ptr<certificate_reporting::ErrorReporter>
@@ skipping 96 matching lines @@
           version_.c_str());
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return GURL(url);
 }
 
 }  // namespace safe_browsing