Remove base::Tuple

tools/ipc_fuzzer/fuzzer/fuzzer.cc

 // Copyright 2015 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 <iostream>
 #include <set>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/shared_memory_handle.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_switches.h"
@@ skipping 187 matching lines @@
 template <>
 struct FuzzTraits<base::string16> {
   static bool Fuzz(base::string16* p, Fuzzer* fuzzer) {
     fuzzer->FuzzString16(p);
     return true;
   }
 };
 
 // Specializations for tuples.
 template <>
-struct FuzzTraits<base::Tuple<>> {
-  static bool Fuzz(base::Tuple<>* p, Fuzzer* fuzzer) {
-    return true;
-  }
+struct FuzzTraits<std::tuple<>> {
+  static bool Fuzz(std::tuple<>* p, Fuzzer* fuzzer) { return true; }
 };
 
 template <class A>
-struct FuzzTraits<base::Tuple<A>> {
-  static bool Fuzz(base::Tuple<A>* p, Fuzzer* fuzzer) {
-    return FuzzParam(&base::get<0>(*p), fuzzer);
+struct FuzzTraits<std::tuple<A>> {
+  static bool Fuzz(std::tuple<A>* p, Fuzzer* fuzzer) {
+    return FuzzParam(&std::get<0>(*p), fuzzer);
   }
 };
 
 template <class A, class B>
-struct FuzzTraits<base::Tuple<A, B>> {
-  static bool Fuzz(base::Tuple<A, B>* p, Fuzzer* fuzzer) {
-    return
-        FuzzParam(&base::get<0>(*p), fuzzer) &&
-        FuzzParam(&base::get<1>(*p), fuzzer);
+struct FuzzTraits<std::tuple<A, B>> {
+  static bool Fuzz(std::tuple<A, B>* p, Fuzzer* fuzzer) {
+    return FuzzParam(&std::get<0>(*p), fuzzer) &&
+           FuzzParam(&std::get<1>(*p), fuzzer);
   }
 };
 
 template <class A, class B, class C>
-struct FuzzTraits<base::Tuple<A, B, C>> {
-  static bool Fuzz(base::Tuple<A, B, C>* p, Fuzzer* fuzzer) {
-    return
-        FuzzParam(&base::get<0>(*p), fuzzer) &&
-        FuzzParam(&base::get<1>(*p), fuzzer) &&
-        FuzzParam(&base::get<2>(*p), fuzzer);
+struct FuzzTraits<std::tuple<A, B, C>> {
+  static bool Fuzz(std::tuple<A, B, C>* p, Fuzzer* fuzzer) {
+    return FuzzParam(&std::get<0>(*p), fuzzer) &&
+           FuzzParam(&std::get<1>(*p), fuzzer) &&
+           FuzzParam(&std::get<2>(*p), fuzzer);
   }
 };
 
 template <class A, class B, class C, class D>
-struct FuzzTraits<base::Tuple<A, B, C, D>> {
-  static bool Fuzz(base::Tuple<A, B, C, D>* p, Fuzzer* fuzzer) {
-    return
-        FuzzParam(&base::get<0>(*p), fuzzer) &&
-        FuzzParam(&base::get<1>(*p), fuzzer) &&
-        FuzzParam(&base::get<2>(*p), fuzzer) &&
-        FuzzParam(&base::get<3>(*p), fuzzer);
+struct FuzzTraits<std::tuple<A, B, C, D>> {
+  static bool Fuzz(std::tuple<A, B, C, D>* p, Fuzzer* fuzzer) {
+    return FuzzParam(&std::get<0>(*p), fuzzer) &&
+           FuzzParam(&std::get<1>(*p), fuzzer) &&
+           FuzzParam(&std::get<2>(*p), fuzzer) &&
+           FuzzParam(&std::get<3>(*p), fuzzer);
   }
 };
 
 template <class A, class B, class C, class D, class E>
-struct FuzzTraits<base::Tuple<A, B, C, D, E>> {
-  static bool Fuzz(base::Tuple<A, B, C, D, E>* p, Fuzzer* fuzzer) {
-    return
-        FuzzParam(&base::get<0>(*p), fuzzer) &&
-        FuzzParam(&base::get<1>(*p), fuzzer) &&
-        FuzzParam(&base::get<2>(*p), fuzzer) &&
-        FuzzParam(&base::get<3>(*p), fuzzer) &&
-        FuzzParam(&base::get<4>(*p), fuzzer);
+struct FuzzTraits<std::tuple<A, B, C, D, E>> {
+  static bool Fuzz(std::tuple<A, B, C, D, E>* p, Fuzzer* fuzzer) {
+    return FuzzParam(&std::get<0>(*p), fuzzer) &&
+           FuzzParam(&std::get<1>(*p), fuzzer) &&
+           FuzzParam(&std::get<2>(*p), fuzzer) &&
+           FuzzParam(&std::get<3>(*p), fuzzer) &&
+           FuzzParam(&std::get<4>(*p), fuzzer);
   }
 };
 
 // Specializations for containers.
 template <class A>
 struct FuzzTraits<std::vector<A> > {
   static bool Fuzz(std::vector<A>* p, Fuzzer* fuzzer) {
     ++g_depth;
     size_t count = p->size();
     if (fuzzer->ShouldGenerate()) {
@@ skipping 1685 matching lines @@
   template <typename... Args>
   static Message* New(const Args&... args) {
     return new Message(RandInRange(MAX_FAKE_ROUTING_ID), args...);
   }
 };
 
 template <typename Message>
 class FuzzerHelper;
 
 template <typename Meta, typename... Ins>
-class FuzzerHelper<IPC::MessageT<Meta, base::Tuple<Ins...>, void>> {
+class FuzzerHelper<IPC::MessageT<Meta, std::tuple<Ins...>, void>> {
  public:
-  using Message = IPC::MessageT<Meta, base::Tuple<Ins...>, void>;
+  using Message = IPC::MessageT<Meta, std::tuple<Ins...>, void>;
 
   static IPC::Message* Fuzz(IPC::Message* msg, Fuzzer* fuzzer) {
     return FuzzImpl(msg, fuzzer, base::MakeIndexSequence<sizeof...(Ins)>());
   }
 
  private:
   template <size_t... Ns>
   static IPC::Message* FuzzImpl(IPC::Message* msg,
                                 Fuzzer* fuzzer,
                                 base::IndexSequence<Ns...>) {
     typename Message::Param p;
     if (msg) {
       Message::Read(static_cast<Message*>(msg), &p);
     }
     if (FuzzParam(&p, fuzzer)) {
-      return MessageFactory<Message, Meta::kKind>::New(base::get<Ns>(p)...);
+      return MessageFactory<Message, Meta::kKind>::New(std::get<Ns>(p)...);
     }
     std::cerr << "Don't know how to handle " << Meta::kName << "\n";
     return nullptr;
   }
 };
 
 template <typename Meta, typename... Ins, typename... Outs>
 class FuzzerHelper<
-    IPC::MessageT<Meta, base::Tuple<Ins...>, base::Tuple<Outs...>>> {
+    IPC::MessageT<Meta, std::tuple<Ins...>, std::tuple<Outs...>>> {
  public:
-  using Message =
-      IPC::MessageT<Meta, base::Tuple<Ins...>, base::Tuple<Outs...>>;
+  using Message = IPC::MessageT<Meta, std::tuple<Ins...>, std::tuple<Outs...>>;
 
   static IPC::Message* Fuzz(IPC::Message* msg, Fuzzer* fuzzer) {
     return FuzzImpl(msg, fuzzer, base::MakeIndexSequence<sizeof...(Ins)>());
   }
 
  private:
   template <size_t... Ns>
   static IPC::Message* FuzzImpl(IPC::Message* msg,
                                 Fuzzer* fuzzer,
                                 base::IndexSequence<Ns...>) {
     typename Message::SendParam p;
     Message* real_msg = static_cast<Message*>(msg);
     Message* new_msg = nullptr;
     if (real_msg) {
       Message::ReadSendParam(real_msg, &p);
     }
     if (FuzzParam(&p, fuzzer)) {
       new_msg = MessageFactory<Message, Meta::kKind>::New(
-          base::get<Ns>(p)..., static_cast<Outs*>(nullptr)...);
+          std::get<Ns>(p)..., static_cast<Outs*>(nullptr)...);
     }
     if (real_msg && new_msg) {
       MessageCracker::CopyMessageID(new_msg, real_msg);
     } else if (!new_msg) {
       std::cerr << "Don't know how to handle " << Meta::kName << "\n";
     }
     return new_msg;
   }
 };
 
@@ skipping 11 matching lines @@
 #include "tools/ipc_fuzzer/message_lib/all_message_null_macros.h"
 #undef IPC_MESSAGE_DECL
 #define IPC_MESSAGE_DECL(name, ...) \
   (*map)[static_cast<uint32_t>(name::ID)] = FuzzerHelper<name>::Fuzz;
 
 void PopulateFuzzerFunctionMap(FuzzerFunctionMap* map) {
 #include "tools/ipc_fuzzer/message_lib/all_messages.h"
 }
 
 }  // namespace ipc_fuzzer