Add download server IP address to the SafeBrowsing download protection ping.

chrome/browser/safe_browsing/download_protection_service_unittest.cc

 // Copyright (c) 2011 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/download_protection_service.h"
 
 #include <map>
 #include <string>
 
 #include "base/base_paths.h"
@@ skipping 155 matching lines @@
     for (int i = 0; i < request.resources_size(); ++i) {
       if (request.resources(i).url() == url &&
           request.resources(i).type() == type &&
           (referrer.empty() || request.resources(i).referrer() == referrer)) {
         return true;
       }
     }
     return false;
   }
 
+  // At this point we only set the server IP for the download itself.
+  bool RequestContainsServerIp(const ClientDownloadRequest& request,
+                               const std::string& remote_address) {
+    for (int i = 0; i < request.resources_size(); ++i) {
+      // We want the last DOWNLOAD_URL in the chain.
+      if (request.resources(i).type() == ClientDownloadRequest::DOWNLOAD_URL &&
+          (i + 1 == request.resources_size() ||
+           request.resources(i + 1).type() !=
+           ClientDownloadRequest::DOWNLOAD_URL)) {
+        return remote_address == request.resources(i).remote_ip();
+      }
+    }
+    return false;
+  }
+
   // Flushes any pending tasks in the message loops of all threads.
   void FlushThreadMessageLoops() {
     FlushMessageLoop(BrowserThread::FILE);
     FlushMessageLoop(BrowserThread::IO);
     msg_loop_.RunAllPending();
   }
 
   // Proxy for private method.
   static void GetCertificateWhitelistStrings(
       const net::X509Certificate& certificate,
@@ skipping 213 matching lines @@
   TestURLFetcherFactory factory;
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("bla.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("bla.exe"));
   info.download_url_chain.push_back(GURL("http://www.google.com/"));
   info.download_url_chain.push_back(GURL("http://www.google.com/bla.exe"));
   info.referrer_url = GURL("http://www.google.com/");
   info.sha256_hash = "hash";
   info.total_bytes = 100;
-  info.user_initiated = false;
+  info.user_initiated = true;
+  info.remote_address = "10.11.12.13";
 
   EXPECT_CALL(*sb_service_, MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _))
       .WillOnce(SetCertificateContents("dummy cert data"));
 #if !defined(OS_WIN)
   // If we're not on windows we won't be sending any request but instead
   // we'll be looking up the download hash.
   EXPECT_CALL(*sb_service_,
               CheckDownloadHash(info.sha256_hash, NotNull()))
@@ skipping 11 matching lines @@
 #if !defined(OS_WIN)
   EXPECT_EQ(NULL, fetcher);
 #else
   ASSERT_TRUE(fetcher);
   ClientDownloadRequest request;
   EXPECT_TRUE(request.ParseFromString(fetcher->upload_data()));
   EXPECT_EQ("http://www.google.com/bla.exe", request.url());
   EXPECT_EQ(info.sha256_hash, request.digests().sha256());
   EXPECT_EQ(info.total_bytes, request.length());
   EXPECT_EQ(info.user_initiated, request.user_initiated());
+  EXPECT_TRUE(RequestContainsServerIp(request, info.remote_address));
   EXPECT_EQ(2, request.resources_size());
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_REDIRECT,
                                       "http://www.google.com/", ""));
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_URL,
                                       "http://www.google.com/bla.exe",
                                       info.referrer_url.spec()));
   EXPECT_TRUE(request.has_signature());
   ASSERT_EQ(1, request.signature().certificate_chain_size());
@@ skipping 400 matching lines @@
 
   cert = net::X509Certificate::CreateSelfSigned(
       private_key.get(), "C=US", 1, base::TimeDelta::FromDays(1));
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
   GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre());
 }
 #endif
 }  // namespace safe_browsing