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

chrome/browser/safe_browsing/client_side_detection_host_unittest.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 "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 209 matching lines @@
     // This needs to happen before we call the parent SetUp() function.  We use
     // a nice mock because other parts of the code are calling IsOffTheRecord.
     mock_profile_ = new NiceMock<MockTestingProfile>();
     return mock_profile_;
   }
 
   void OnPhishingDetectionDone(const std::string& verdict_str) {
     csd_host_->OnPhishingDetectionDone(verdict_str);
   }
 
-  void UpdateIPHostMap(const std::string& ip, const std::string& host) {
-    csd_host_->UpdateIPHostMap(ip, host);
+  void UpdateIPUrlMap(const std::string& ip, const std::string& host) {
+    csd_host_->UpdateIPUrlMap(ip, host);
   }
 
   BrowseInfo* GetBrowseInfo() {
     return csd_host_->browse_info_.get();
   }
 
   void ExpectPreClassificationChecks(const GURL& url,
                                      const bool* is_private,
                                      const bool* is_incognito,
                                      const bool* match_csd_whitelist,
@@ skipping 333 matching lines @@
                   Pointee(PartiallyEqualVerdict(verdict)), CallbackIsNull()))
       .WillOnce(DoAll(DeleteArg<0>(), QuitUIMessageLoop()));
   std::vector<GURL> redirect_chain;
   redirect_chain.push_back(url);
   SetRedirectChain(redirect_chain);
   OnPhishingDetectionDone(verdict.SerializeAsString());
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
 }
 
-TEST_F(ClientSideDetectionHostTest, UpdateIPHostMap) {
+TEST_F(ClientSideDetectionHostTest, UpdateIPUrlMap) {
   BrowseInfo* browse_info = GetBrowseInfo();
 
   // Empty IP or host are skipped
-  UpdateIPHostMap("250.10.10.10", std::string());
+  UpdateIPUrlMap("250.10.10.10", std::string());
   ASSERT_EQ(0U, browse_info->ips.size());
-  UpdateIPHostMap(std::string(), "google.com/");
+  UpdateIPUrlMap(std::string(), "http://google.com/a");
   ASSERT_EQ(0U, browse_info->ips.size());
-  UpdateIPHostMap(std::string(), std::string());
+  UpdateIPUrlMap(std::string(), std::string());
   ASSERT_EQ(0U, browse_info->ips.size());
 
-  std::set<std::string> expected_hosts;
+  std::set<std::string> expected_urls;
   for (int i = 0; i < 20; i++) {
-    std::string host = base::StringPrintf("%d.com/", i);
-    expected_hosts.insert(host);
-    UpdateIPHostMap("250.10.10.10", host);
+    std::string url = base::StringPrintf("http://%d.com/", i);
+    expected_urls.insert(url);
+    UpdateIPUrlMap("250.10.10.10", url);
   }
   ASSERT_EQ(1U, browse_info->ips.size());
   ASSERT_EQ(20U, browse_info->ips["250.10.10.10"].size());
-  EXPECT_EQ(expected_hosts, browse_info->ips["250.10.10.10"]);
+  EXPECT_EQ(expected_urls, browse_info->ips["250.10.10.10"]);
 
-  // Add more hosts for this ip, it exceeds max limit and won't be added
-  UpdateIPHostMap("250.10.10.10", "21.com/");
+  // Add more urls for this ip, it exceeds max limit and won't be added
+  UpdateIPUrlMap("250.10.10.10", "http://21.com/");
   ASSERT_EQ(1U, browse_info->ips.size());
   ASSERT_EQ(20U, browse_info->ips["250.10.10.10"].size());
-  EXPECT_EQ(expected_hosts, browse_info->ips["250.10.10.10"]);
+  EXPECT_EQ(expected_urls, browse_info->ips["250.10.10.10"]);
 
   // Add 199 more IPs
   for (int i = 0; i < 199; i++) {
     std::string ip = base::StringPrintf("%d.%d.%d.256", i, i, i);
-    expected_hosts.clear();
-    expected_hosts.insert("test.com/");
-    UpdateIPHostMap(ip, "test.com/");
+    expected_urls.clear();
+    expected_urls.insert("test.com/");
+    UpdateIPUrlMap(ip, "test.com/");
     ASSERT_EQ(1U, browse_info->ips[ip].size());
-    EXPECT_EQ(expected_hosts, browse_info->ips[ip]);
+    EXPECT_EQ(expected_urls, browse_info->ips[ip]);
   }
   ASSERT_EQ(200U, browse_info->ips.size());
 
   // Exceeding max ip limit 200, these won't be added
-  UpdateIPHostMap("250.250.250.250", "goo.com/");
-  UpdateIPHostMap("250.250.250.250", "bar.com/");
-  UpdateIPHostMap("250.250.0.250", "foo.com/");
+  UpdateIPUrlMap("250.250.250.250", "goo.com/");
+  UpdateIPUrlMap("250.250.250.250", "bar.com/");
+  UpdateIPUrlMap("250.250.0.250", "foo.com/");
   ASSERT_EQ(200U, browse_info->ips.size());
 
-  // Add host to existing IPs succeed
-  UpdateIPHostMap("100.100.100.256", "more.com/");
+  // Add url to existing IPs succeed
+  UpdateIPUrlMap("100.100.100.256", "more.com/");
   ASSERT_EQ(2U, browse_info->ips["100.100.100.256"].size());
-  expected_hosts.clear();
-  expected_hosts.insert("test.com/");
-  expected_hosts.insert("more.com/");
-  EXPECT_EQ(expected_hosts, browse_info->ips["100.100.100.256"]);
+  expected_urls.clear();
+  expected_urls.insert("test.com/");
+  expected_urls.insert("more.com/");
+  EXPECT_EQ(expected_urls, browse_info->ips["100.100.100.256"]);
 }
 
 TEST_F(ClientSideDetectionHostTest,
        OnPhishingDetectionDoneVerdictNotPhishingNotMalwareIP) {
   // Case 7: renderer sends a verdict string that isn't phishing and not matches
   // malware bad IP list
   MockBrowserFeatureExtractor* mock_extractor = new MockBrowserFeatureExtractor(
       web_contents(),
       csd_service_.get());
   SetFeatureExtractor(mock_extractor);  // The host class takes ownership.
@@ skipping 264 matching lines @@
   EXPECT_TRUE(Mock::VerifyAndClear(ui_manager_.get()));
   EXPECT_EQ(url, resource.url);
   EXPECT_EQ(url, resource.original_url);
   resource.callback.Reset();
   msg = process()->sink().GetFirstMessageMatching(
       SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 }
 
 }  // namespace safe_browsing