Replace base::get with std::get

base/bind_internal.h

 // Copyright (c) 2011 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_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include <stddef.h>
 
 #include <tuple>
@@ skipping 342 matching lines @@
 
     using DecayedArgsTuple = typename std::decay<BoundArgsTuple>::type;
     static constexpr bool is_weak_call =
         IsWeakMethod<is_method,
                      typename std::tuple_element<
                          indices,
                          DecayedArgsTuple>::type...>::value;
 
     return InvokeHelper<is_weak_call, R>::MakeItSo(
         std::forward<Functor>(functor),
-        Unwrap(base::get<indices>(std::forward<BoundArgsTuple>(bound)))...,
+        Unwrap(std::get<indices>(std::forward<BoundArgsTuple>(bound)))...,
         std::forward<UnboundArgs>(unbound_args)...);
   }
 };
 
 // Used to implement MakeUnboundRunType.
 template <typename Functor, typename... BoundArgs>
 struct MakeUnboundRunTypeImpl {
   using RunType =
       typename FunctorTraits<typename std::decay<Functor>::type>::RunType;
   using ReturnType = ExtractReturnType<RunType>;
@@ skipping 12 matching lines @@
 IsNull(const Functor&) {
   return false;
 }
 
 // Used by ApplyCancellationTraits below.
 template <typename Functor, typename BoundArgsTuple, size_t... indices>
 bool ApplyCancellationTraitsImpl(const Functor& functor,
                                  const BoundArgsTuple& bound_args,
                                  IndexSequence<indices...>) {
   return CallbackCancellationTraits<Functor, BoundArgsTuple>::IsCancelled(
-      functor, base::get<indices>(bound_args)...);
+      functor, std::get<indices>(bound_args)...);
 }
 
 // Relays |base| to corresponding CallbackCancellationTraits<>::Run(). Returns
 // true if the callback |base| represents is canceled.
 template <typename BindStateType>
 bool ApplyCancellationTraits(const BindStateBase* base) {
   const BindStateType* storage = static_cast<const BindStateType*>(base);
   static constexpr size_t num_bound_args =
       std::tuple_size<decltype(storage->bound_args_)>::value;
   return ApplyCancellationTraitsImpl(storage->functor_, storage->bound_args_,
@@ skipping 127 matching lines @@
 
 // Returns a RunType of bound functor.
 // E.g. MakeUnboundRunType<R(A, B, C), A, B> is evaluated to R(C).
 template <typename Functor, typename... BoundArgs>
 using MakeUnboundRunType =
     typename internal::MakeUnboundRunTypeImpl<Functor, BoundArgs...>::Type;
 
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_