Add IPC fuzzer GenerateTraits for some cc types.

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 382 matching lines @@
         GenerateParam(&get<2>(*p), generator) &&
         GenerateParam(&get<3>(*p), generator) &&
         GenerateParam(&get<4>(*p), generator);
   }
 };
 
 // Specializations to generate containers.
 template <class A>
 struct GenerateTraits<std::vector<A> > {
   static bool Generate(std::vector<A>* p, Generator* generator) {
-    size_t count = ++g_depth > 3 ? 0 : RandInRange(20);
+    size_t count = ++g_depth > 3 ? 0 : RandElementCount();
     p->resize(count);
     for (size_t i = 0; i < count; ++i) {
       if (!GenerateParam(&p->at(i), generator)) {
         --g_depth;
         return false;
       }
     }
     --g_depth;
     return true;
   }
 };
 
 template <class A>
 struct GenerateTraits<std::set<A> > {
   static bool Generate(std::set<A>* p, Generator* generator) {
     static int g_depth = 0;
-    size_t count = ++g_depth > 3 ? 0 : RandInRange(20);
+    size_t count = ++g_depth > 3 ? 0 : RandElementCount();
     A a;
     for (size_t i = 0; i < count; ++i) {
       if (!GenerateParam(&a, generator)) {
         --g_depth;
         return false;
       }
       p->insert(a);
     }
     --g_depth;
     return true;
   }
 };
 
 
 template <class A, class B>
 struct GenerateTraits<std::map<A, B> > {
   static bool Generate(std::map<A, B>* p, Generator* generator) {
     static int g_depth = 0;
-    size_t count = ++g_depth > 3 ? 0 : RandInRange(10);
+    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;
@@ skipping 252 matching lines @@
       return false;
     if (!GenerateParam(&value, generator))
       return false;
     *p = blink::WebGamepadButton(pressed, value);
     return true;
   }
 };
 
 template <>
 struct GenerateTraits<cc::CompositorFrame> {
-  // FIXME: this should actually generate something
   static bool Generate(cc::CompositorFrame* p, Generator* generator) {
+    if (!GenerateParam(&p->metadata, generator))
+      return false;
+    switch (RandInRange(4)) {
+      case 0: {
+        p->delegated_frame_data.reset(new cc::DelegatedFrameData());
+        if (!GenerateParam(p->delegated_frame_data.get(), generator))
+          return false;
+        return true;
+      }
+      case 1: {
+        p->gl_frame_data.reset(new cc::GLFrameData());
+        if (!GenerateParam(p->gl_frame_data.get(), generator))
+          return false;
+        return true;
+      }
+      case 2: {
+        p->software_frame_data.reset(new cc::SoftwareFrameData());
+        if (!GenerateParam(p->software_frame_data.get(), generator))
+          return false;
+        return true;
+      }
+      default:
+        // Generate nothing to handle the no frame case.
+        return true;
+    }
+  }
+};
+
+template <>
+struct GenerateTraits<cc::CompositorFrameAck> {
+  static bool Generate(cc::CompositorFrameAck* p, Generator* generator) {
+    if (!GenerateParam(&p->resources, generator))
+      return false;
+    if (!GenerateParam(&p->last_software_frame_id, generator))
+      return false;
+    p->gl_frame_data.reset(new cc::GLFrameData);
+    if (!GenerateParam(p->gl_frame_data.get(), generator))
+      return false;
     return true;
   }
 };
 
 template <>
-struct GenerateTraits<cc::CompositorFrameAck> {
-  // FIXME: this should actually generate something
-  static bool Generate(cc::CompositorFrameAck* p, Generator* generator) {
+struct GenerateTraits<cc::DelegatedFrameData> {
+  static bool Generate(cc::DelegatedFrameData* p, Generator* generator) {
+    if (!GenerateParam(&p->device_scale_factor, generator))
+      return false;
+    if (!GenerateParam(&p->resource_list, generator))
+      return false;
+    if (!GenerateParam(&p->render_pass_list, generator))
+      return false;
     return true;
   }
 };
+
+template <class A>
+struct GenerateTraits<cc::ListContainer<A>> {
+  static bool Generate(cc::ListContainer<A>* p, Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<cc::QuadList> {
+  static bool Generate(cc::QuadList* p, Generator* generator) {
+    // TODO(mbarbella): This should actually generate something.
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<cc::RenderPass> {
+  static bool Generate(cc::RenderPass* p, Generator* generator) {
+    if (!GenerateParam(&p->id, generator))
+      return false;
+    if (!GenerateParam(&p->output_rect, generator))
+      return false;
+    if (!GenerateParam(&p->damage_rect, generator))
+      return false;
+    if (!GenerateParam(&p->transform_to_root_target, generator))
+      return false;
+    if (!GenerateParam(&p->has_transparent_background, generator))
+      return false;
+    if (!GenerateParam(&p->quad_list, generator))
+      return false;
+    if (!GenerateParam(&p->shared_quad_state_list, generator))
+      return false;
+    // Omitting |copy_requests| as it is not sent over IPC.
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<cc::RenderPassList> {
+  static bool Generate(cc::RenderPassList* p, Generator* generator) {
+    size_t count = RandElementCount();
+    for (size_t i = 0; i < count; ++i) {
+      scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+      if (!GenerateParam(render_pass.get(), generator))
+        return false;
+      p->push_back(render_pass.Pass());
+    }
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<cc::SoftwareFrameData> {
+  static bool Generate(cc::SoftwareFrameData* p, Generator* generator) {
+    if (!GenerateParam(&p->id, generator))
+      return false;
+    if (!GenerateParam(&p->size, generator))
+      return false;
+    if (!GenerateParam(&p->damage_rect, generator))
+      return false;
+    if (!GenerateParam(&p->bitmap_id, generator))
+      return false;
+    return true;
+  }
+};
 
 template <>
 struct GenerateTraits<content::IndexedDBKey> {
   static bool Generate(content::IndexedDBKey* p, Generator* generator) {
     ++g_depth;
     blink::WebIDBKeyType web_type =
         static_cast<blink::WebIDBKeyType>(RandInRange(7));
     switch (web_type)
     {
       case blink::WebIDBKeyTypeArray: {
@@ skipping 321 matching lines @@
     if (!GenerateParam(&x, generator))
       return false;
     if (!GenerateParam(&y, generator))
       return false;
     p->SetPoint(x, y);
     return true;
   }
 };
 
 template <>
-struct GenerateTraits<gfx::Size> {
-  static bool Generate(gfx::Size *p, Generator* generator) {
-    int w;
-    int h;
-    if (!GenerateParam(&w, generator))
-      return false;
-    if (!GenerateParam(&h, generator))
-      return false;
-    p->SetSize(w, h);
-    return true;
-  }
-};
-
-template <>
-struct GenerateTraits<gfx::SizeF> {
-  static bool Generate(gfx::SizeF *p, Generator* generator) {
-    float w;
-    float h;
-    if (!GenerateParam(&w, generator))
-      return false;
-    if (!GenerateParam(&h, generator))
-      return false;
-    p->SetSize(w, h);
-    return true;
-  }
-};
-
-template <>
 struct GenerateTraits<gfx::Rect> {
   static bool Generate(gfx::Rect *p, Generator* generator) {
     gfx::Point origin;
     gfx::Size  size;
     if (!GenerateParam(&origin, generator))
       return false;
     if (!GenerateParam(&size, generator))
       return false;
     p->set_origin(origin);
     p->set_size(size);
@@ skipping 24 matching lines @@
     if (!GenerateParam(&start, generator))
       return false;
     if (!GenerateParam(&end, generator))
       return false;
     *p = gfx::Range(start, end);
     return true;
   }
 };
 
 template <>
+struct GenerateTraits<gfx::Size> {
+  static bool Generate(gfx::Size* p, Generator* generator) {
+    int w;
+    int h;
+    if (!GenerateParam(&w, generator))
+      return false;
+    if (!GenerateParam(&h, generator))
+      return false;
+    p->SetSize(w, h);
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<gfx::SizeF> {
+  static bool Generate(gfx::SizeF* p, Generator* generator) {
+    float w;
+    float h;
+    if (!GenerateParam(&w, generator))
+      return false;
+    if (!GenerateParam(&h, generator))
+      return false;
+    p->SetSize(w, h);
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<gfx::Transform> {
+  static bool Generate(gfx::Transform* p, Generator* generator) {
+    SkMScalar matrix[16];
+    if (!GenerateParamArray(&matrix[0], arraysize(matrix), generator))
+      return false;
+    *p = gfx::Transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4],
+                        matrix[5], matrix[6], matrix[7], matrix[8], matrix[9],
+                        matrix[10], matrix[11], matrix[12], matrix[13],
+                        matrix[14], matrix[15]);
+    return true;
+  }
+};
+
+template <>
 struct GenerateTraits<gfx::Vector2d> {
   static bool Generate(gfx::Vector2d *p, Generator* generator) {
     int x;
     int y;
     if (!GenerateParam(&x, generator))
       return false;
     if (!GenerateParam(&y, generator))
       return false;
     *p = gfx::Vector2d(x, y);
     return true;
@@ skipping 500 matching lines @@
     return EXIT_FAILURE;
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace ipc_fuzzer
 
 int main(int argc, char** argv) {
   return ipc_fuzzer::GenerateMain(argc, argv);
 }