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 691 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;
+    p->delegated_frame_data.reset(new cc::DelegatedFrameData);

[inferno, 2015/01/28 22:44:36]

empty constructor for clarity everywhere
s/p->delegated_frame_data.reset(new
cc::DelegatedFrameData)/p->delegated_frame_data.reset(new
cc::DelegatedFrameData())

[inferno, 2015/01/28 22:44:36]

Should we be generating all of these three at once or just one out of three -
https://code.google.com/p/chromium/codesearch#chromium/src/content/common/cc_...

[Martin Barbella, 2015/01/28 23:03:59]

Yeah, it looks like we should only be generating one here.

[Martin Barbella, 2015/01/28 23:32:59]

Both comments addressed.

+    if (!GenerateParam(p->delegated_frame_data.get(), generator))
+      return false;
+    p->gl_frame_data.reset(new cc::GLFrameData);
+    if (!GenerateParam(p->gl_frame_data.get(), generator))
+      return false;
+    p->software_frame_data.reset(new cc::SoftwareFrameData);
+    if (!GenerateParam(p->software_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) {
+    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::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) {
+    // FIXME(mbarbella): This should actually generate something.

[Tom Sepez, 2015/01/28 22:58:09]

nit: style guide says TODO(mbarbella): ..

[Martin Barbella, 2015/01/28 23:32:59]

Done.

+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<cc::QuadList> {
+  static bool Generate(cc::QuadList* p, Generator* generator) {
+    // FIXME(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))

[inferno, 2015/01/28 22:44:36]

please add fixme for
https://code.google.com/p/chromium/codesearch#chromium/src/cc/quads/render_pa...
 ScopedPtrVector<CopyOutputRequest> copy_requests;

[Martin Barbella, 2015/01/28 23:03:59]

I didn't add it because it doesn't seem to be getting written. Should I just add
a comment here to mention it?

https://code.google.com/p/chromium/codesearch#chromium/src/content/common/cc_...

[Martin Barbella, 2015/01/28 23:32:59]

Left a comment here. Could you take a look to make sure I'm not missing
something here, though?

+      return false;
+    if (!GenerateParam(&p->shared_quad_state_list, generator))
+      return false;
+    return true;
+  }
+};
+
+template <>
+struct GenerateTraits<cc::RenderPassList> {
+  static bool Generate(cc::RenderPassList* p, Generator* generator) {
+    size_t count = RandInRange(5);

[inferno, 2015/01/28 22:44:36]

Why just 5 ? lets probably put that 10 we use other places in a global and use
it everywhere.

[Martin Barbella, 2015/01/28 23:32:59]

Done.

+    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);
 }