IPC pickling optimization for render passes.

content/common/cc_messages_unittest.cc

 // Copyright (c) 2012 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 "content/common/cc_messages.h"
 
 #include <string.h>
 
+#include <algorithm>
+
 #include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 
 using cc::CheckerboardDrawQuad;
 using cc::DelegatedFrameData;
@@ skipping 529 matching lines @@
   DelegatedFrameData frame_out;
   PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
       &iter, &frame_out));
 
   ASSERT_EQ(2u, frame_out.resource_list.size());
   Compare(arbitrary_resource1, frame_out.resource_list[0]);
   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 }
 
+TEST_F(CCMessagesTest, LargestQuadType) {
+  size_t largest = 0;
+
+  bool done = false;
+  for (int i = 0; !done; ++i) {
+    switch (static_cast<DrawQuad::Material>(i)) {
+      case cc::DrawQuad::CHECKERBOARD:
+        largest = std::max(largest, sizeof(cc::CheckerboardDrawQuad));
+        break;
+      case cc::DrawQuad::DEBUG_BORDER:
+        largest = std::max(largest, sizeof(cc::DebugBorderDrawQuad));
+        break;
+      case cc::DrawQuad::IO_SURFACE_CONTENT:
+        largest = std::max(largest, sizeof(cc::IOSurfaceDrawQuad));
+        break;
+      case cc::DrawQuad::PICTURE_CONTENT:
+        largest = std::max(largest, sizeof(cc::PictureDrawQuad));
+        break;
+      case cc::DrawQuad::TEXTURE_CONTENT:
+        largest = std::max(largest, sizeof(cc::TextureDrawQuad));
+        break;
+      case cc::DrawQuad::RENDER_PASS:
+        largest = std::max(largest, sizeof(cc::RenderPassDrawQuad));
+        break;
+      case cc::DrawQuad::SOLID_COLOR:
+        largest = std::max(largest, sizeof(cc::SolidColorDrawQuad));
+        break;
+      case cc::DrawQuad::TILED_CONTENT:
+        largest = std::max(largest, sizeof(cc::TileDrawQuad));
+        break;
+      case cc::DrawQuad::STREAM_VIDEO_CONTENT:
+        largest = std::max(largest, sizeof(cc::StreamVideoDrawQuad));
+        break;
+      case cc::DrawQuad::YUV_VIDEO_CONTENT:
+        largest = std::max(largest, sizeof(cc::YUVVideoDrawQuad));
+        break;
+      case cc::DrawQuad::INVALID:
+        break;
+      default:
+        done = true;
+    }
+  }
+
+  // Verify the largest DrawQuad type is RenderPassDrawQuad. If this ever
+  // changes, then the ParamTraits<cc::RenderPass>::ReserveSizeForWrite() method
+  // needs to be updated as well to use the new largest quad.
+  EXPECT_EQ(sizeof(RenderPassDrawQuad), largest);

[Tom Sepez, 2013/10/24 17:48:06]

Create a union consisting of all these types, and use sizeof() on it to get the
biggest size. 

[danakj, 2013/10/24 17:51:38]

That does not create a compiler error, however, if a new type is added, which
was my goal here.

+}
+
 }  // namespace
 }  // namespace content