Replace ThreatEntryType::URL_EXPRESSION with ThreatEntryType::URL

components/safe_browsing_db/v4_get_hash_protocol_manager_unittest.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 33 matching lines @@
     return std::unique_ptr<V4GetHashProtocolManager>(
         V4GetHashProtocolManager::Create(NULL, config));
   }
 
   std::string GetStockV4HashResponse() {
     FindFullHashesResponse res;
     res.mutable_negative_cache_duration()->set_seconds(600);
     ThreatMatch* m = res.add_matches();
     m->set_threat_type(API_ABUSE);
     m->set_platform_type(CHROME_PLATFORM);
-    m->set_threat_entry_type(URL_EXPRESSION);
+    m->set_threat_entry_type(URL);
     m->mutable_cache_duration()->set_seconds(300);
     m->mutable_threat()->set_hash(
         SBFullHashToString(SBFullHashForString("Everything's shiny, Cap'n.")));
     ThreatEntryMetadata::MetadataEntry* e =
         m->mutable_threat_entry_metadata()->add_entries();
     e->set_key("permission");
     e->set_value("NOTIFICATIONS");
 
     // Serialize.
     std::string res_data;
@@ skipping 107 matching lines @@
   EXPECT_EQ(1ul, pm->gethash_back_off_mult_);
 }
 
 TEST_F(SafeBrowsingV4GetHashProtocolManagerTest, TestGetHashRequest) {
   std::unique_ptr<V4GetHashProtocolManager> pm(CreateProtocolManager());
 
   FindFullHashesRequest req;
   ThreatInfo* info = req.mutable_threat_info();
   info->add_threat_types(API_ABUSE);
   info->add_platform_types(CHROME_PLATFORM);
-  info->add_threat_entry_types(URL_EXPRESSION);
+  info->add_threat_entry_types(URL);
 
   SBPrefix one = 1u;
   SBPrefix two = 2u;
   SBPrefix three = 3u;
   std::string hash(reinterpret_cast<const char*>(&one), sizeof(SBPrefix));
   info->add_threat_entries()->set_hash(hash);
   hash.clear();
   hash.append(reinterpret_cast<const char*>(&two), sizeof(SBPrefix));
   info->add_threat_entries()->set_hash(hash);
   hash.clear();
@@ skipping 21 matching lines @@
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   clock->SetNow(now);
   pm->SetClockForTests(base::WrapUnique(clock));
 
   FindFullHashesResponse res;
   res.mutable_negative_cache_duration()->set_seconds(600);
   res.mutable_minimum_wait_duration()->set_seconds(400);
   ThreatMatch* m = res.add_matches();
   m->set_threat_type(API_ABUSE);
   m->set_platform_type(CHROME_PLATFORM);
-  m->set_threat_entry_type(URL_EXPRESSION);
+  m->set_threat_entry_type(URL);
   m->mutable_cache_duration()->set_seconds(300);
   m->mutable_threat()->set_hash(
       SBFullHashToString(SBFullHashForString("Everything's shiny, Cap'n.")));
   ThreatEntryMetadata::MetadataEntry* e =
       m->mutable_threat_entry_metadata()->add_entries();
   e->set_key("permission");
   e->set_value("NOTIFICATIONS");
 
   // Serialize.
   std::string res_data;
@@ skipping 40 matching lines @@
 TEST_F(SafeBrowsingV4GetHashProtocolManagerTest,
        TestParseHashThreatPatternType) {
   std::unique_ptr<V4GetHashProtocolManager> pm(CreateProtocolManager());
 
   // Test social engineering pattern type.
   FindFullHashesResponse se_res;
   se_res.mutable_negative_cache_duration()->set_seconds(600);
   ThreatMatch* se = se_res.add_matches();
   se->set_threat_type(SOCIAL_ENGINEERING_PUBLIC);
   se->set_platform_type(CHROME_PLATFORM);
-  se->set_threat_entry_type(URL_EXPRESSION);
+  se->set_threat_entry_type(URL);
   SBFullHash hash_string = SBFullHashForString("Everything's shiny, Cap'n.");
   se->mutable_threat()->set_hash(SBFullHashToString(hash_string));
   ThreatEntryMetadata::MetadataEntry* se_meta =
       se->mutable_threat_entry_metadata()->add_entries();
   se_meta->set_key("se_pattern_type");
   se_meta->set_value("SOCIAL_ENGINEERING_LANDING");
 
   std::string se_data;
   se_res.SerializeToString(&se_data);
 
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_TRUE(pm->ParseHashResponse(se_data, &full_hashes, &cache_lifetime));
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(600), cache_lifetime);
   EXPECT_EQ(1ul, full_hashes.size());
   EXPECT_TRUE(SBFullHashEqual(hash_string, full_hashes[0].hash));
   EXPECT_EQ(ThreatPatternType::SOCIAL_ENGINEERING_LANDING,
             full_hashes[0].metadata.threat_pattern_type);
 
   // Test potentially harmful application pattern type.
   FindFullHashesResponse pha_res;
   pha_res.mutable_negative_cache_duration()->set_seconds(600);
   ThreatMatch* pha = pha_res.add_matches();
   pha->set_threat_type(POTENTIALLY_HARMFUL_APPLICATION);
-  pha->set_threat_entry_type(URL_EXPRESSION);
+  pha->set_threat_entry_type(URL);
   pha->set_platform_type(CHROME_PLATFORM);
   hash_string = SBFullHashForString("Not to fret.");
   pha->mutable_threat()->set_hash(SBFullHashToString(hash_string));
   ThreatEntryMetadata::MetadataEntry* pha_meta =
       pha->mutable_threat_entry_metadata()->add_entries();
   pha_meta->set_key("pha_pattern_type");
   pha_meta->set_value("LANDING");
 
   std::string pha_data;
   pha_res.SerializeToString(&pha_data);
   full_hashes.clear();
   EXPECT_TRUE(pm->ParseHashResponse(pha_data, &full_hashes, &cache_lifetime));
   EXPECT_EQ(1ul, full_hashes.size());
   EXPECT_TRUE(SBFullHashEqual(hash_string, full_hashes[0].hash));
   EXPECT_EQ(ThreatPatternType::MALWARE_LANDING,
             full_hashes[0].metadata.threat_pattern_type);
 
   // Test invalid pattern type.
   FindFullHashesResponse invalid_res;
   invalid_res.mutable_negative_cache_duration()->set_seconds(600);
   ThreatMatch* invalid = invalid_res.add_matches();
   invalid->set_threat_type(POTENTIALLY_HARMFUL_APPLICATION);
-  invalid->set_threat_entry_type(URL_EXPRESSION);
+  invalid->set_threat_entry_type(URL);
   invalid->set_platform_type(CHROME_PLATFORM);
   invalid->mutable_threat()->set_hash(SBFullHashToString(hash_string));
   ThreatEntryMetadata::MetadataEntry* invalid_meta =
       invalid->mutable_threat_entry_metadata()->add_entries();
   invalid_meta->set_key("pha_pattern_type");
   invalid_meta->set_value("INVALIDE_VALUE");
 
   std::string invalid_data;
   invalid_res.SerializeToString(&invalid_data);
   full_hashes.clear();
   EXPECT_FALSE(
       pm->ParseHashResponse(invalid_data, &full_hashes, &cache_lifetime));
   EXPECT_EQ(0ul, full_hashes.size());
 }
 
 // Adds metadata with a key value that is not "permission".
 TEST_F(SafeBrowsingV4GetHashProtocolManagerTest,
        TestParseHashResponseNonPermissionMetadata) {
   std::unique_ptr<V4GetHashProtocolManager> pm(CreateProtocolManager());
 
   FindFullHashesResponse res;
   res.mutable_negative_cache_duration()->set_seconds(600);
   ThreatMatch* m = res.add_matches();
   m->set_threat_type(API_ABUSE);
   m->set_platform_type(CHROME_PLATFORM);
-  m->set_threat_entry_type(URL_EXPRESSION);
+  m->set_threat_entry_type(URL);
   m->mutable_threat()->set_hash(
       SBFullHashToString(SBFullHashForString("Not to fret.")));
   ThreatEntryMetadata::MetadataEntry* e =
       m->mutable_threat_entry_metadata()->add_entries();
   e->set_key("notpermission");
   e->set_value("NOTGEOLOCATION");
 
   // Serialize.
   std::string res_data;
   res.SerializeToString(&res_data);
 
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_FALSE(pm->ParseHashResponse(res_data, &full_hashes, &cache_lifetime));
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(600), cache_lifetime);
   EXPECT_EQ(0ul, full_hashes.size());
 }
 
 TEST_F(SafeBrowsingV4GetHashProtocolManagerTest,
        TestParseHashResponseInconsistentThreatTypes) {
   std::unique_ptr<V4GetHashProtocolManager> pm(CreateProtocolManager());
 
   FindFullHashesResponse res;
   ThreatMatch* m1 = res.add_matches();
   m1->set_threat_type(API_ABUSE);
   m1->set_platform_type(CHROME_PLATFORM);
-  m1->set_threat_entry_type(URL_EXPRESSION);
+  m1->set_threat_entry_type(URL);
   m1->mutable_threat()->set_hash(
       SBFullHashToString(SBFullHashForString("Everything's shiny, Cap'n.")));
   m1->mutable_threat_entry_metadata()->add_entries();
   ThreatMatch* m2 = res.add_matches();
   m2->set_threat_type(MALWARE_THREAT);
-  m2->set_threat_entry_type(URL_EXPRESSION);
+  m2->set_threat_entry_type(URL);
   m2->mutable_threat()->set_hash(
       SBFullHashToString(SBFullHashForString("Not to fret.")));
 
   // Serialize.
   std::string res_data;
   res.SerializeToString(&res_data);
 
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_FALSE(pm->ParseHashResponse(res_data, &full_hashes, &cache_lifetime));
 }
 
 }  // namespace safe_browsing