Support C++98 std::vector in mojo surfaces code

std::vector<>::data() is a C++11 feature and not available on all
toolchains. This uses &vector[0] instead.

Review URL: https://codereview.chromium.org/393583003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@284558 0039d316-1c4b-4281-b951-d872f2087c98

mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc

@@ -4,6 +4,7 @@
 
 #include "mojo/services/public/cpp/surfaces/surfaces_type_converters.h"
 
+#include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/draw_quad.h"
@@ -16,6 +17,23 @@
 
 namespace mojo {
 
+#define ASSERT_ENUM_VALUES_EQUAL(value)                                      \
+  COMPILE_ASSERT(cc::DrawQuad::value == static_cast<cc::DrawQuad::Material>( \
+                                            surfaces::MATERIAL_##value),     \
+                 value##_enum_value_matches)
+
+ASSERT_ENUM_VALUES_EQUAL(CHECKERBOARD);
+ASSERT_ENUM_VALUES_EQUAL(DEBUG_BORDER);
+ASSERT_ENUM_VALUES_EQUAL(IO_SURFACE_CONTENT);
+ASSERT_ENUM_VALUES_EQUAL(PICTURE_CONTENT);
+ASSERT_ENUM_VALUES_EQUAL(RENDER_PASS);
+ASSERT_ENUM_VALUES_EQUAL(SOLID_COLOR);
+ASSERT_ENUM_VALUES_EQUAL(STREAM_VIDEO_CONTENT);
+ASSERT_ENUM_VALUES_EQUAL(SURFACE_CONTENT);
+ASSERT_ENUM_VALUES_EQUAL(TEXTURE_CONTENT);
+ASSERT_ENUM_VALUES_EQUAL(TILED_CONTENT);
+ASSERT_ENUM_VALUES_EQUAL(YUV_VIDEO_CONTENT);
+
 namespace {
 
 cc::SharedQuadState* ConvertToSharedQuadState(
@@ -33,11 +51,13 @@ cc::SharedQuadState* ConvertToSharedQuadState(
   return state;
 }
 
-cc::DrawQuad* ConvertToDrawQuad(const surfaces::QuadPtr& input,
-                                cc::SharedQuadState* sqs,
-                                cc::RenderPass* render_pass) {
+bool ConvertToDrawQuad(const surfaces::QuadPtr& input,
+                       cc::SharedQuadState* sqs,
+                       cc::RenderPass* render_pass) {
   switch (input->material) {
     case surfaces::MATERIAL_SOLID_COLOR: {
+      if (input->solid_color_quad_state.is_null())
+        return false;
       cc::SolidColorDrawQuad* color_quad =
           render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
       color_quad->SetAll(
@@ -48,9 +68,11 @@ cc::DrawQuad* ConvertToDrawQuad(const surfaces::QuadPtr& input,
           input->needs_blending,
           input->solid_color_quad_state->color.To<SkColor>(),
           input->solid_color_quad_state->force_anti_aliasing_off);
-      return color_quad;
+      break;
     }
     case surfaces::MATERIAL_SURFACE_CONTENT: {
+      if (input->surface_quad_state.is_null())
+        return false;
       cc::SurfaceDrawQuad* surface_quad =
           render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
       surface_quad->SetAll(
@@ -60,13 +82,17 @@ cc::DrawQuad* ConvertToDrawQuad(const surfaces::QuadPtr& input,
           input->visible_rect.To<gfx::Rect>(),
           input->needs_blending,
           input->surface_quad_state->surface.To<cc::SurfaceId>());
-      return surface_quad;
+      break;
     }
     case surfaces::MATERIAL_TEXTURE_CONTENT: {
-      cc::TextureDrawQuad* texture_quad =
-          render_pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
       surfaces::TextureQuadStatePtr& texture_quad_state =
           input->texture_quad_state;
+      if (texture_quad_state.is_null() ||
+          texture_quad_state->vertex_opacity.is_null() ||
+          texture_quad_state->background_color.is_null())
+        return false;
+      cc::TextureDrawQuad* texture_quad =
+          render_pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
       texture_quad->SetAll(
           sqs,
           input->rect.To<gfx::Rect>(),
@@ -78,14 +104,15 @@ cc::DrawQuad* ConvertToDrawQuad(const surfaces::QuadPtr& input,
           texture_quad_state->uv_top_left.To<gfx::PointF>(),
           texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
           texture_quad_state->background_color.To<SkColor>(),
-          texture_quad_state->vertex_opacity.storage().data(),
+          &texture_quad_state->vertex_opacity.storage()[0],
           texture_quad_state->flipped);
-      return texture_quad;
+      break;
     }
     default:
       NOTREACHED() << "Unsupported material " << input->material;
+      return false;
   }
-  return NULL;
+  return true;
 }
 
 }  // namespace
@@ -248,8 +275,9 @@ scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
   pass->quad_list.reserve(input->quads.size());
   for (size_t i = 0; i < input->quads.size(); ++i) {
     surfaces::QuadPtr quad = input->quads[i].Pass();
-    ConvertToDrawQuad(
-        quad, sqs_list[quad->shared_quad_state_index], pass.get());
+    if (!ConvertToDrawQuad(
+            quad, sqs_list[quad->shared_quad_state_index], pass.get()))
+      return scoped_ptr<cc::RenderPass>();
   }
   return pass.Pass();
 }
@@ -271,7 +299,8 @@ TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertFrom(
 gpu::Mailbox TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertTo(
     const surfaces::MailboxPtr& input) {
   gpu::Mailbox mailbox;
-  mailbox.SetName(input->name.storage().data());
+  if (!input->name.is_null())
+    mailbox.SetName(&input->name.storage()[0]);
   return mailbox;
 }
 
@@ -415,7 +444,10 @@ scoped_ptr<cc::CompositorFrame> ConvertTo(const surfaces::FramePtr& input) {
       input->resources.To<cc::TransferableResourceArray>();
   frame_data->render_pass_list.reserve(input->passes.size());
   for (size_t i = 0; i < input->passes.size(); ++i) {
-    frame_data->render_pass_list.push_back(ConvertTo(input->passes[i]));
+    scoped_ptr<cc::RenderPass> pass = ConvertTo(input->passes[i]);
+    if (!pass)
+      return scoped_ptr<cc::CompositorFrame>();
+    frame_data->render_pass_list.push_back(pass.Pass());
   }
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   frame->delegated_frame_data = frame_data.Pass();

mojo/services/public/cpp/surfaces/tests/surface_unittest.cc

@@ -143,6 +143,38 @@ TEST_F(SurfaceLibQuadTest, TextureQuad) {
   EXPECT_EQ(flipped, mojo_texture_state->flipped);
 }
 
+TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
+  surfaces::QuadPtr mojo_texture_quad = surfaces::Quad::New();
+  mojo_texture_quad->material = surfaces::MATERIAL_TEXTURE_CONTENT;
+  surfaces::TextureQuadStatePtr mojo_texture_state =
+      surfaces::TextureQuadState::New();
+  mojo_texture_state->background_color = surfaces::Color::New();
+  mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();
+  surfaces::PassPtr mojo_pass = surfaces::Pass::New();
+  mojo_pass->quads.push_back(mojo_texture_quad.Pass());
+  surfaces::SharedQuadStatePtr mojo_sqs = surfaces::SharedQuadState::New();
+  mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());
+
+  scoped_ptr<cc::RenderPass> pass = ConvertTo(mojo_pass.Pass());
+  EXPECT_FALSE(pass);
+}
+
+TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
+  surfaces::QuadPtr mojo_texture_quad = surfaces::Quad::New();
+  mojo_texture_quad->material = surfaces::MATERIAL_TEXTURE_CONTENT;
+  surfaces::TextureQuadStatePtr mojo_texture_state =
+      surfaces::TextureQuadState::New();
+  mojo_texture_state->vertex_opacity = mojo::Array<float>::New(4);
+  mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();
+  surfaces::PassPtr mojo_pass = surfaces::Pass::New();
+  mojo_pass->quads.push_back(mojo_texture_quad.Pass());
+  surfaces::SharedQuadStatePtr mojo_sqs = surfaces::SharedQuadState::New();
+  mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());
+
+  scoped_ptr<cc::RenderPass> pass = ConvertTo(mojo_pass.Pass());
+  EXPECT_FALSE(pass);
+}
+
 TEST(SurfaceLibTest, SharedQuadState) {
   gfx::Transform content_to_target_transform;
   content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
@@ -332,12 +364,19 @@ TEST(SurfaceLibTest, Mailbox) {
   mailbox.Generate();
 
   surfaces::MailboxPtr mojo_mailbox = surfaces::Mailbox::From(mailbox);
-  EXPECT_EQ(0, memcmp(mailbox.name, mojo_mailbox->name.storage().data(), 64));
+  EXPECT_EQ(0, memcmp(mailbox.name, &mojo_mailbox->name.storage()[0], 64));
 
   gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();
   EXPECT_EQ(mailbox, round_trip_mailbox);
 }
 
+TEST(SurfaceLibTest, MailboxEmptyName) {
+  surfaces::MailboxPtr mojo_mailbox = surfaces::Mailbox::New();
+
+  gpu::Mailbox converted_mailbox = mojo_mailbox.To<gpu::Mailbox>();
+  EXPECT_TRUE(converted_mailbox.IsZero());
+}
+
 TEST(SurfaceLibTest, MailboxHolder) {
   gpu::Mailbox mailbox;
   mailbox.Generate();