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

net/cert/internal/signature_algorithm.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/signature_algorithm.h"
 
 #include <utility>
 
 #include "base/numerics/safe_math.h"
 #include "net/der/input.h"
@@ skipping 322 matching lines @@
 //     }
 WARN_UNUSED_RESULT bool ParseHashAlgorithm(const der::Input input,
                                            DigestAlgorithm* out) {
   der::Input oid;
   der::Input params;
   if (!ParseAlgorithmIdentifier(input, &oid, &params))
     return false;
 
   DigestAlgorithm hash;
 
-  if (oid.Equals(der::Input(kOidSha1))) {
+  if (oid == der::Input(kOidSha1)) {
     hash = DigestAlgorithm::Sha1;
-  } else if (oid.Equals(der::Input(kOidSha256))) {
+  } else if (oid == der::Input(kOidSha256)) {
     hash = DigestAlgorithm::Sha256;
-  } else if (oid.Equals(der::Input(kOidSha384))) {
+  } else if (oid == der::Input(kOidSha384)) {
     hash = DigestAlgorithm::Sha384;
-  } else if (oid.Equals(der::Input(kOidSha512))) {
+  } else if (oid == der::Input(kOidSha512)) {
     hash = DigestAlgorithm::Sha512;
   } else {
     // Unsupported digest algorithm.
     return false;
   }
 
   // From RFC 5912: "PARAMS TYPE NULL ARE preferredPresent". Which is to say
   // the can either be absent, or NULL.
   if (!IsEmpty(params) && !IsNull(params))
     return false;
@@ skipping 28 matching lines @@
 // the only function supported is MGF1, as that is the singular mask gen
 // function defined by RFC 4055 / RFC 5912.
 WARN_UNUSED_RESULT bool ParseMaskGenAlgorithm(const der::Input input,
                                               DigestAlgorithm* mgf1_hash) {
   der::Input oid;
   der::Input params;
   if (!ParseAlgorithmIdentifier(input, &oid, &params))
     return false;
 
   // MGF1 is the only supported mask generation algorithm.
-  if (!oid.Equals(der::Input(kOidMgf1)))
+  if (oid != der::Input(kOidMgf1))
     return false;
 
   return ParseHashAlgorithm(params, mgf1_hash);
 }
 
 // Consumes an optional, explicitly-tagged INTEGER from |parser|, using the
 // indicated context-specific class number. Values greater than 32-bits will be
 // rejected.
 //
 // Returns true on success and sets |*present| to true if the field was present.
@@ skipping 139 matching lines @@
 scoped_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateFromDer(
     const der::Input& algorithm_identifier) {
   der::Input oid;
   der::Input params;
   if (!ParseAlgorithmIdentifier(algorithm_identifier, &oid, &params))
     return nullptr;
 
   // TODO(eroman): Each OID is tested for equality in order, which is not
   // particularly efficient.
 
-  if (oid.Equals(der::Input(kOidSha1WithRsaEncryption)))
+  if (oid == der::Input(kOidSha1WithRsaEncryption))
     return ParseRsaPkcs1(DigestAlgorithm::Sha1, params);
 
-  if (oid.Equals(der::Input(kOidSha256WithRsaEncryption)))
+  if (oid == der::Input(kOidSha256WithRsaEncryption))
     return ParseRsaPkcs1(DigestAlgorithm::Sha256, params);
 
-  if (oid.Equals(der::Input(kOidSha384WithRsaEncryption)))
+  if (oid == der::Input(kOidSha384WithRsaEncryption))
     return ParseRsaPkcs1(DigestAlgorithm::Sha384, params);
 
-  if (oid.Equals(der::Input(kOidSha512WithRsaEncryption)))
+  if (oid == der::Input(kOidSha512WithRsaEncryption))
     return ParseRsaPkcs1(DigestAlgorithm::Sha512, params);
 
-  if (oid.Equals(der::Input(kOidEcdsaWithSha1)))
+  if (oid == der::Input(kOidEcdsaWithSha1))
     return ParseEcdsa(DigestAlgorithm::Sha1, params);
 
-  if (oid.Equals(der::Input(kOidEcdsaWithSha256)))
+  if (oid == der::Input(kOidEcdsaWithSha256))
     return ParseEcdsa(DigestAlgorithm::Sha256, params);
 
-  if (oid.Equals(der::Input(kOidEcdsaWithSha384)))
+  if (oid == der::Input(kOidEcdsaWithSha384))
     return ParseEcdsa(DigestAlgorithm::Sha384, params);
 
-  if (oid.Equals(der::Input(kOidEcdsaWithSha512)))
+  if (oid == der::Input(kOidEcdsaWithSha512))
     return ParseEcdsa(DigestAlgorithm::Sha512, params);
 
-  if (oid.Equals(der::Input(kOidRsaSsaPss)))
+  if (oid == der::Input(kOidRsaSsaPss))
     return ParseRsaPss(params);
 
-  if (oid.Equals(der::Input(kOidSha1WithRsaSignature)))
+  if (oid == der::Input(kOidSha1WithRsaSignature))
     return ParseRsaPkcs1(DigestAlgorithm::Sha1, params);
 
   return nullptr;  // Unsupported OID.
 }
 
 scoped_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateRsaPkcs1(
     DigestAlgorithm digest) {
   return make_scoped_ptr(
       new SignatureAlgorithm(SignatureAlgorithmId::RsaPkcs1, digest, nullptr));
 }
@@ skipping 19 matching lines @@
   return nullptr;
 }
 
 SignatureAlgorithm::SignatureAlgorithm(
     SignatureAlgorithmId algorithm,
     DigestAlgorithm digest,
     scoped_ptr<SignatureAlgorithmParameters> params)
     : algorithm_(algorithm), digest_(digest), params_(std::move(params)) {}
 
 }  // namespace net