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

google_apis/drive/test_util.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 GOOGLE_APIS_DRIVE_TEST_UTIL_H_
 #define GOOGLE_APIS_DRIVE_TEST_UTIL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
-#include "base/template_util.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/drive_api_error_codes.h"
 #include "google_apis/drive/task_util.h"
 
 class GURL;
 
 namespace base {
 class FilePath;
 class RunLoop;
 class Value;
@@ skipping 99 matching lines @@
 namespace internal {
 // Following helper templates are to support Chrome's move semantics.
 // Their goal is defining helper methods which are similar to:
 //   void CopyResultCallback1(T1* out1, T1&& in1)
 //   void CopyResultCallback2(T1* out1, T2* out2, T1&& in1, T2&& in2)
 //            :
 // in C++11.
 
 // Declare if the type is movable or not. Currently limited to scoped_ptr only.
 // We can add more types upon the usage.
-template<typename T> struct IsMovable : base::false_type {};
+template<typename T> struct IsMovable : std::false_type {};
 template<typename T, typename D>
-struct IsMovable<scoped_ptr<T, D> > : base::true_type {};
+struct IsMovable<scoped_ptr<T, D> > : std::true_type {};
 
 // InType is const T& if |UseConstRef| is true, otherwise |T|.
 template<bool UseConstRef, typename T> struct InTypeHelper {
   typedef const T& InType;
 };
 template<typename T> struct InTypeHelper<false, T> {
   typedef T InType;
 };
 
 // Simulates the std::move function in C++11. We use pointer here for argument,
 // instead of rvalue reference.
 template<bool IsMovable, typename T> struct MoveHelper {
   static const T& Move(const T* in) { return *in; }
 };
 template<typename T> struct MoveHelper<true, T> {
   static T Move(T* in) { return std::move(*in); }
 };
 
 // Helper to handle Chrome's move semantics correctly.
 template<typename T>
 struct CopyResultCallbackHelper
       // It is necessary to calculate the exact signature of callbacks we want
       // to create here. In our case, as we use value-parameters for primitive
       // types and movable types in the callback declaration.
       // Thus the incoming type is as follows:
       // 1) If the argument type |T| is class type but doesn't movable,
       //    |InType| is const T&.
       // 2) Otherwise, |T| as is.
     : InTypeHelper<
-          base::is_class<T>::value && !IsMovable<T>::value,  // UseConstRef
+          std::is_class<T>::value && !IsMovable<T>::value,  // UseConstRef
           T>,
       MoveHelper<IsMovable<T>::value, T> {
 };
 
 // Copies the |in|'s value to |out|.
 template<typename T1>
 void CopyResultCallback(
     T1* out,
     typename CopyResultCallbackHelper<T1>::InType in) {
   *out = CopyResultCallbackHelper<T1>::Move(&in);
@@ skipping 111 matching lines @@
   const GetContentCallback callback_;
   ScopedVector<std::string> data_;
 
   DISALLOW_COPY_AND_ASSIGN(TestGetContentCallback);
 };
 
 }  // namespace test_util
 }  // namespace google_apis
 
 #endif  // GOOGLE_APIS_DRIVE_TEST_UTIL_H_