[safe browsing] Mobile requests different malware and phishing lists.

chrome/browser/safe_browsing/protocol_parser_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 <string>
 
+#include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+
+#if defined(OS_ANDROID)
+const char kDefaultPhishList[] = "goog-mobilephish-shavar";
+const char kDefaultMalwareList[] = "goog-mobilemalware-shavar";
+#else
+const char kDefaultPhishList[] = "goog-phish-shavar";
+const char kDefaultMalwareList[] = "goog-malware-shavar";
+#endif
+
 // Test parsing one add chunk.
 TEST(SafeBrowsingProtocolParsingTest, TestAddChunk) {
   const char kRawAddChunk[] = {
     '\0', '\0', '\0', '\x1C',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x01',                    // chunk_number varint 1
     '\x22',                    // field 4, wire format length-delimited
     '\x18',                    // varint length 24
     '1', '1', '1', '1',        // 4-byte prefixes
     '2', '2', '2', '2',
@@ skipping 294 matching lines @@
   deletes.clear();
   urls.clear();
   add_del = "n:1700\nad:1-7,43-597,44444,99999\ni:malware\nsd:4,21-27171717\n";
   EXPECT_FALSE(safe_browsing::ParseUpdate(add_del.data(), add_del.length(),
                                           &next_query_sec, &reset,
                                           &deletes, &urls));
 }
 
 // Test parsing the SafeBrowsing update response.
 TEST(SafeBrowsingProtocolParsingTest, TestRedirects) {
-  std::string redirects("i:goog-malware-shavar\n"
-    "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_1\n"
-    "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_2\n"
-    "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_3\n"
-    "u:s.ytimg.com/safebrowsing/rd/goog-phish-shavar_a_8641-8800:8641-8689,"
-    "8691-8731,8733-8786\n");
+  const std::string redirects(base::StringPrintf(
+      "i:%s\n"
+      "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_1\n"
+      "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_2\n"
+      "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_3\n"
+      "u:s.ytimg.com/safebrowsing/rd/goog-phish-shavar_a_8641-8800:8641-8689,"
+      "8691-8731,8733-8786\n",
+      kDefaultMalwareList));
 
   size_t next_query_sec = 0;
   bool reset = false;
   std::vector<SBChunkDelete> deletes;
   std::vector<ChunkUrl> urls;
   EXPECT_TRUE(safe_browsing::ParseUpdate(redirects.data(), redirects.length(),
                                          &next_query_sec, &reset,
                                          &deletes, &urls));
   EXPECT_FALSE(reset);
   EXPECT_EQ(0U, next_query_sec);
@@ skipping 23 matching lines @@
                                          &deletes, &urls));
 
   EXPECT_EQ(1800U, next_query_sec);
   EXPECT_FALSE(reset);
   EXPECT_TRUE(deletes.empty());
   EXPECT_TRUE(urls.empty());
 }
 
 // Test parsing data from a GetHashRequest
 TEST(SafeBrowsingProtocolParsingTest, TestGetHash) {
-  std::string get_hash("45\n"
-                       "goog-phish-shavar:32:3\n"
-                       "00112233445566778899aabbccddeeff"
-                       "00001111222233334444555566667777"
-                       "ffffeeeeddddccccbbbbaaaa99998888");
+  const std::string get_hash(base::StringPrintf(
+      "45\n"
+      "%s:32:3\n"
+      "00112233445566778899aabbccddeeff"
+      "00001111222233334444555566667777"
+      "ffffeeeeddddccccbbbbaaaa99998888",
+      kDefaultPhishList));
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(),
                                           &cache_lifetime, &full_hashes));
 
   ASSERT_EQ(3U, full_hashes.size());
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "00112233445566778899aabbccddeeff",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
   EXPECT_EQ(memcmp(&full_hashes[1].hash,
                    "00001111222233334444555566667777",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[1].list_id);
   EXPECT_EQ(memcmp(&full_hashes[2].hash,
                    "ffffeeeeddddccccbbbbaaaa99998888",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id);
 
   // Test multiple lists in the GetHash results.
-  std::string get_hash2("45\n"
-                        "goog-phish-shavar:32:1\n"
-                        "00112233445566778899aabbccddeeff"
-                        "goog-malware-shavar:32:2\n"
-                        "cafebeefcafebeefdeaddeaddeaddead"
-                        "zzzzyyyyxxxxwwwwvvvvuuuuttttssss");
+  const std::string get_hash2(base::StringPrintf(
+      "45\n"
+      "%s:32:1\n"
+      "00112233445566778899aabbccddeeff"
+      "%s:32:2\n"
+      "cafebeefcafebeefdeaddeaddeaddead"
+      "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
+      kDefaultPhishList,
+      kDefaultMalwareList));
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(),
                                           &cache_lifetime, &full_hashes));
 
   ASSERT_EQ(3U, full_hashes.size());
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "00112233445566778899aabbccddeeff",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
   EXPECT_EQ(memcmp(&full_hashes[1].hash,
                    "cafebeefcafebeefdeaddeaddeaddead",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
   EXPECT_EQ(memcmp(&full_hashes[2].hash,
                    "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[2].list_id);
 
   // Test metadata parsing.
   // TODO(shess): Currently the code doesn't actually put the metadata anywhere,
   // this is just testing that metadata doesn't break parsing.
-  std::string get_hash3("45\n"
-                        "goog-malware-shavar:32:2:m\n"
-                        "zzzzyyyyxxxxwwwwvvvvuuuuttttssss"
-                        "00112233445566778899aabbccddeeff"
-                        "2\nab2\nxy"
-                        "goog-phish-shavar:32:1\n"
-                        "cafebeefcafebeefdeaddeaddeaddead");
+  const std::string get_hash3(base::StringPrintf(
+      "45\n"
+      "%s:32:2:m\n"
+      "zzzzyyyyxxxxwwwwvvvvuuuuttttssss"
+      "00112233445566778899aabbccddeeff"
+      "2\nab2\nxy"
+      "%s:32:1\n"
+      "cafebeefcafebeefdeaddeaddeaddead",
+      kDefaultMalwareList,
+      kDefaultPhishList));
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
                                           &cache_lifetime, &full_hashes));
 
   ASSERT_EQ(3U, full_hashes.size());
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id);
   EXPECT_EQ(memcmp(&full_hashes[1].hash,
                    "00112233445566778899aabbccddeeff",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
   EXPECT_EQ(memcmp(&full_hashes[2].hash,
                    "cafebeefcafebeefdeaddeaddeaddead",
                    sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id);
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) {
-  std::string hash_response = "45\n"
-                              "goog-phish-shavar:32:1\n"
-                              "12345678901234567890123456789012"
-                              "googpub-phish-shavar:32:1\n"
-                              "09876543210987654321098765432109";
+  std::string hash_response(base::StringPrintf(
+      "45\n"
+      "%s:32:1\n"
+      "12345678901234567890123456789012"
+      "googpub-phish-shavar:32:1\n"
+      "09876543210987654321098765432109",
+      kDefaultPhishList));
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
                                           hash_response.size(),
                                           &cache_lifetime,
                                           &full_hashes));
 
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_EQ(memcmp("12345678901234567890123456789012",
                    &full_hashes[0].hash, sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
 
-  hash_response += "goog-malware-shavar:32:1\n"
-                   "abcdefghijklmnopqrstuvwxyz123457";
+  hash_response += base::StringPrintf(
+      "%s:32:1\n"
+      "abcdefghijklmnopqrstuvwxyz123457",
+      kDefaultMalwareList);
   full_hashes.clear();
   EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
                                           hash_response.size(),
                                           &cache_lifetime,
                                           &full_hashes));
 
   EXPECT_EQ(2U, full_hashes.size());
   EXPECT_EQ(memcmp("12345678901234567890123456789012",
                    &full_hashes[0].hash, sizeof(SBFullHash)), 0);
   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
@@ skipping 177 matching lines @@
 
   EXPECT_EQ(3, chunks[2]->ChunkNumber());
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[2]->IsPrefix());
   EXPECT_FALSE(chunks[2]->IsFullHash());
   ASSERT_EQ(1U, chunks[2]->PrefixCount());
   EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0));  // pppp
   EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0));
 }
+
+}  // namespace