Remove base::is_trivially_destructible and use the standard library.

base/trace_event/memory_usage_estimator.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 BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
 #define BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <array>
 #include <deque>
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <set>
 #include <stack>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/containers/linked_list.h"
 #include "base/strings/string16.h"
-#include "base/template_util.h"
 
 // Composable memory usage estimators.
 //
 // This file defines set of EstimateMemoryUsage(object) functions that return
 // approximate memory usage of their argument.
 //
 // The ultimate goal is to make memory usage estimation for a class simply a
 // matter of aggregating EstimateMemoryUsage() results over all fields.
 //
 // That is achieved via composability: if EstimateMemoryUsage() is defined
@@ skipping 162 matching lines @@
 
 template <class T>
 struct EMUCaller<T, typename std::enable_if<HasEMU<T>::value>::type> {
   static size_t Call(const T& value) { return EstimateMemoryUsage(value); }
 };
 
 template <class T>
 struct EMUCaller<
     T,
     typename std::enable_if<!HasEMU<T>::value &&
-                            is_trivially_destructible<T>::value>::type> {
+                            std::is_trivially_destructible<T>::value>::type> {
   static size_t Call(const T& value) { return 0; }
 };
 
 // Returns reference to the underlying container of a container adapter.
 // Works for std::stack, std::queue and std::priority_queue.
 template <class A>
 const typename A::container_type& GetUnderlyingContainer(const A& adapter) {
   struct ExposedAdapter : A {
     using A::c;
   };
@@ skipping 319 matching lines @@
 
 template <class T, class C>
 size_t EstimateMemoryUsage(const std::stack<T, C>& stack) {
   return EstimateMemoryUsage(internal::GetUnderlyingContainer(stack));
 }
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_