Migrate WTF::Vector::append() to ::push_back() in WTF::HexNumber

third_party/WebKit/Source/wtf/HexNumber.h

Index: third_party/WebKit/Source/wtf/HexNumber.h
diff --git a/third_party/WebKit/Source/wtf/HexNumber.h b/third_party/WebKit/Source/wtf/HexNumber.h
index 6956430bfd413474530f8fe4fd4f764f3f09d2c4..7da2439a01aaef988ece7803890c8b49ba52c0d9 100644
--- a/third_party/WebKit/Source/wtf/HexNumber.h
+++ b/third_party/WebKit/Source/wtf/HexNumber.h
@@ -24,66 +24,81 @@
 
 namespace WTF {
 
-enum HexConversionMode { Lowercase, Uppercase };
-
 namespace Internal {
 
 const LChar lowerHexDigits[17] = "0123456789abcdef";
 const LChar upperHexDigits[17] = "0123456789ABCDEF";
-inline const LChar* hexDigitsForMode(HexConversionMode mode) {
-  return mode == Lowercase ? lowerHexDigits : upperHexDigits;
-}
 
 }  // namespace Internal
 
-template <typename T>
-inline void appendByteAsHex(unsigned char byte,
-                            T& destination,
-                            HexConversionMode mode = Uppercase) {
-  const LChar* hexDigits = Internal::hexDigitsForMode(mode);
-  destination.append(hexDigits[byte >> 4]);
-  destination.append(hexDigits[byte & 0xF]);
-}
-
-template <typename T>
-inline void appendUnsignedAsHex(unsigned number,
-                                T& destination,
-                                HexConversionMode mode = Uppercase) {
-  const LChar* hexDigits = Internal::hexDigitsForMode(mode);
-  Vector<LChar, 8> result;
-  do {
-    result.prepend(hexDigits[number % 16]);
-    number >>= 4;
-  } while (number > 0);
-
-  destination.append(result.data(), result.size());
-}
-
-// Same as appendUnsignedAsHex, but using exactly 'desiredDigits' for the
-// conversion.
-template <typename T>
-inline void appendUnsignedAsHexFixedSize(unsigned number,
+class HexNumber final {
+  STATIC_ONLY(HexNumber);
+
+ public:
+  enum HexConversionMode { Lowercase, Uppercase };
+
+  template <typename T>
+  static inline void appendByteAsHex(unsigned char byte,
+                                     T& destination,
+                                     HexConversionMode mode = Uppercase) {
+    const LChar* hexDigits = hexDigitsForMode(mode);
+    destination.append(hexDigits[byte >> 4]);
+    destination.append(hexDigits[byte & 0xF]);
+  }
+
+  template <typename T>
+  static inline void appendByteAsHex(unsigned char byte,
+                                     Vector<T>& destination,

[jsbell, 2017/01/19 17:52:30]

Partial specialization of functions is forbidden, but partial specialization of
static methods is just fine. Thanks, C++!

[Yuta Kitamura, 2017/01/20 04:46:33]

Strictly speaking, this isn't partial specialization, but
function overloading. This can be done in non-member functions,
too.

+                                     HexConversionMode mode = Uppercase) {
+    const LChar* hexDigits = hexDigitsForMode(mode);
+    destination.push_back(hexDigits[byte >> 4]);
+    destination.push_back(hexDigits[byte & 0xF]);
+  }
+
+  template <typename T>
+  static inline void appendUnsignedAsHex(unsigned number,
                                          T& destination,
-                                         unsigned desiredDigits,
                                          HexConversionMode mode = Uppercase) {
-  DCHECK(desiredDigits);
-
-  const LChar* hexDigits = Internal::hexDigitsForMode(mode);
-  Vector<LChar, 8> result;
-  do {
-    result.prepend(hexDigits[number % 16]);
-    number >>= 4;
-  } while (result.size() < desiredDigits);
-
-  DCHECK_EQ(result.size(), desiredDigits);
-  destination.append(result.data(), result.size());
-}
+    const LChar* hexDigits = hexDigitsForMode(mode);
+    Vector<LChar, 8> result;
+    do {
+      result.prepend(hexDigits[number % 16]);
+      number >>= 4;
+    } while (number > 0);
+
+    destination.append(result.data(), result.size());
+  }
+
+  // Same as appendUnsignedAsHex, but using exactly 'desiredDigits' for the
+  // conversion.
+  template <typename T>
+  static inline void appendUnsignedAsHexFixedSize(
+      unsigned number,
+      T& destination,
+      unsigned desiredDigits,
+      HexConversionMode mode = Uppercase) {
+    DCHECK(desiredDigits);
+
+    const LChar* hexDigits = hexDigitsForMode(mode);
+    Vector<LChar, 8> result;
+    do {
+      result.prepend(hexDigits[number % 16]);
+      number >>= 4;
+    } while (result.size() < desiredDigits);
+
+    DCHECK_EQ(result.size(), desiredDigits);
+    destination.append(result.data(), result.size());
+  }
+
+ private:
+  static inline const LChar* hexDigitsForMode(HexConversionMode mode) {
+    return mode == Lowercase ? Internal::lowerHexDigits
+                             : Internal::upperHexDigits;
+  }
+};
 
 }  // namespace WTF
 
-using WTF::appendByteAsHex;
-using WTF::appendUnsignedAsHex;
-using WTF::appendUnsignedAsHexFixedSize;
-using WTF::Lowercase;
+using WTF::HexNumber;

[jsbell, 2017/01/19 17:52:30]

Question for the architecture folks: 

Given that this CL is touching every use of this API anyway, do we want to keep
the 'using' or should we require callers to be explicit about the WTF namespace?

 
 #endif  // HexNumber_h