Using == instead of Equals for der::Input comparison.

net/cert/internal/verify_name_match.cc

 // Copyright 2015 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 "net/cert/internal/verify_name_match.h"
 
 #include <string.h>
 
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ skipping 271 matching lines @@
     std::string a_normalized, b_normalized;
     if (!NormalizeValue(a_tag, a_value, &a_normalized) ||
         !NormalizeValue(b_tag, b_value, &b_normalized))
       return false;
     return a_normalized == b_normalized;
   }
   // Attributes encoded with different types may be assumed to be unequal.
   if (a_tag != b_tag)
     return false;
   // All other types use binary comparison.
-  return a_value.Equals(b_value);
+  return a_value == b_value;
 }
 
 struct AttributeTypeAndValue {
   AttributeTypeAndValue(der::Input in_type,
                         der::Tag in_value_tag,
                         der::Input in_value)
       : type(in_type), value_tag(in_value_tag), value(in_value) {}
   der::Input type;
   der::Tag value_tag;
   der::Input value;
@@ skipping 71 matching lines @@
 
   // The ordering of elements may differ due to denormalized values sorting
   // differently in the DER encoding. Since the number of elements should be
   // small, a naive linear search for each element should be fine. (Hostile
   // certificates already have ways to provoke pathological behavior.)
   for (const auto& a : a_type_and_values) {
     std::vector<AttributeTypeAndValue>::iterator b_iter =
         b_type_and_values.begin();
     for (; b_iter != b_type_and_values.end(); ++b_iter) {
       const auto& b = *b_iter;
-      if (a.type.Equals(b.type) &&
+      if (a.type == b.type &&
           VerifyValueMatch(a.value_tag, a.value, b.value_tag, b.value)) {
         break;
       }
     }
     if (b_iter == b_type_and_values.end())
       return false;
     // Remove the matched element from b_type_and_values to ensure duplicate
     // elements in a_type_and_values can't match the same element in
     // b_type_and_values multiple times.
     b_type_and_values.erase(b_iter);
@@ skipping 90 matching lines @@
   while (rdn_sequence_parser.HasMore()) {
     der::Parser rdn_parser;
     if (!rdn_sequence_parser.ReadConstructed(der::kSet, &rdn_parser))
       return false;
 
     std::vector<AttributeTypeAndValue> type_and_values;
     if (!ReadRdn(&rdn_parser, &type_and_values))
       return false;
 
     for (const auto& type_and_value : type_and_values) {
-      if (type_and_value.type.Equals(der::Input(kOidEmailAddress))) {
+      if (type_and_value.type == der::Input(kOidEmailAddress)) {
         *contained_email_address = true;
         return true;
       }
     }
   }
 
   *contained_email_address = false;
   return true;
 }
 
 }  // namespace net