For c++, Generate enum classes instead of enum from mojom.

mojo/public/cpp/bindings/tests/sample_service_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 <algorithm>
 #include <ostream>
 #include <string>
 
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
@@ skipping 23 matching lines @@
 bool g_dump_message_as_text = false;
 
 // Make a sample |Foo|.
 FooPtr MakeFoo() {
   mojo::String name("foopy");
 
   BarPtr bar(Bar::New());
   bar->alpha = 20;
   bar->beta = 40;
   bar->gamma = 60;
-  bar->type = Bar::TYPE_VERTICAL;
+  bar->type = Bar::Type::VERTICAL;
 
   mojo::Array<BarPtr> extra_bars(3);
   for (size_t i = 0; i < extra_bars.size(); ++i) {
-    Bar::Type type = i % 2 == 0 ? Bar::TYPE_VERTICAL : Bar::TYPE_HORIZONTAL;
+    Bar::Type type = i % 2 == 0 ? Bar::Type::VERTICAL : Bar::Type::HORIZONTAL;
     BarPtr bar(Bar::New());
     uint8_t base = static_cast<uint8_t>(i * 100);
     bar->alpha = base;
     bar->beta = base + 20;
     bar->gamma = base + 40;
     bar->type = type;
     extra_bars[i] = bar.Pass();
   }
 
   mojo::Array<uint8_t> data(10);
@@ skipping 56 matching lines @@
 
   EXPECT_EQ(1, foo.x);
   EXPECT_EQ(2, foo.y);
   EXPECT_FALSE(foo.a);
   EXPECT_TRUE(foo.b);
   EXPECT_FALSE(foo.c);
 
   EXPECT_EQ(20, foo.bar->alpha);
   EXPECT_EQ(40, foo.bar->beta);
   EXPECT_EQ(60, foo.bar->gamma);
-  EXPECT_EQ(Bar::TYPE_VERTICAL, foo.bar->type);
+  EXPECT_EQ(Bar::Type::VERTICAL, foo.bar->type);
 
   EXPECT_EQ(3u, foo.extra_bars.size());
   for (size_t i = 0; i < foo.extra_bars.size(); i++) {
     uint8_t base = static_cast<uint8_t>(i * 100);
-    Bar::Type type = i % 2 == 0 ? Bar::TYPE_VERTICAL : Bar::TYPE_HORIZONTAL;
+    Bar::Type type = i % 2 == 0 ? Bar::Type::VERTICAL : Bar::Type::HORIZONTAL;
     EXPECT_EQ(base, foo.extra_bars[i]->alpha) << i;
     EXPECT_EQ(base + 20, foo.extra_bars[i]->beta) << i;
     EXPECT_EQ(base + 40, foo.extra_bars[i]->gamma) << i;
     EXPECT_EQ(type, foo.extra_bars[i]->type) << i;
   }
 
   EXPECT_EQ(10u, foo.data.size());
   for (size_t i = 0; i < foo.data.size(); ++i) {
     EXPECT_EQ(static_cast<uint8_t>(foo.data.size() - i), foo.data[i]) << i;
   }
@@ skipping 118 matching lines @@
   void Frobinate(FooPtr foo,
                  BazOptions baz,
                  PortPtr port,
                  const Service::FrobinateCallback& callback) override {
     // Users code goes here to handle the incoming Frobinate message.
 
     // We mainly check that we're given the expected arguments.
     EXPECT_FALSE(foo.is_null());
     if (!foo.is_null())
       CheckFoo(*foo);
-    EXPECT_EQ(BAZ_OPTIONS_EXTRA, baz);
+    EXPECT_EQ(Service::BazOptions::EXTRA, baz);
 
     if (g_dump_message_as_text) {
       // Also dump the Foo structure and all of its members.
       std::cout << "Frobinate:" << std::endl;
       int depth = 1;
       Print(depth, "foo", foo);
       Print(depth, "baz", static_cast<int32_t>(baz));
       Print(depth, "port", port.get());
     }
     callback.Run(5);
@@ skipping 53 matching lines @@
   // User constructs a message to send.
 
   // Notice that it doesn't matter in what order the structs / arrays are
   // allocated. Here, the various members of Foo are allocated before Foo is
   // allocated.
 
   FooPtr foo = MakeFoo();
   CheckFoo(*foo);
 
   PortPtr port;
-  service->Frobinate(foo.Pass(), Service::BAZ_OPTIONS_EXTRA, port.Pass(),
+  service->Frobinate(foo.Pass(), Service::BazOptions::EXTRA, port.Pass(),
                      Service::FrobinateCallback());
 
   delete service;
 }
 
 TEST_F(BindingsSampleTest, DefaultValues) {
   DefaultsTestPtr defaults(DefaultsTest::New());
   EXPECT_EQ(-12, defaults->a0);
   EXPECT_EQ(kTwelve, defaults->a1);
   EXPECT_EQ(1234, defaults->a2);
   EXPECT_EQ(34567U, defaults->a3);
   EXPECT_EQ(123456, defaults->a4);
   EXPECT_EQ(3456789012U, defaults->a5);
   EXPECT_EQ(-111111111111LL, defaults->a6);
   EXPECT_EQ(9999999999999999999ULL, defaults->a7);
   EXPECT_EQ(0x12345, defaults->a8);
   EXPECT_EQ(-0x12345, defaults->a9);
   EXPECT_EQ(1234, defaults->a10);
   EXPECT_TRUE(defaults->a11);
   EXPECT_FALSE(defaults->a12);
   EXPECT_FLOAT_EQ(123.25f, defaults->a13);
   EXPECT_DOUBLE_EQ(1234567890.123, defaults->a14);
   EXPECT_DOUBLE_EQ(1E10, defaults->a15);
   EXPECT_DOUBLE_EQ(-1.2E+20, defaults->a16);
   EXPECT_DOUBLE_EQ(1.23E-20, defaults->a17);
   EXPECT_TRUE(defaults->a18.is_null());
   EXPECT_TRUE(defaults->a19.is_null());
-  EXPECT_EQ(Bar::TYPE_BOTH, defaults->a20);
+  EXPECT_EQ(Bar::Type::BOTH, defaults->a20);
   EXPECT_TRUE(defaults->a21.is_null());
   ASSERT_FALSE(defaults->a22.is_null());
-  EXPECT_EQ(imported::SHAPE_RECTANGLE, defaults->a22->shape);
-  EXPECT_EQ(static_cast<int32_t>(imported::COLOR_BLACK), defaults->a22->color);
+  EXPECT_EQ(imported::Shape::RECTANGLE, defaults->a22->shape);
+  EXPECT_EQ(static_cast<int32_t>(imported::Color::BLACK), defaults->a22->color);
   EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, defaults->a23);
   EXPECT_EQ(0x123456789, defaults->a24);
   EXPECT_EQ(-0x123456789, defaults->a25);
 }
 
 }  // namespace
 }  // namespace sample