Replace ThreatEntryType::URL_EXPRESSION with ThreatEntryType::URL

components/safe_browsing_db/v4_get_hash_protocol_manager.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 <utility>
 
 #include "base/base64.h"
 #include "base/macros.h"
@@ skipping 125 matching lines @@
 
 std::string V4GetHashProtocolManager::GetHashRequest(
     const std::vector<SBPrefix>& prefixes,
     const std::vector<PlatformType>& platforms,
     ThreatType threat_type) {
   // Build the request. Client info and client states are not added to the
   // request protocol buffer. Client info is passed as params in the url.
   FindFullHashesRequest req;
   ThreatInfo* info = req.mutable_threat_info();
   info->add_threat_types(threat_type);
-  info->add_threat_entry_types(URL_EXPRESSION);
+  info->add_threat_entry_types(URL);
   for (const PlatformType p : platforms) {
     info->add_platform_types(p);
   }
   for (const SBPrefix& prefix : prefixes) {
     std::string hash(reinterpret_cast<const char*>(&prefix), sizeof(SBPrefix));
     info->add_threat_entries()->set_hash(hash);
   }
 
   // Serialize and Base64 encode.
   std::string req_data, req_base64;
@@ skipping 28 matching lines @@
   }
 
   // We only expect one threat type per request, so we make sure
   // the threat types are consistent between matches.
   ThreatType expected_threat_type = THREAT_TYPE_UNSPECIFIED;
 
   // Loop over the threat matches and fill in full_hashes.
   for (const ThreatMatch& match : response.matches()) {
     // Make sure the platform and threat entry type match.
     if (!(match.has_threat_entry_type() &&
-          match.threat_entry_type() == URL_EXPRESSION && match.has_threat())) {
+          match.threat_entry_type() == URL && match.has_threat())) {
       RecordParseGetHashResult(UNEXPECTED_THREAT_ENTRY_TYPE_ERROR);
       return false;
     }
 
     if (!match.has_threat_type()) {
       RecordParseGetHashResult(UNEXPECTED_THREAT_TYPE_ERROR);
       return false;
     }
 
     if (expected_threat_type == THREAT_TYPE_UNSPECIFIED) {
@@ skipping 197 matching lines @@
   next_gethash_time_ = now + next;
 }
 
 GURL V4GetHashProtocolManager::GetHashUrl(const std::string& req_base64) const {
   return V4ProtocolManagerUtil::GetRequestUrl(req_base64, "encodedFullHashes",
                                               config_);
 }
 
 
 }  // namespace safe_browsing