Add some paramtraits to 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 643 matching lines @@
         default:
           break;
       }
     }
     --g_depth;
     return true;
   }
 };
 
 template <>
-struct GenerateTraits<GURL> {
-  static bool Generate(GURL *p, Generator* generator) {
-    const char url_chars[] = "Ahtp0:/.?+\\%&#";
-    size_t count = RandInRange(100);
-    std::string random_url;
-    for (size_t i = 0; i < count; ++i)
-      random_url += url_chars[RandInRange(sizeof(url_chars) - 1)];
-    int selector = RandInRange(10);
-    if (selector == 0)
-      random_url = std::string("http://") + random_url;
-    else if (selector == 1)
-      random_url = std::string("file://") + random_url;
-    else if (selector == 2)
-      random_url = std::string("javascript:") + random_url;
-    else if (selector == 2)
-      random_url = std::string("data:") + random_url;
-    *p = GURL(random_url);
-    return true;
-  }
-};
-
-// FIXME: Actually generate something.
-template <>
-struct GenerateTraits<SkBitmap> {
-  static bool Generate(SkBitmap* p, Generator* generator) {
-    *p = SkBitmap();
-    return true;
-  }
-};
-
-template <>
 struct GenerateTraits<cc::CompositorFrame> {
   // FIXME: this should actually generate something
   static bool Generate(cc::CompositorFrame* p, Generator* generator) {
     return true;
   }
 };
 
 template <>
 struct GenerateTraits<cc::CompositorFrameAck> {
   // FIXME: this should actually generate something
@@ skipping 115 matching lines @@
   static bool Generate(content::PageState *p, Generator* generator) {
     std::string junk;
     if (!GenerateParam(&junk, generator))
       return false;
     *p = content::PageState::CreateFromEncodedData(junk);
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<dns_prefetch::LookupRequest> {
+  static bool Generate(dns_prefetch::LookupRequest* p, Generator* generator) {
+    dns_prefetch::LookupRequest request;
+    if (!GenerateParam(&request.hostname_list, generator))
+      return false;
+    *p = request;
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<extensions::URLPatternSet> {
+  static bool Generate(extensions::URLPatternSet* p, Generator* generator) {
+    std::set<URLPattern> patterns;
+    if (!GenerateParam(&patterns, generator))
+      return false;
+    *p = extensions::URLPatternSet(patterns);
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<gpu::Mailbox> {
   static bool Generate(gpu::Mailbox *p, Generator* generator) {
     generator->GenerateBytes(p->name, sizeof(p->name));
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<gpu::MailboxHolder> {
+  static bool Generate(gpu::MailboxHolder *p, Generator* generator) {
+    gpu::Mailbox mailbox;
+    uint32_t texture_target;
+    uint32_t sync_point;
+    if (!GenerateParam(&mailbox, generator))
+      return false;
+    if (!GenerateParam(&texture_target, generator))
+      return false;
+    if (!GenerateParam(&sync_point, generator))
+      return false;
+    *p = gpu::MailboxHolder(mailbox, texture_target, sync_point);
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<gpu::ValueState> {
+  static bool Generate(gpu::ValueState* p, Generator* generator) {
+    gpu::ValueState state;
+    for (int i = 0; i < 4; i++) {
+      if (!GenerateParam(&state.float_value[i], generator))
+        return false;
+      if (!GenerateParam(&state.int_value[i], generator))
+        return false;
+    }
+    *p = state;
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<GURL> {
+  static bool Generate(GURL *p, Generator* generator) {
+    const char url_chars[] = "Ahtp0:/.?+\\%&#";
+    size_t count = RandInRange(100);
+    std::string random_url;
+    for (size_t i = 0; i < count; ++i)
+      random_url += url_chars[RandInRange(sizeof(url_chars) - 1)];
+    int selector = RandInRange(10);
+    if (selector == 0)
+      random_url = std::string("http://") + random_url;
+    else if (selector == 1)
+      random_url = std::string("file://") + random_url;
+    else if (selector == 2)
+      random_url = std::string("javascript:") + random_url;
+    else if (selector == 2)
+      random_url = std::string("data:") + random_url;
+    *p = GURL(random_url);
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<media::AudioParameters> {
   static bool Generate(media::AudioParameters *p, Generator* generator) {
     int format;
     int channel_layout;
     int sample_rate;
     int bits_per_sample;
     int frames_per_buffer;
     int channels;
     int effects;
     if (!GenerateParam(&format, generator))
@@ skipping 302 matching lines @@
     webrtc::DesktopVector vector;
     if (!GenerateParam(&size, generator))
       return false;
     if (!GenerateParam(&vector, generator))
       return false;
     *p = remoting::ScreenResolution(size, vector);
     return true;
   }
 };
 
+// FIXME: Actually generate something.
+template <>
+struct GenerateTraits<SkBitmap> {
+  static bool Generate(SkBitmap* p, Generator* generator) {
+    *p = SkBitmap();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<url::Origin> {
+  static bool Generate(url::Origin* p, Generator* generator) {
+    std::string origin;
+    if (!GenerateParam(&origin, generator))
+        return false;
+    *p = url::Origin(origin);
+    return true;
+  }
+};
+
 template <>
 struct GenerateTraits<webrtc::DesktopSize> {
   static bool Generate(webrtc::DesktopSize* p, Generator* generator) {
     int32_t width;
     int32_t height;
     if (!GenerateParam(&width, generator))
       return false;
     if (!GenerateParam(&height, generator))
       return false;
     *p = webrtc::DesktopSize(width, height);
@@ skipping 244 matching lines @@
     return EXIT_FAILURE;
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace ipc_fuzzer
 
 int main(int argc, char** argv) {
   return ipc_fuzzer::GenerateMain(argc, argv);
 }