Change mojo enums to be scoped enums in the generated C++ bindings.

mojo/converters/surfaces/tests/surface_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "cc/quads/debug_border_draw_quad.h"
@@ skipping 102 matching lines @@
   color_quad->SetAll(sqs,
                      rect,
                      opaque_rect,
                      visible_rect,
                      needs_blending,
                      arbitrary_color,
                      force_anti_aliasing_off);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*color_quad);
   ASSERT_FALSE(mus_quad.is_null());
-  EXPECT_EQ(mus::mojom::MATERIAL_SOLID_COLOR, mus_quad->material);
+  EXPECT_EQ(mus::mojom::Material::SOLID_COLOR, mus_quad->material);
   EXPECT_TRUE(Rect::From(rect).Equals(mus_quad->rect));
   EXPECT_TRUE(Rect::From(opaque_rect).Equals(mus_quad->opaque_rect));
   EXPECT_TRUE(Rect::From(visible_rect).Equals(mus_quad->visible_rect));
   EXPECT_EQ(needs_blending, mus_quad->needs_blending);
   ASSERT_TRUE(mus_quad->solid_color_quad_state);
   SolidColorQuadStatePtr& mus_color_state = mus_quad->solid_color_quad_state;
   EXPECT_TRUE(Color::From(arbitrary_color).Equals(mus_color_state->color));
   EXPECT_EQ(force_anti_aliasing_off, mus_color_state->force_anti_aliasing_off);
 }
 
 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
   cc::SurfaceDrawQuad* surface_quad =
       pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
   cc::SurfaceId arbitrary_id(5);
   surface_quad->SetAll(
       sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*surface_quad);
   ASSERT_FALSE(mus_quad.is_null());
-  EXPECT_EQ(mus::mojom::MATERIAL_SURFACE_CONTENT, mus_quad->material);
+  EXPECT_EQ(mus::mojom::Material::SURFACE_CONTENT, mus_quad->material);
   ASSERT_TRUE(mus_quad->surface_quad_state);
   SurfaceQuadStatePtr& mus_surface_state = mus_quad->surface_quad_state;
   EXPECT_TRUE(SurfaceId::From(arbitrary_id).Equals(mus_surface_state->surface));
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuad) {
   cc::TextureDrawQuad* texture_quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   unsigned resource_id = 9;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(1.7f, 2.1f);
   gfx::PointF uv_bottom_right(-7.f, 16.3f);
   SkColor background_color = SK_ColorYELLOW;
   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
   bool y_flipped = false;
   bool nearest_neighbor = false;
   texture_quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
                        resource_id, gfx::Size(), premultiplied_alpha,
                        uv_top_left, uv_bottom_right, background_color,
                        vertex_opacity, y_flipped, nearest_neighbor);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*texture_quad);
   ASSERT_FALSE(mus_quad.is_null());
-  EXPECT_EQ(mus::mojom::MATERIAL_TEXTURE_CONTENT, mus_quad->material);
+  EXPECT_EQ(mus::mojom::Material::TEXTURE_CONTENT, mus_quad->material);
   ASSERT_TRUE(mus_quad->texture_quad_state);
   TextureQuadStatePtr& mus_texture_state = mus_quad->texture_quad_state;
   EXPECT_EQ(resource_id, mus_texture_state->resource_id);
   EXPECT_EQ(premultiplied_alpha, mus_texture_state->premultiplied_alpha);
   EXPECT_TRUE(PointF::From(uv_top_left).Equals(mus_texture_state->uv_top_left));
   EXPECT_TRUE(
       PointF::From(uv_bottom_right).Equals(mus_texture_state->uv_bottom_right));
   EXPECT_TRUE(Color::From(background_color)
                   .Equals(mus_texture_state->background_color));
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(vertex_opacity[i], mus_texture_state->vertex_opacity[i]) << i;
   }
   EXPECT_EQ(y_flipped, mus_texture_state->y_flipped);
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
   QuadPtr mus_texture_quad = Quad::New();
-  mus_texture_quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
+  mus_texture_quad->material = mus::mojom::Material::TEXTURE_CONTENT;
   TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
   mus_texture_state->background_color = Color::New();
   mus_texture_quad->texture_quad_state = std::move(mus_texture_state);
   PassPtr mus_pass = Pass::New();
   mus_pass->id = RenderPassId::New();
   mus_pass->id->layer_id = 1;
   mus_pass->id->index = 1u;
   mus_pass->quads.push_back(std::move(mus_texture_quad));
   SharedQuadStatePtr mus_sqs = SharedQuadState::New();
   mus_pass->shared_quad_states.push_back(std::move(mus_sqs));
 
   scoped_ptr<cc::RenderPass> pass = mus_pass.To<scoped_ptr<cc::RenderPass>>();
 
   EXPECT_FALSE(pass);
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
   QuadPtr mus_texture_quad = Quad::New();
-  mus_texture_quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
+  mus_texture_quad->material = mus::mojom::Material::TEXTURE_CONTENT;
   TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
   mus_texture_state->vertex_opacity = mojo::Array<float>::New(4);
   mus_texture_quad->texture_quad_state = std::move(mus_texture_state);
   PassPtr mus_pass = Pass::New();
   mus_pass->id = RenderPassId::New();
   mus_pass->id->layer_id = 1;
   mus_pass->id->index = 1u;
   mus_pass->quads.push_back(std::move(mus_texture_quad));
   SharedQuadStatePtr mus_sqs = SharedQuadState::New();
   mus_pass->shared_quad_states.push_back(std::move(mus_sqs));
@@ skipping 276 matching lines @@
   debug_border_quad->SetAll(sqs,
                             rect,
                             opaque_rect,
                             visible_rect,
                             needs_blending,
                             arbitrary_color,
                             width);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*debug_border_quad);
   ASSERT_FALSE(mus_quad.is_null());
-  EXPECT_EQ(mus::mojom::MATERIAL_DEBUG_BORDER, mus_quad->material);
+  EXPECT_EQ(mus::mojom::Material::DEBUG_BORDER, mus_quad->material);
   EXPECT_TRUE(Rect::From(rect).Equals(mus_quad->rect));
   EXPECT_TRUE(Rect::From(opaque_rect).Equals(mus_quad->opaque_rect));
   EXPECT_TRUE(Rect::From(visible_rect).Equals(mus_quad->visible_rect));
   EXPECT_EQ(needs_blending, mus_quad->needs_blending);
   ASSERT_TRUE(mus_quad->debug_border_quad_state);
   DebugBorderQuadStatePtr& mus_debug_border_state =
       mus_quad->debug_border_quad_state;
   EXPECT_TRUE(
       Color::From(arbitrary_color).Equals(mus_debug_border_state->color));
   EXPECT_EQ(width, mus_debug_border_state->width);
 }
 
 }  // namespace
 }  // namespace mojo