Add another batch of GenerateTraits.

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 432 matching lines @@
         --g_depth;
         return false;
       }
       p->insert(place_holder);
     }
     --g_depth;
     return true;
   }
 };
 
+template <class A, class B, class C, class D>
+struct GenerateTraits<std::map<A, B, C, D>> {
+  static bool Generate(std::map<A, B, C, D>* p, Generator* generator) {
+    static int g_depth = 0;
+    size_t count = ++g_depth > 3 ? 0 : RandElementCount();
+    std::pair<A, B> place_holder;
+    for (size_t i = 0; i < count; ++i) {
+      if (!GenerateParam(&place_holder, generator)) {
+        --g_depth;
+        return false;
+      }
+      p->insert(place_holder);
+    }
+    --g_depth;
+    return true;
+  }
+};
+
 template <class A, class B>
 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.
@@ skipping 34 matching lines @@
   static bool Generate(base::File::Info* p, Generator* generator) {
     double last_modified;
     double last_accessed;
     double creation_time;
     if (!GenerateParam(&p->size, generator))
       return false;
     if (!GenerateParam(&p->is_directory, generator))
       return false;
     if (!GenerateParam(&last_modified, generator))
       return false;
-    if (GenerateParam(&last_accessed, generator))
+    if (!GenerateParam(&last_accessed, generator))
       return false;
-    if (GenerateParam(&creation_time, generator))
+    if (!GenerateParam(&creation_time, generator))
       return false;
     p->last_modified = base::Time::FromDoubleT(last_modified);
     p->last_accessed = base::Time::FromDoubleT(last_accessed);
     p->creation_time = base::Time::FromDoubleT(creation_time);
     return true;
   }
 };
 
 template <>
 struct GenerateTraits<base::Time> {
@@ skipping 414 matching lines @@
       case 2: {
         *p = content::IndexedDBKeyPath();
         break;
       }
     }
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<content::NPIdentifier_Param> {
+  static bool Generate(content::NPIdentifier_Param* p, Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = content::NPIdentifier_Param();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<content::NPVariant_Param> {
+  static bool Generate(content::NPVariant_Param* p, Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = content::NPVariant_Param();
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<content::PageState> {
-  static bool Generate(content::PageState *p, Generator* generator) {
+  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<content::SyntheticGesturePacket> {
+  static bool Generate(content::SyntheticGesturePacket* p,
+                       Generator* generator) {
+    scoped_ptr<content::SyntheticGestureParams> gesture_params;
+    switch (RandInRange(3)) {
+      case content::SyntheticGestureParams::GestureType::
+          SMOOTH_SCROLL_GESTURE: {
+        content::SyntheticSmoothScrollGestureParams* params =
+            new content::SyntheticSmoothScrollGestureParams();
+        if (!GenerateParam(&params->anchor, generator))
+          return false;
+        if (!GenerateParam(&params->distances, generator))
+          return false;
+        if (!GenerateParam(&params->prevent_fling, generator))
+          return false;
+        if (!GenerateParam(&params->speed_in_pixels_s, generator))
+          return false;
+        gesture_params.reset(params);
+        break;
+      }
+      case content::SyntheticGestureParams::GestureType::PINCH_GESTURE: {
+        content::SyntheticPinchGestureParams* params =
+            new content::SyntheticPinchGestureParams();
+        if (!GenerateParam(&params->scale_factor, generator))
+          return false;
+        if (!GenerateParam(&params->anchor, generator))
+          return false;
+        if (!GenerateParam(&params->relative_pointer_speed_in_pixels_s,
+                           generator))
+          return false;
+        gesture_params.reset(params);
+        break;
+      }
+      case content::SyntheticGestureParams::GestureType::TAP_GESTURE: {
+        content::SyntheticTapGestureParams* params =
+            new content::SyntheticTapGestureParams();
+        if (!GenerateParam(&params->position, generator))
+          return false;
+        if (!GenerateParam(&params->duration_ms, generator))
+          return false;
+        gesture_params.reset(params);
+        break;
+      }
+    }
+    p->set_gesture_params(gesture_params.Pass());
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<content::WebCursor> {
+  static bool Generate(content::WebCursor* p, Generator* generator) {
+    blink::WebCursorInfo::Type type;
+    if (!GenerateParam(&type, generator))
+      return false;
+    content::WebCursor::CursorInfo info(type);
+
+    // Omitting |externalHandle| since it is not serialized.
+    if (!GenerateParam(&info.hotspot, generator))
+      return false;
+    if (!GenerateParam(&info.image_scale_factor, generator))
+      return false;
+    if (!GenerateParam(&info.custom_image, generator))
+      return false;
+    *p = content::WebCursor(info);
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<ContentSettingsPattern> {
+  static bool Generate(ContentSettingsPattern* p, Generator* generator) {
+    // TODO(mbarbella): This can crash if a pattern is generated from a random
+    // string. We could carefully generate a pattern or fix pattern generation.
+    *p = ContentSettingsPattern();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<ExtensionMsg_PermissionSetStruct> {
+  static bool Generate(ExtensionMsg_PermissionSetStruct* p,
+                       Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = ExtensionMsg_PermissionSetStruct();
+    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;
-    if (!GenerateParamArray(&state.float_value[0], 4, generator))
-      return false;
-    if (!GenerateParamArray(&state.int_value[0], 4, 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))
-      return false;
-    if (!GenerateParam(&channel_layout, generator))
-      return false;
-    if (!GenerateParam(&sample_rate, generator))
-      return false;
-    if (!GenerateParam(&bits_per_sample, generator))
-      return false;
-    if (!GenerateParam(&frames_per_buffer, generator))
-      return false;
-    if (!GenerateParam(&channels, generator))
-      return false;
-    if (!GenerateParam(&effects, generator))
-      return false;
-    media::AudioParameters params(
-        static_cast<media::AudioParameters::Format>(format),
-        static_cast<media::ChannelLayout>(channel_layout),
-        channels,
-        sample_rate,
-        bits_per_sample,
-        frames_per_buffer,
-        effects);
-    *p = params;
-    return true;
-  }
-};
-
-template <>
-struct GenerateTraits<media::VideoCaptureFormat> {
-  static bool Generate(media::VideoCaptureFormat *p, Generator* generator) {
-    int frame_size_width;
-    int frame_size_height;
-    int pixel_format;
-    if (!GenerateParam(&frame_size_height, generator))
-      return false;
-    if (!GenerateParam(&frame_size_width, generator))
-      return false;
-    if (!GenerateParam(&pixel_format, generator))
-      return false;
-    if (!GenerateParam(&p->frame_rate, generator))
-      return false;
-    p->frame_size.SetSize(frame_size_width, frame_size_height);
-    p->pixel_format = static_cast<media::VideoPixelFormat>(pixel_format);
-    return true;
-  }
-};
-
-
-template <>
-struct GenerateTraits<net::LoadTimingInfo> {
-  static bool Generate(net::LoadTimingInfo *p, Generator* generator) {
-    return
-        GenerateParam(&p->socket_log_id, generator) &&
-        GenerateParam(&p->socket_reused, generator) &&
-        GenerateParam(&p->request_start_time, generator) &&
-        GenerateParam(&p->request_start, generator) &&
-        GenerateParam(&p->proxy_resolve_start, generator) &&
-        GenerateParam(&p->proxy_resolve_end, generator) &&
-        GenerateParam(&p->connect_timing.dns_start, generator) &&
-        GenerateParam(&p->connect_timing.dns_end, generator) &&
-        GenerateParam(&p->connect_timing.connect_start, generator) &&
-        GenerateParam(&p->connect_timing.connect_end, generator) &&
-        GenerateParam(&p->connect_timing.ssl_start, generator) &&
-        GenerateParam(&p->connect_timing.ssl_end, generator) &&
-        GenerateParam(&p->send_start, generator) &&
-        GenerateParam(&p->send_end, generator) &&
-        GenerateParam(&p->receive_headers_end, generator);
-  }
-};
-
-template <>
-struct GenerateTraits<net::HostPortPair> {
-  static bool Generate(net::HostPortPair *p, Generator* generator) {
-    std::string host;
-    uint16 port;
-    if (!GenerateParam(&host, generator))
-      return false;
-    if (!GenerateParam(&port, generator))
-      return false;
-    p->set_host(host);
-    p->set_port(port);
-    return true;
-  }
-};
-
-template <>
-struct GenerateTraits<net::IPEndPoint> {
-  static bool Generate(net::IPEndPoint *p, Generator* generator) {
-    net::IPAddressNumber address;
-    int port;
-    if (!GenerateParam(&address, generator))
-      return false;
-    if (!GenerateParam(&port, generator))
-      return false;
-    net::IPEndPoint ip_endpoint(address, port);
-    *p = ip_endpoint;
-    return true;
-  }
-};
-
-template <>
-struct GenerateTraits<network_hints::LookupRequest> {
-  static bool Generate(network_hints::LookupRequest* p, Generator* generator) {
-    network_hints::LookupRequest request;
-    if (!GenerateParam(&request.hostname_list, generator))
-      return false;
-    *p = request;
-    return true;
-  }
-};
 
 template <>
 struct GenerateTraits<gfx::Point> {
   static bool Generate(gfx::Point *p, Generator* generator) {
     int x;
     int y;
     if (!GenerateParam(&x, generator))
       return false;
     if (!GenerateParam(&y, generator))
       return false;
@@ skipping 124 matching lines @@
     if (!GenerateParam(&x, generator))
       return false;
     if (!GenerateParam(&y, generator))
       return false;
     *p = gfx::Vector2dF(x, y);
     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;
+    if (!GenerateParamArray(&state.float_value[0], 4, generator))
+      return false;
+    if (!GenerateParamArray(&state.int_value[0], 4, 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<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;
@@ skipping 19 matching lines @@
     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<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))
+      return false;
+    if (!GenerateParam(&channel_layout, generator))
+      return false;
+    if (!GenerateParam(&sample_rate, generator))
+      return false;
+    if (!GenerateParam(&bits_per_sample, generator))
+      return false;
+    if (!GenerateParam(&frames_per_buffer, generator))
+      return false;
+    if (!GenerateParam(&channels, generator))
+      return false;
+    if (!GenerateParam(&effects, generator))
+      return false;
+    media::AudioParameters params(
+        static_cast<media::AudioParameters::Format>(format),
+        static_cast<media::ChannelLayout>(channel_layout), channels,
+        sample_rate, bits_per_sample, frames_per_buffer, effects);
+    *p = params;
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<media::VideoCaptureFormat> {
+  static bool Generate(media::VideoCaptureFormat* p, Generator* generator) {
+    int frame_size_width;
+    int frame_size_height;
+    int pixel_format;
+    if (!GenerateParam(&frame_size_height, generator))
+      return false;
+    if (!GenerateParam(&frame_size_width, generator))
+      return false;
+    if (!GenerateParam(&pixel_format, generator))
+      return false;
+    if (!GenerateParam(&p->frame_rate, generator))
+      return false;
+    p->frame_size.SetSize(frame_size_width, frame_size_height);
+    p->pixel_format = static_cast<media::VideoPixelFormat>(pixel_format);
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<net::LoadTimingInfo> {
+  static bool Generate(net::LoadTimingInfo* p, Generator* generator) {
+    return GenerateParam(&p->socket_log_id, generator) &&
+           GenerateParam(&p->socket_reused, generator) &&
+           GenerateParam(&p->request_start_time, generator) &&
+           GenerateParam(&p->request_start, generator) &&
+           GenerateParam(&p->proxy_resolve_start, generator) &&
+           GenerateParam(&p->proxy_resolve_end, generator) &&
+           GenerateParam(&p->connect_timing.dns_start, generator) &&
+           GenerateParam(&p->connect_timing.dns_end, generator) &&
+           GenerateParam(&p->connect_timing.connect_start, generator) &&
+           GenerateParam(&p->connect_timing.connect_end, generator) &&
+           GenerateParam(&p->connect_timing.ssl_start, generator) &&
+           GenerateParam(&p->connect_timing.ssl_end, generator) &&
+           GenerateParam(&p->send_start, generator) &&
+           GenerateParam(&p->send_end, generator) &&
+           GenerateParam(&p->receive_headers_end, generator);
+  }
+};
+
+template <>
+struct GenerateTraits<net::HostPortPair> {
+  static bool Generate(net::HostPortPair* p, Generator* generator) {
+    std::string host;
+    uint16 port;
+    if (!GenerateParam(&host, generator))
+      return false;
+    if (!GenerateParam(&port, generator))
+      return false;
+    p->set_host(host);
+    p->set_port(port);
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<net::IPEndPoint> {
+  static bool Generate(net::IPEndPoint* p, Generator* generator) {
+    net::IPAddressNumber address;
+    int port;
+    if (!GenerateParam(&address, generator))
+      return false;
+    if (!GenerateParam(&port, generator))
+      return false;
+    net::IPEndPoint ip_endpoint(address, port);
+    *p = ip_endpoint;
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<network_hints::LookupRequest> {
+  static bool Generate(network_hints::LookupRequest* p, Generator* generator) {
+    network_hints::LookupRequest request;
+    if (!GenerateParam(&request.hostname_list, generator))
+      return false;
+    *p = request;
+    return true;
+  }
+};
+
 // 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;
   }
 };
 
 template <>
+struct GenerateTraits<PP_KeyInformation> {
+  static bool Generate(PP_KeyInformation* p, Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = PP_KeyInformation();
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<PP_NetAddress_Private> {
   static bool Generate(PP_NetAddress_Private *p, Generator* generator) {
     p->size = RandInRange(sizeof(p->data) + 1);
     generator->GenerateBytes(&p->data, p->size);
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<ppapi::PPB_X509Certificate_Fields> {
+  static bool Generate(ppapi::PPB_X509Certificate_Fields* p,
+                       Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params> {
+  static bool Generate(ppapi::proxy::PPBFlash_DrawGlyphs_Params* p,
+                       Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = ppapi::proxy::PPBFlash_DrawGlyphs_Params();
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<ppapi::proxy::ResourceMessageCallParams> {
   static bool Generate(
       ppapi::proxy::ResourceMessageCallParams *p, Generator* generator) {
     PP_Resource resource;
     int32_t sequence;
     bool has_callback;
     if (!GenerateParam(&resource, generator))
       return false;
     if (!GenerateParam(&sequence, generator))
       return false;
@@ skipping 19 matching lines @@
       return false;
     if (!GenerateParam(&result, generator))
       return false;
     *p = ppapi::proxy::ResourceMessageReplyParams(resource, sequence);
     p->set_result(result);
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<ppapi::proxy::SerializedHandle> {
+  static bool Generate(ppapi::proxy::SerializedHandle* p,
+                       Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = ppapi::proxy::SerializedHandle();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<ppapi::proxy::SerializedFontDescription> {
+  static bool Generate(ppapi::proxy::SerializedFontDescription* p,
+                       Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = ppapi::proxy::SerializedFontDescription();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<ppapi::proxy::SerializedTrueTypeFontDesc> {
+  static bool Generate(ppapi::proxy::SerializedTrueTypeFontDesc* p,
+                       Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = ppapi::proxy::SerializedTrueTypeFontDesc();
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<ppapi::proxy::SerializedVar> {
+  static bool Generate(ppapi::proxy::SerializedVar* p, Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    *p = ppapi::proxy::SerializedVar();
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<ppapi::HostResource> {
   static bool Generate(ppapi::HostResource *p, Generator* generator) {
     PP_Instance instance;
     PP_Resource resource;
     if (!GenerateParam(&instance, generator))
       return false;
     if (!GenerateParam(&resource, generator))
       return false;
     p->SetHostResource(instance, resource);
     return true;
@@ skipping 60 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) {
+    // TODO(mbarbella): This should actually generate something.
     *p = SkBitmap();
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<storage::DataElement> {
+  static bool Generate(storage::DataElement* p, Generator* generator) {
+    switch (RandInRange(4)) {
+      case storage::DataElement::Type::TYPE_BYTES: {
+        if (RandEvent(2)) {
+          p->SetToEmptyBytes();
+        } else {
+          // TODO(mbarbella): Occasionally send more data here.
+          char data[256];
+          int data_len = RandInRange(sizeof(data));
+          generator->GenerateBytes(&data[0], data_len);
+          p->SetToBytes(&data[0], data_len);
+        }
+        return true;
+      }
+      case storage::DataElement::Type::TYPE_FILE: {
+        base::FilePath path;
+        uint64 offset;
+        uint64 length;
+        base::Time modification_time;
+        if (!GenerateParam(&path, generator))
+          return false;
+        if (!GenerateParam(&offset, generator))
+          return false;
+        if (!GenerateParam(&length, generator))
+          return false;
+        if (!GenerateParam(&modification_time, generator))
+          return false;
+        p->SetToFilePathRange(path, offset, length, modification_time);
+        return true;
+      }
+      case storage::DataElement::Type::TYPE_BLOB: {
+        std::string uuid;
+        uint64 offset;
+        uint64 length;
+        if (!GenerateParam(&uuid, generator))
+          return false;
+        if (!GenerateParam(&offset, generator))
+          return false;
+        if (!GenerateParam(&length, generator))
+          return false;
+        p->SetToBlobRange(uuid, offset, length);
+        return true;
+      }
+      case storage::DataElement::Type::TYPE_FILE_FILESYSTEM: {
+        GURL url;
+        uint64 offset;
+        uint64 length;
+        base::Time modification_time;
+        if (!GenerateParam(&url, generator))
+          return false;
+        if (!GenerateParam(&offset, generator))
+          return false;
+        if (!GenerateParam(&length, generator))
+          return false;
+        if (!GenerateParam(&modification_time, generator))
+          return false;
+        p->SetToFileSystemUrlRange(url, offset, length, modification_time);
+        return true;
+      }
+      default: {
+        NOTREACHED();
+        return false;
+      }
+    }
+  }
+};
+
+template <>
 struct GenerateTraits<ui::LatencyInfo> {
   static bool Generate(ui::LatencyInfo* p, Generator* generator) {
     // TODO(inferno): Add param traits for |latency_components|.
     p->input_coordinates_size = static_cast<uint32>(
         RandInRange(ui::LatencyInfo::kMaxInputCoordinates + 1));
     if (!GenerateParamArray(
         &p->input_coordinates[0], p->input_coordinates_size, generator))
       return false;
     if (!GenerateParam(&p->trace_id, generator))
       return false;
@@ skipping 23 matching lines @@
   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<URLPattern> {
+  static bool Generate(URLPattern* p, Generator* generator) {
+    int valid_schemes;
+    std::string host;
+    std::string port;
+    std::string path;
+    if (!GenerateParam(&valid_schemes, generator))
+      return false;
+    if (!GenerateParam(&host, generator))
+      return false;
+    if (!GenerateParam(&port, generator))
+      return false;
+    if (!GenerateParam(&path, generator))
+      return false;
+    *p = URLPattern(valid_schemes);
+    p->SetHost(host);
+    p->SetPort(port);
+    p->SetPath(path);
+    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);
     return true;
@@ skipping 27 matching lines @@
       return false;
     if (!GenerateParam(&right, generator))
       return false;
     if (!GenerateParam(&bottom, generator))
       return false;
     *p = webrtc::DesktopRect::MakeLTRB(left, top, right, bottom);
     return true;
   }
 };
 
+template <>
+struct GenerateTraits<webrtc::MouseCursor> {
+  static bool Generate(webrtc::MouseCursor* p, Generator* generator) {
+    webrtc::DesktopVector hotspot;
+    if (!GenerateParam(&hotspot, generator))
+      return false;
+    // Using a small size here to avoid OOM or overflow on image allocation.
+    webrtc::DesktopSize size(RandInRange(100), RandInRange(100));
+    p->set_image(new webrtc::BasicDesktopFrame(size));
+    p->set_hotspot(hotspot);
+    return true;
+  }
+};
+
 // Redefine macros to generate generating from traits declarations.
 // STRUCT declarations cause corresponding STRUCT_TRAITS declarations to occur.
 #undef IPC_STRUCT_BEGIN
 #undef IPC_STRUCT_BEGIN_WITH_PARENT
 #undef IPC_STRUCT_MEMBER
 #undef IPC_STRUCT_END
 #define IPC_STRUCT_BEGIN_WITH_PARENT(struct_name, parent) \
   IPC_STRUCT_BEGIN(struct_name)
 #define IPC_STRUCT_BEGIN(struct_name) IPC_STRUCT_TRAITS_BEGIN(struct_name)
 #define IPC_STRUCT_MEMBER(type, name, ...) IPC_STRUCT_TRAITS_MEMBER(name)
@@ skipping 192 matching lines @@
     return EXIT_FAILURE;
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace ipc_fuzzer
 
 int main(int argc, char** argv) {
   return ipc_fuzzer::GenerateMain(argc, argv);
 }