Remove base::is_*assignable as these are now in the linux sysroot.

base/bind_unittest.cc

 // 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.
 
 #include "base/bind.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 1285 matching lines @@
   std::move(cb3).Run();
   std::move(cb5).Run();
 }
 
 TEST_F(BindTest, OnceCallback) {
   // Check if Callback variants have declarations of conversions as expected.
   // Copy constructor and assignment of RepeatingCallback.
   static_assert(std::is_constructible<
       RepeatingClosure, const RepeatingClosure&>::value,
       "RepeatingClosure should be copyable.");
-  static_assert(is_assignable<
-      RepeatingClosure, const RepeatingClosure&>::value,
+  static_assert(
+      std::is_assignable<RepeatingClosure, const RepeatingClosure&>::value,
       "RepeatingClosure should be copy-assignable.");
 
   // Move constructor and assignment of RepeatingCallback.
   static_assert(std::is_constructible<
       RepeatingClosure, RepeatingClosure&&>::value,
       "RepeatingClosure should be movable.");
-  static_assert(is_assignable<
-      RepeatingClosure, RepeatingClosure&&>::value,
-      "RepeatingClosure should be move-assignable");
+  static_assert(std::is_assignable<RepeatingClosure, RepeatingClosure&&>::value,
+                "RepeatingClosure should be move-assignable");
 
   // Conversions from OnceCallback to RepeatingCallback.
   static_assert(!std::is_constructible<
       RepeatingClosure, const OnceClosure&>::value,
       "OnceClosure should not be convertible to RepeatingClosure.");
-  static_assert(!is_assignable<
-      RepeatingClosure, const OnceClosure&>::value,
+  static_assert(
+      !std::is_assignable<RepeatingClosure, const OnceClosure&>::value,
       "OnceClosure should not be convertible to RepeatingClosure.");
 
   // Destructive conversions from OnceCallback to RepeatingCallback.
   static_assert(!std::is_constructible<
       RepeatingClosure, OnceClosure&&>::value,
       "OnceClosure should not be convertible to RepeatingClosure.");
-  static_assert(!is_assignable<
-      RepeatingClosure, OnceClosure&&>::value,
-      "OnceClosure should not be convertible to RepeatingClosure.");
+  static_assert(!std::is_assignable<RepeatingClosure, OnceClosure&&>::value,
+                "OnceClosure should not be convertible to RepeatingClosure.");
 
   // Copy constructor and assignment of OnceCallback.
   static_assert(!std::is_constructible<
       OnceClosure, const OnceClosure&>::value,
       "OnceClosure should not be copyable.");
-  static_assert(!is_assignable<
-      OnceClosure, const OnceClosure&>::value,
-      "OnceClosure should not be copy-assignable");
+  static_assert(!std::is_assignable<OnceClosure, const OnceClosure&>::value,
+                "OnceClosure should not be copy-assignable");
 
   // Move constructor and assignment of OnceCallback.
   static_assert(std::is_constructible<
       OnceClosure, OnceClosure&&>::value,
       "OnceClosure should be movable.");
-  static_assert(is_assignable<
-      OnceClosure, OnceClosure&&>::value,
-      "OnceClosure should be move-assignable.");
+  static_assert(std::is_assignable<OnceClosure, OnceClosure&&>::value,
+                "OnceClosure should be move-assignable.");
 
   // Conversions from RepeatingCallback to OnceCallback.
   static_assert(std::is_constructible<
       OnceClosure, const RepeatingClosure&>::value,
       "RepeatingClosure should be convertible to OnceClosure.");
-  static_assert(is_assignable<
-      OnceClosure, const RepeatingClosure&>::value,
-      "RepeatingClosure should be convertible to OnceClosure.");
+  static_assert(std::is_assignable<OnceClosure, const RepeatingClosure&>::value,
+                "RepeatingClosure should be convertible to OnceClosure.");
 
   // Destructive conversions from RepeatingCallback to OnceCallback.
   static_assert(std::is_constructible<
       OnceClosure, RepeatingClosure&&>::value,
       "RepeatingClosure should be convertible to OnceClosure.");
-  static_assert(is_assignable<
-      OnceClosure, RepeatingClosure&&>::value,
-      "RepeatingClosure should be covretible to OnceClosure.");
+  static_assert(std::is_assignable<OnceClosure, RepeatingClosure&&>::value,
+                "RepeatingClosure should be covretible to OnceClosure.");
 
   OnceClosure cb = BindOnce(&VoidPolymorphic<>::Run);
   std::move(cb).Run();
 
   // RepeatingCallback should be convertible to OnceCallback.
   OnceClosure cb2 = BindRepeating(&VoidPolymorphic<>::Run);
   std::move(cb2).Run();
 
   RepeatingClosure cb3 = BindRepeating(&VoidPolymorphic<>::Run);
   cb = cb3;
@@ skipping 35 matching lines @@
 
 // Test null callbacks cause a DCHECK.
 TEST(BindDeathTest, NullCallback) {
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DCHECK_DEATH(base::Bind(null_cb, 42));
 }
 
 }  // namespace
 }  // namespace base