Remove base::underlying_type, replace uses with std::underlying_type

net/http2/tools/random_decoder_test.h

 // 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.
 
 #ifndef NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_
 #define NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_
 
 // RandomDecoderTest is a base class for tests of decoding various kinds
 // of HTTP/2 and HPACK encodings.
 
 // TODO(jamessynge): Move more methods into .cc file.
 
 #include <stddef.h>
 
 #include <functional>
 #include <memory>
 #include <string>
 #include <type_traits>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
-#include "base/template_util.h"
 #include "net/http2/decoder/decode_buffer.h"
 #include "net/http2/decoder/decode_status.h"
 #include "net/http2/tools/failure.h"
 #include "net/http2/tools/http2_random.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
 // Some helpers.
 
 template <typename T, size_t N>
 base::StringPiece ToStringPiece(T (&data)[N]) {
   return base::StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T));
 }
 
 // strings/hex_ascii_dump.h doesn't support StringPiece args for this case.
 std::string HexEncode(base::StringPiece s);
 
 // Overwrite the enum with some random value, probably not a valid value for
 // the enum type, but which fits into its storage.
 template <typename T,
           typename E = typename std::enable_if<std::is_enum<T>::value>::type>
 void CorruptEnum(T* out, RandomBase* rng) {
   // Per cppreference.com, if the destination type of a static_cast is
   // smaller than the source type (i.e. type of r and uint32 below), the
   // resulting value is the smallest unsigned value equal to the source value
   // modulo 2^n, where n is the number of bits used to represent the
   // destination type unsigned U.
-  typedef typename base::underlying_type<T>::type underlying_type_T;
-  typedef typename std::make_unsigned<underlying_type_T>::type
-      unsigned_underlying_type_T;
+  using underlying_type_T = typename std::underlying_type<T>::type;
+  using unsigned_underlying_type_T =
+      typename std::make_unsigned<underlying_type_T>::type;
   auto r = static_cast<unsigned_underlying_type_T>(rng->Rand32());
   *out = static_cast<T>(r);
 }
 
 // Base class for tests of the ability to decode a sequence of bytes with
 // various boundaries between the DecodeBuffers provided to the decoder.
 class RandomDecoderTest : public ::testing::Test {
  public:
   // SelectSize returns the size of the next DecodeBuffer to be passed to the
   // decoder. Note that RandomDecoderTest allows that size to be zero, though
@@ skipping 186 matching lines @@
   bool stop_decode_on_done_ = true;
 
  private:
   Http2Random random_;
 };
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_