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

services/native_support/process_controller_impl_unittest.cc

 // Copyright 2015 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 <signal.h>
 
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
   base::MessageLoop::current()->Run();
 }
 
 // Note: We already tested success (zero) versus failure (non-zero) exit
 // statuses in |ProcessControllerTest.Spawn|.
 TEST_F(ProcessControllerImplTest, Wait) {
   mojo::files::Error error;
 
   {
     ProcessControllerPtr process_controller;
-    error = mojo::files::ERROR_INTERNAL;
+    error = mojo::files::Error::INTERNAL;
     const char kPath[] = "/bin/sh";
     mojo::Array<mojo::String> argv;
     argv.push_back(kPath);
     argv.push_back("-c");
     argv.push_back("exit 42");
     process()->Spawn(kPath, argv.Pass(), mojo::Array<mojo::String>(), nullptr,
                      nullptr, nullptr, GetProxy(&process_controller),
                      Capture(&error));
     ASSERT_TRUE(process().WaitForIncomingResponse());
-    EXPECT_EQ(mojo::files::ERROR_OK, error);
+    EXPECT_EQ(mojo::files::Error::OK, error);
 
-    error = mojo::files::ERROR_INTERNAL;
+    error = mojo::files::Error::INTERNAL;
     int32_t exit_status = 0;
     process_controller->Wait(Capture(&error, &exit_status));
     ASSERT_TRUE(process_controller.WaitForIncomingResponse());
-    EXPECT_EQ(mojo::files::ERROR_OK, error);
+    EXPECT_EQ(mojo::files::Error::OK, error);
     EXPECT_EQ(42, exit_status);
   }
 }
 
 // An output file stream that captures output and quits when "ready" is seen.
 class QuitOnReadyFile : public files_impl::OutputStreamFile::Client {
  public:
   explicit QuitOnReadyFile(mojo::InterfaceRequest<mojo::files::File> request)
       : impl_(files_impl::OutputStreamFile::Create(this, request.Pass())) {}
   ~QuitOnReadyFile() override {}
@@ skipping 55 matching lines @@
   // So instead we use "read" with a timeout (note that "-t" is a bash
   // extension, and not specified by POSIX for /bin/sh). Thus we have to give
   // something for stdin (otherwise, it'd come from /dev/null and the read would
   // be completed immediately).
   mojo::files::FilePtr ifile;
   IgnoreReadsFile ifile_impl(GetProxy(&ifile));
   mojo::files::FilePtr ofile;
   QuitOnReadyFile ofile_impl(GetProxy(&ofile));
 
   ProcessControllerPtr process_controller;
-  mojo::files::Error error = mojo::files::ERROR_INTERNAL;
+  mojo::files::Error error = mojo::files::Error::INTERNAL;
   const char kPath[] = "/bin/bash";
   mojo::Array<mojo::String> argv;
   argv.push_back(kPath);
   argv.push_back("-c");
   argv.push_back("trap 'exit 42' INT; echo ready; read -t30; exit 1");
   process()->Spawn(kPath, argv.Pass(), mojo::Array<mojo::String>(),
                    ifile.Pass(), ofile.Pass(), nullptr,
                    GetProxy(&process_controller), Capture(&error));
   ASSERT_TRUE(process().WaitForIncomingResponse());
-  EXPECT_EQ(mojo::files::ERROR_OK, error);
+  EXPECT_EQ(mojo::files::Error::OK, error);
 
   // |ofile_impl| will quit the message loop once it sees "ready".
   RunMessageLoop();
   ASSERT_TRUE(ofile_impl.got_ready());
 
   // Send SIGINT.
-  error = mojo::files::ERROR_INTERNAL;
+  error = mojo::files::Error::INTERNAL;
   process_controller->Kill(static_cast<int32_t>(SIGINT), Capture(&error));
   ASSERT_TRUE(process_controller.WaitForIncomingResponse());
-  EXPECT_EQ(mojo::files::ERROR_OK, error);
+  EXPECT_EQ(mojo::files::Error::OK, error);
 
-  error = mojo::files::ERROR_INTERNAL;
+  error = mojo::files::Error::INTERNAL;
   int32_t exit_status = 0;
   process_controller->Wait(Capture(&error, &exit_status));
   ASSERT_TRUE(process_controller.WaitForIncomingResponse());
-  EXPECT_EQ(mojo::files::ERROR_OK, error);
+  EXPECT_EQ(mojo::files::Error::OK, error);
   EXPECT_EQ(42, exit_status);
 }
 
 TEST_F(ProcessControllerImplTest, DestroyingControllerKills) {
   // We want to make sure that we've exec-ed before killing, so we do what we do
   // in |ProcessControllerImplTest.Kill| (without the trap).
   {
     mojo::files::FilePtr ifile;
     IgnoreReadsFile ifile_impl(GetProxy(&ifile));
     mojo::files::FilePtr ofile;
     QuitOnReadyFile ofile_impl(GetProxy(&ofile));
 
     ProcessControllerPtr process_controller;
-    mojo::files::Error error = mojo::files::ERROR_INTERNAL;
+    mojo::files::Error error = mojo::files::Error::INTERNAL;
     const char kPath[] = "/bin/bash";
     mojo::Array<mojo::String> argv;
     argv.push_back(kPath);
     argv.push_back("-c");
     argv.push_back("echo ready; read -t30");
     process()->Spawn(kPath, argv.Pass(), mojo::Array<mojo::String>(),
                      ifile.Pass(), ofile.Pass(), nullptr,
                      GetProxy(&process_controller), Capture(&error));
     ASSERT_TRUE(process().WaitForIncomingResponse());
-    EXPECT_EQ(mojo::files::ERROR_OK, error);
+    EXPECT_EQ(mojo::files::Error::OK, error);
 
     // |ofile_impl| will quit the message loop once it sees "ready".
     RunMessageLoop();
     ASSERT_TRUE(ofile_impl.got_ready());
   }
 
   // The child should be killed.
   // TODO(vtl): It's pretty hard to verify that the child process was actually
   // killed. This could be done, e.g., by having the child trap SIGTERM and
   // writing something to a file, and then separately checking for that file.
   // For now now, just be happy if it doesn't crash. (I've actually verified it
   // "manually", but automation is hard.)
 }
 
 }  // namespace
 }  // namespace native_support