Store and return urls instead of hosts for the malware IP matching.

chrome/browser/safe_browsing/client_side_detection_host.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/client_side_detection_host.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 26 matching lines @@
 #include "content/public/common/frame_navigate_params.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::ResourceRequestDetails;
 using content::WebContents;
 
 namespace safe_browsing {
 
-const int ClientSideDetectionHost::kMaxHostsPerIP = 20;
+const int ClientSideDetectionHost::kMaxUrlsPerIP = 20;
 const int ClientSideDetectionHost::kMaxIPsPerBrowse = 200;
 
 namespace {
 
 void EmptyUrlCheckCallback(bool processed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 }  // namespace
 
@@ skipping 428 matching lines @@
   // Send ping if there is matching features.
   if (request->feature_map_size() > 0) {
     VLOG(1) << "Start sending client malware request.";
     ClientSideDetectionService::ClientReportMalwareRequestCallback callback;
     csd_service_->SendClientReportMalwareRequest(
         request.release(),  // The service takes ownership of the request object
         callback);  // no action after request sent for now
   }
 }
 
-void ClientSideDetectionHost::UpdateIPHostMap(const std::string& ip,
-                                              const std::string& host) {
-  if (ip.empty() || host.empty())
+void ClientSideDetectionHost::UpdateIPUrlMap(const std::string& ip,
+                                             const std::string& url) {
+  if (ip.empty() || url.empty())
     return;
 
-  IPHostMap::iterator it = browse_info_->ips.find(ip);
+  IPUrlMap::iterator it = browse_info_->ips.find(ip);
   if (it == browse_info_->ips.end()) {
     if (int(browse_info_->ips.size()) < kMaxIPsPerBrowse) {
-      std::set<std::string> hosts;
-      hosts.insert(host);
-      browse_info_->ips.insert(make_pair(ip, hosts));
+      std::set<std::string> urls;
+      urls.insert(url);
+      browse_info_->ips.insert(make_pair(ip, urls));
     }
-  } else if (int(it->second.size()) < kMaxHostsPerIP) {
-    it->second.insert(host);
+  } else if (int(it->second.size()) < kMaxUrlsPerIP) {
+    it->second.insert(url);
   }
 }
 
 void ClientSideDetectionHost::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(type, content::NOTIFICATION_RESOURCE_RESPONSE_STARTED);
   const ResourceRequestDetails* req = content::Details<ResourceRequestDetails>(
       details).ptr();
   if (req && browse_info_.get() && malware_report_enabled_ &&
       !MalwareKillSwitchIsOn()) {
-    UpdateIPHostMap(req->socket_address.host() /* ip */,
-                    req->url.host()  /* url host */);
+    if (req->url.is_valid()) {
+      UpdateIPUrlMap(req->socket_address.host() /* ip */,
+                     req->url.spec()  /* url */);
+    }
   }
 }
 
 bool ClientSideDetectionHost::DidShowSBInterstitial() {
   if (unsafe_unique_page_id_ <= 0 || !web_contents()) {
     return false;
   }
   const NavigationEntry* nav_entry =
       web_contents()->GetController().GetActiveEntry();
   return (nav_entry && nav_entry->GetUniqueID() == unsafe_unique_page_id_);
@@ skipping 21 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return malware_killswitch_on_;
 }
 
 void ClientSideDetectionHost::SetMalwareKillSwitch(bool killswitch_on) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   malware_killswitch_on_ = killswitch_on;
 }
 
 }  // namespace safe_browsing