Replace template_util.h stuff with C++11 <type_traits>

base/android/scoped_java_ref.h

 // Copyright (c) 2012 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_ANDROID_SCOPED_JAVA_REF_H_
 #define BASE_ANDROID_SCOPED_JAVA_REF_H_
 
 #include <jni.h>
 #include <stddef.h>
 
+#include <type_traits>
+
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/template_util.h"
 
 namespace base {
 namespace android {
 
 // Creates a new local reference frame, in which at least a given number of
 // local references can be created. Note that local references already created
 // in previous local frames are still valid in the current local frame.
 class BASE_EXPORT ScopedJavaLocalFrame {
  public:
   explicit ScopedJavaLocalFrame(JNIEnv* env);
@@ skipping 161 matching lines @@
 
   template<typename U>
   void Reset(const U& other) {
     // If |env_| was not yet set (is still NULL) it will be attached to the
     // current thread in SetNewLocalRef().
     this->Reset(env_, other.obj());
   }
 
   template<typename U>
   void Reset(JNIEnv* env, U obj) {
-    static_assert(base::is_convertible<U, T>::value,
+    static_assert(std::is_convertible<U, T>::value,
                   "U must be convertible to T");
     env_ = this->SetNewLocalRef(env, obj);
   }
 
   // Releases the local reference to the caller. The caller *must* delete the
   // local reference when it is done with it. Note that calling a Java method
   // is *not* a transfer of ownership and Release() should not be used.
   T Release() {
     return static_cast<T>(this->ReleaseInternal());
   }
@@ skipping 50 matching lines @@
     this->Reset(NULL, other.obj());
   }
 
   template<typename U>
   void Reset(JNIEnv* env, const JavaParamRef<U>& other) {
     this->Reset(env, other.obj());
   }
 
   template<typename U>
   void Reset(JNIEnv* env, U obj) {
-    static_assert(base::is_convertible<U, T>::value,
+    static_assert(std::is_convertible<U, T>::value,
                   "U must be convertible to T");
     this->SetNewGlobalRef(env, obj);
   }
 
   // Releases the global reference to the caller. The caller *must* delete the
   // global reference when it is done with it. Note that calling a Java method
   // is *not* a transfer of ownership and Release() should not be used.
   T Release() {
     return static_cast<T>(this->ReleaseInternal());
   }
 };
 
 }  // namespace android
 }  // namespace base
 
 #endif  // BASE_ANDROID_SCOPED_JAVA_REF_H_