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

net/der/input.h

 // 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.
 
 #ifndef NET_DER_INPUT_H_
 #define NET_DER_INPUT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 45 matching lines @@
   explicit Input(const base::StringPiece& sp);
 
   // Creates an Input from a std::string. The lifetimes are a bit subtle when
   // using this function: The constructed Input is only valid so long as |s| is
   // still alive and not mutated.
   Input(const std::string* s);
 
   // Returns the length in bytes of an Input's data.
   size_t Length() const { return len_; }
 
-  // Return true if the Input's data and |other|'s data are byte-wise equal.
-  bool Equals(const Input& other) const;
-
   // Returns a pointer to the Input's data. This method is marked as "unsafe"
   // because access to the Input's data should be done through ByteReader
   // instead. This method should only be used where using a ByteReader truly
   // is not an option.
   const uint8_t* UnsafeData() const { return data_; }
 
   // Returns a copy of the data represented by this object as a std::string.
   std::string AsString() const;
 
   // Returns a StringPiece pointing to the same data as the Input. The resulting
   // StringPiece must not outlive the data that was used to construct this
   // Input.
   base::StringPiece AsStringPiece() const;
 
  private:
   // This constructor is deleted to prevent constructing an Input from a
   // std::string r-value. Since the Input points to memory owned by another
   // object, such an Input would point to invalid memory. Without this deleted
   // constructor, a std::string could be passed in to the base::StringPiece
   // constructor because of StringPiece's implicit constructor.
   Input(std::string) = delete;
   const uint8_t* data_;
   size_t len_;
 };
 
+// Return true if |lhs|'s data and |rhs|'s data are byte-wise equal.
+NET_EXPORT_PRIVATE bool operator==(const Input& lhs, const Input& rhs);

[eroman, 2016/02/04 19:43:42]

Any reason to choose a function rather than method on Input?

I don't really care either way, but I think it is more common in net code to
expose these as member functions.

[mattm, 2016/02/04 20:05:51]

See my reference above to the style guide. (I don't really feel strongly about
it, just think we should default to following the guide unless there's a reason
not to.)

+
+// Return true if |lhs|'s data and |rhs|'s data are not byte-wise equal.
+NET_EXPORT_PRIVATE bool operator!=(const Input& lhs, const Input& rhs);
+
 // Returns true if |lhs|'s data is lexicographically less than |rhs|'s data.
 NET_EXPORT_PRIVATE bool operator<(const Input& lhs, const Input& rhs);
 
 // This class provides ways to read data from an Input in a bounds-checked way.
 // The ByteReader is designed to read through the input sequentially. Once a
 // byte has been read with a ByteReader, the caller can't go back and re-read
 // that byte with the same reader. Of course, the caller can create multiple
 // ByteReaders for the same input (or copy an existing ByteReader).
 //
 // For something simple like a single byte lookahead, the easiest way to do
@@ skipping 72 matching lines @@
   explicit Mark(const uint8_t* ptr);
   Mark();
   const uint8_t* ptr_;
 };
 
 }  // namespace der
 
 }  // namespace net
 
 #endif  // NET_DER_INPUT_H_