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

services/native_support/redirectors.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 "services/native_support/redirectors.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
 }
 
 void FDToMojoFileRedirector::DoWrite() {
   CHECK_GT(num_bytes_, offset_);
   size_t num_bytes_to_write = num_bytes_ - offset_;
 
   // TODO(vtl): Is there a more natural (or efficient) way to do this?
   mojo::Array<uint8_t> bytes_to_write(num_bytes_to_write);
   memcpy(&bytes_to_write[offset_], buffer_.get(), num_bytes_to_write);
 
-  file_->Write(bytes_to_write.Pass(), 0, mojo::files::WHENCE_FROM_CURRENT,
+  file_->Write(bytes_to_write.Pass(), 0, mojo::files::Whence::FROM_CURRENT,
                base::Bind(&FDToMojoFileRedirector::DidWrite,
                           weak_factory_.GetWeakPtr()));
 }
 
 void FDToMojoFileRedirector::DidWrite(mojo::files::Error error,
                                       uint32_t num_bytes_written) {
-  if (error != mojo::files::ERROR_OK) {
+  if (error != mojo::files::Error::OK) {
     LOG(WARNING) << "Failed to write to Mojo File";
     // TODO(vtl): Should maybe close |file_|?
     return;
   }
 
   CHECK_GT(num_bytes_, offset_);
   size_t num_bytes_to_write = num_bytes_ - offset_;
   if (num_bytes_written > num_bytes_to_write) {
     LOG(ERROR) << "Bad result from write to Mojo File";
     return;
@@ skipping 23 matching lines @@
 
 MojoFileToFDRedirector::~MojoFileToFDRedirector() {}
 
 void MojoFileToFDRedirector::Start() {
   running_ = true;
 
   if (read_pending_)
     return;
 
   file_->Read(
-      static_cast<uint32_t>(buffer_size_), 0, mojo::files::WHENCE_FROM_CURRENT,
+      static_cast<uint32_t>(buffer_size_), 0, mojo::files::Whence::FROM_CURRENT,
       base::Bind(&MojoFileToFDRedirector::DidRead, weak_factory_.GetWeakPtr()));
   read_pending_ = true;
 }
 
 void MojoFileToFDRedirector::Stop() {
   running_ = false;
 }
 
 void MojoFileToFDRedirector::DidRead(mojo::files::Error error,
                                      mojo::Array<uint8_t> bytes_read) {
   DCHECK(read_pending_);
   read_pending_ = false;
 
-  if (error != mojo::files::ERROR_OK) {
+  if (error != mojo::files::Error::OK) {
     LOG(ERROR) << "Read failed";
     // TODO(vtl): Should maybe close |file_|?
     return;
   }
 
   ssize_t result = HANDLE_EINTR(write(fd_, &bytes_read[0], bytes_read.size()));
   if (result < 0) {
     if (errno == EAGAIN || errno == EWOULDBLOCK) {
       LOG(ERROR) << "Could not write to FD without blocking";
       if (running_)
         Start();
       return;
     }
     PLOG(WARNING) << "Failed to write to FD";
     // TODO(vtl): Should maybe close |file_|?
     return;
   }
   if (static_cast<size_t>(result) != bytes_read.size())
     LOG(ERROR) << "Failed to write everything to FD";
 
   if (running_)
     Start();
 }
 
 }  // namespace native_support