Componentize ping_manager

components/safe_browsing/base_ping_manager.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 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.
 
-#include "chrome/browser/safe_browsing/ping_manager.h"
+#include "components/safe_browsing/base_ping_manager.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #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/notification_image_reporter.h"
-#include "chrome/browser/safe_browsing/permission_reporter.h"
 #include "components/data_use_measurement/core/data_use_user_data.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/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 "third_party/skia/include/core/SkBitmap.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace {
 // Returns a dictionary with "url"=|url-spec| and "data"=|payload| for
 // netlogging the start phase of a ping.
 std::unique_ptr<base::Value> NetLogPingStartCallback(
     const net::NetLogWithSource& net_log,
     const GURL& url,
@@ skipping 21 matching lines @@
   return std::move(event_params);
 }
 
 }  // namespace
 
 namespace safe_browsing {
 
 // SafeBrowsingPingManager implementation ----------------------------------
 
 // static
-std::unique_ptr<SafeBrowsingPingManager> SafeBrowsingPingManager::Create(
+std::unique_ptr<BasePingManager> BasePingManager::Create(
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return base::WrapUnique(
-      new SafeBrowsingPingManager(request_context_getter, config));
+  return base::WrapUnique(new BasePingManager(request_context_getter, config));
 }
 
-SafeBrowsingPingManager::SafeBrowsingPingManager(
+BasePingManager::BasePingManager(
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config)
     : client_name_(config.client_name),
       request_context_getter_(request_context_getter),
       url_prefix_(config.url_prefix) {
   DCHECK(!url_prefix_.empty());
 
   if (request_context_getter) {
-    permission_reporter_ = base::MakeUnique<PermissionReporter>(
-        request_context_getter->GetURLRequestContext());
-    notification_image_reporter_ = base::MakeUnique<NotificationImageReporter>(
-        request_context_getter->GetURLRequestContext());
-
     net_log_ = net::NetLogWithSource::Make(
         request_context_getter->GetURLRequestContext()->net_log(),
         net::NetLogSourceType::SAFE_BROWSING);
   }
 
-  version_ = SafeBrowsingProtocolManagerHelper::Version();
+  version_ = ProtocolManagerHelper::Version();
 }
 
-SafeBrowsingPingManager::~SafeBrowsingPingManager() {
-}
+BasePingManager::~BasePingManager() {}
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // All SafeBrowsing request responses are handled here.
-void SafeBrowsingPingManager::OnURLFetchComplete(
-    const net::URLFetcher* source) {
+void BasePingManager::OnURLFetchComplete(const net::URLFetcher* source) {
   net_log_.EndEvent(
       net::NetLogEventType::SAFE_BROWSING_PING,
       base::Bind(&NetLogPingEndCallback, net_log_, source->GetStatus()));
   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);
 }
 
 // Sends a SafeBrowsing "hit" report.
-void SafeBrowsingPingManager::ReportSafeBrowsingHit(
+void BasePingManager::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,
+      report_url,
+      hit_report.post_data.empty() ? net::URLFetcher::GET
+                                   : net::URLFetcher::POST,
       this);
   net::URLFetcher* report = report_ptr.get();
   data_use_measurement::DataUseUserData::AttachToFetcher(
       report, data_use_measurement::DataUseUserData::SAFE_BROWSING);
   report_ptr->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   report_ptr->SetRequestContext(request_context_getter_.get());
   std::string post_data_base64;
   if (!hit_report.post_data.empty()) {
     report_ptr->SetUploadData("text/plain", hit_report.post_data);
     base::Base64Encode(hit_report.post_data, &post_data_base64);
   }
 
   net_log_.BeginEvent(
       net::NetLogEventType::SAFE_BROWSING_PING,
       base::Bind(&NetLogPingStartCallback, net_log_,
                  report_ptr->GetOriginalURL(), post_data_base64));
 
   report->Start();
   safebrowsing_reports_.insert(std::move(report_ptr));
 }
 
 // Sends threat details for users who opt-in.
-void SafeBrowsingPingManager::ReportThreatDetails(const std::string& report) {
+void BasePingManager::ReportThreatDetails(const std::string& report) {
   GURL report_url = ThreatDetailsUrl();
   std::unique_ptr<net::URLFetcher> fetcher =
       net::URLFetcher::Create(report_url, net::URLFetcher::POST, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
   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);
 
   std::string report_base64;
   base::Base64Encode(report, &report_base64);
-  net_log_.BeginEvent(
-      net::NetLogEventType::SAFE_BROWSING_PING,
-      base::Bind(&NetLogPingStartCallback, net_log_, fetcher->GetOriginalURL(),
-                 report_base64));
+  net_log_.BeginEvent(net::NetLogEventType::SAFE_BROWSING_PING,
+                      base::Bind(&NetLogPingStartCallback, net_log_,
+                                 fetcher->GetOriginalURL(), report_base64));
 
   fetcher->Start();
   safebrowsing_reports_.insert(std::move(fetcher));
 }
 
-void SafeBrowsingPingManager::ReportPermissionAction(
-    const PermissionReportInfo& report_info) {
-  permission_reporter_->SendReport(report_info);
-}
-
-void SafeBrowsingPingManager::ReportNotificationImage(
-    Profile* profile,
-    const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager,
-    const GURL& origin,
-    const SkBitmap& image) {
-  notification_image_reporter_->ReportNotificationImageOnIO(
-      profile, database_manager, origin, image);
-}
-
-GURL SafeBrowsingPingManager::SafeBrowsingHitUrl(
+GURL BasePingManager::SafeBrowsingHitUrl(
     const safe_browsing::HitReport& hit_report) const {
   DCHECK(hit_report.threat_type == SB_THREAT_TYPE_URL_MALWARE ||
          hit_report.threat_type == SB_THREAT_TYPE_URL_PHISHING ||
          hit_report.threat_type == SB_THREAT_TYPE_URL_UNWANTED ||
          hit_report.threat_type == SB_THREAT_TYPE_BINARY_MALWARE_URL ||
          hit_report.threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL ||
          hit_report.threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL);
-  std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
+  std::string url = ProtocolManagerHelper::ComposeUrl(
       url_prefix_, "report", client_name_, version_, std::string(),
       hit_report.extended_reporting_level);
 
   std::string threat_list = "none";
   switch (hit_report.threat_type) {
     case SB_THREAT_TYPE_URL_MALWARE:
       threat_list = "malblhit";
       break;
     case SB_THREAT_TYPE_URL_PHISHING:
       threat_list = "phishblhit";
@@ skipping 53 matching lines @@
   return GURL(base::StringPrintf(
       "%s&evts=%s&evtd=%s&evtr=%s&evhr=%s&evtb=%d&src=%s&m=%d%s", url.c_str(),
       threat_list.c_str(),
       net::EscapeQueryParamValue(hit_report.malicious_url.spec(), true).c_str(),
       net::EscapeQueryParamValue(hit_report.page_url.spec(), true).c_str(),
       net::EscapeQueryParamValue(hit_report.referrer_url.spec(), true).c_str(),
       hit_report.is_subresource, threat_source.c_str(),
       hit_report.is_metrics_reporting_active, user_population_comp.c_str()));
 }
 
-GURL SafeBrowsingPingManager::ThreatDetailsUrl() const {
+GURL BasePingManager::ThreatDetailsUrl() const {
   std::string url = base::StringPrintf(
-          "%s/clientreport/malware?client=%s&appver=%s&pver=1.0",
-          url_prefix_.c_str(),
-          client_name_.c_str(),
-          version_.c_str());
+      "%s/clientreport/malware?client=%s&appver=%s&pver=1.0",
+      url_prefix_.c_str(), client_name_.c_str(), 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