Add param trait for IPC::Message in ipc fuzzer.

tools/ipc_fuzzer/mutate/generate.cc

 // Copyright 2013 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 <stdlib.h>
 
 #include <algorithm>
 #include <iostream>
 #include <ostream>
 #include <set>
@@ skipping 55 matching lines @@
   virtual void GenerateInt64(int64* value) = 0;
   virtual void GenerateUInt64(uint64* value) = 0;
   virtual void GenerateFloat(float *value) = 0;
   virtual void GenerateDouble(double *value) = 0;
   virtual void GenerateString(std::string* value) = 0;
   virtual void GenerateString16(base::string16* value) = 0;
   virtual void GenerateData(char* data, int length) = 0;
   virtual void GenerateBytes(void* data, int data_len) = 0;
 };
 
+typedef IPC::Message* (*GeneratorFunction)(Generator*);
+typedef std::vector<GeneratorFunction> GeneratorFunctionVector;
+GeneratorFunctionVector g_function_vector;
+
 template <typename T>
 void GenerateIntegralType(T* value) {
   switch (RandInRange(16)) {
     case 0:
       *value = static_cast<T>(0);
       break;
     case 1:
       *value = static_cast<T>(1);
       break;
     case 2:
@@ skipping 364 matching lines @@
 struct GenerateTraits<std::pair<A, B> > {
   static bool Generate(std::pair<A, B>* p, Generator* generator) {
     return
         GenerateParam(&p->first, generator) &&
         GenerateParam(&p->second, generator);
   }
 };
 
 // Specializations to generate hand-coded types.
 template <>
-struct GenerateTraits<IPC::PlatformFileForTransit> {
-  static bool Generate(IPC::PlatformFileForTransit* p, Generator* generator) {
-    // TODO(inferno): I don't think we can generate real ones due to check on
-    // construct.
-    *p = IPC::InvalidPlatformFileForTransit();
-    return true;
-  }
-};
-
-template <>
-struct GenerateTraits<IPC::ChannelHandle> {
-  static bool Generate(IPC::ChannelHandle* p, Generator* generator) {
-    // TODO(inferno): Add way to generate real channel handles.
-#if defined(OS_WIN)
-    HANDLE fake_handle = (HANDLE)(RandU64());
-    p->pipe = IPC::ChannelHandle::PipeHandle(fake_handle);
-    return true;
-#elif defined(OS_POSIX)
-    return
-        GenerateParam(&p->name, generator) &&
-        GenerateParam(&p->socket, generator);
-#endif
-  }
-};
-
-template <>
 struct GenerateTraits<base::NullableString16> {
   static bool Generate(base::NullableString16* p, Generator* generator) {
     *p = base::NullableString16();
     return true;
   }
 };
 
 template <>
 struct GenerateTraits<base::FilePath> {
   static bool Generate(base::FilePath* p, Generator* generator) {
@@ skipping 681 matching lines @@
     float y;
     if (!GenerateParam(&x, generator))
       return false;
     if (!GenerateParam(&y, generator))
       return false;
     *p = gfx::Vector2dF(x, y);
     return true;
   }
 };
 
+template <>
+struct GenerateTraits<IPC::Message> {
+  static bool Generate(IPC::Message *p, Generator* generator) {
+    if (g_function_vector.empty())
+      return false;
+    size_t index = RandInRange(g_function_vector.size());
+    IPC::Message* ipc_message = (*g_function_vector[index])(generator);
+    if (!ipc_message)
+      return false;
+    p = ipc_message;
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<IPC::PlatformFileForTransit> {
+  static bool Generate(IPC::PlatformFileForTransit* p, Generator* generator) {
+    // TODO(inferno): I don't think we can generate real ones due to check on
+    // construct.
+    *p = IPC::InvalidPlatformFileForTransit();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<IPC::ChannelHandle> {
+  static bool Generate(IPC::ChannelHandle* p, Generator* generator) {
+    // TODO(inferno): Add way to generate real channel handles.
+#if defined(OS_WIN)
+    HANDLE fake_handle = (HANDLE)(RandU64());
+    p->pipe = IPC::ChannelHandle::PipeHandle(fake_handle);
+    return true;
+#elif defined(OS_POSIX)
+    return
+      GenerateParam(&p->name, generator) &&
+      GenerateParam(&p->socket, generator);
+#endif
+  }
+};
+
 // PP_ traits.
 template <>
 struct GenerateTraits<PP_Bool> {
   static bool Generate(PP_Bool *p, Generator* generator) {
     bool tmp;
     if (!GenerateParam(&tmp, generator))
       return false;
     *p = PP_FromBool(tmp);
     return true;
   }
@@ skipping 365 matching lines @@
 #define IPC_MEMBERS_OUT_0()
 #define IPC_MEMBERS_OUT_1() NULL
 #define IPC_MEMBERS_OUT_2() NULL, NULL
 #define IPC_MEMBERS_OUT_3() NULL, NULL, NULL
 #define IPC_MEMBERS_OUT_4() NULL, NULL, NULL, NULL
 #define IPC_MEMBERS_OUT_5() NULL, NULL, NULL, NULL, NULL
 
 #include "tools/ipc_fuzzer/message_lib/all_messages.h"
 #include "ipc/ipc_message_null_macros.h"
 
-typedef IPC::Message* (*GeneratorFunction)(Generator*);
-typedef std::vector<GeneratorFunction> GeneratorFunctionVector;
-
 void PopulateGeneratorFunctionVector(
     GeneratorFunctionVector *function_vector) {
 #undef IPC_MESSAGE_DECL
 #define IPC_MESSAGE_DECL(kind, type, name, in, out, ilist, olist) \
   function_vector->push_back(generator_for_##name);
 #include "tools/ipc_fuzzer/message_lib/all_messages.h"
 }
 
 static const char kCountSwitch[] = "count";
 static const char kHelpSwitch[] = "help";
 
 int GenerateMain(int argc, char** argv) {
   base::CommandLine::Init(argc, argv);
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
   base::CommandLine::StringVector args = cmd->GetArgs();
 
   if (args.size() != 1 || cmd->HasSwitch(kHelpSwitch)) {
     std::cerr << "Usage: ipc_fuzzer_generate [--help] [--count=n] outfile\n";
     return EXIT_FAILURE;
   }
   base::FilePath::StringType output_file_name = args[0];
 
   int message_count = 1000;
   if (cmd->HasSwitch(kCountSwitch))
     message_count = atoi(cmd->GetSwitchValueASCII(kCountSwitch).c_str());
 
   InitRand();
 
-  GeneratorFunctionVector function_vector;
-  PopulateGeneratorFunctionVector(&function_vector);
-  std::cerr << "Counted " << function_vector.size()
+  PopulateGeneratorFunctionVector(&g_function_vector);
+  std::cerr << "Counted " << g_function_vector.size()
             << " distinct messages present in chrome.\n";
 
   Generator* generator = new GeneratorImpl();
   MessageVector message_vector;
 
   int bad_count = 0;
   if (message_count < 0) {
     // Enumerate them all.
-    for (size_t i = 0; i < function_vector.size(); ++i) {
-      if (IPC::Message* new_message = (*function_vector[i])(generator))
+    for (size_t i = 0; i < g_function_vector.size(); ++i) {
+      if (IPC::Message* new_message = (*g_function_vector[i])(generator))
         message_vector.push_back(new_message);
       else
         bad_count += 1;
     }
   } else {
     // Generate a random batch.
     for (int i = 0; i < message_count; ++i) {
-      size_t index = RandInRange(function_vector.size());
-      if (IPC::Message* new_message = (*function_vector[index])(generator))
+      size_t index = RandInRange(g_function_vector.size());
+      if (IPC::Message* new_message = (*g_function_vector[index])(generator))
         message_vector.push_back(new_message);
       else
         bad_count += 1;
     }
   }
 
   std::cerr << "Failed to generate " << bad_count << " messages.\n";
 
   if (!MessageFile::Write(base::FilePath(output_file_name), message_vector))
     return EXIT_FAILURE;
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace ipc_fuzzer
 
 int main(int argc, char** argv) {
   return ipc_fuzzer::GenerateMain(argc, argv);
 }