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

sql/mojo/mojo_vfs.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 "sql/mojo/mojo_vfs.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 49 matching lines @@
 };
 
 filesystem::FilePtr& GetFSFile(sqlite3_file* vfs_file) {
   return reinterpret_cast<MojoVFSFile*>(vfs_file)->file_ptr;
 }
 
 int MojoVFSClose(sqlite3_file* file) {
   DVLOG(1) << "MojoVFSClose(*)";
   TRACE_EVENT0("sql", "MojoVFSClose");
   using filesystem::FilePtr;
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   // Must call File::Close explicitly instead of just deleting the file, since
   // otherwise we wouldn't have an object to wait on.
   GetFSFile(file)->Close(mojo::Capture(&error));
   GetFSFile(file).WaitForIncomingResponse();
   GetFSFile(file).~FilePtr();
   return SQLITE_OK;
 }
 
 int MojoVFSRead(sqlite3_file* sql_file,
                 void* buffer,
                 int size,
                 sqlite3_int64 offset) {
   DVLOG(1) << "MojoVFSRead (" << size << " @ " << offset << ")";
   TRACE_EVENT0("sql", "MojoVFSRead");
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   mojo::Array<uint8_t> mojo_data;
-  GetFSFile(sql_file)->Read(size, offset, filesystem::WHENCE_FROM_BEGIN,
+  GetFSFile(sql_file)->Read(size, offset, filesystem::Whence::FROM_BEGIN,
                             Capture(&error, &mojo_data));
   GetFSFile(sql_file).WaitForIncomingResponse();
 
-  if (error != filesystem::FILE_ERROR_OK) {
+  if (error != filesystem::FileError::OK) {
     // TODO(erg): Better implementation here.
     NOTIMPLEMENTED();
     return SQLITE_IOERR_READ;
   }
 
   if (mojo_data.size())
     memcpy(buffer, &mojo_data.front(), mojo_data.size());
   if (mojo_data.size() == static_cast<size_t>(size))
     return SQLITE_OK;
 
   // We didn't read the entire buffer. Fill the rest of the buffer with zeros.
   memset(reinterpret_cast<char*>(buffer) + mojo_data.size(), 0,
          size - mojo_data.size());
 
   return SQLITE_IOERR_SHORT_READ;
 }
 
 int MojoVFSWrite(sqlite3_file* sql_file,
                  const void* buffer,
                  int size,
                  sqlite_int64 offset) {
   DVLOG(1) << "MojoVFSWrite(*, " << size << ", " << offset << ")";
   TRACE_EVENT0("sql", "MojoVFSWrite");
   mojo::Array<uint8_t> mojo_data(size);
   memcpy(&mojo_data.front(), buffer, size);
 
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   uint32_t num_bytes_written = 0;
   GetFSFile(sql_file)->Write(std::move(mojo_data), offset,
-                             filesystem::WHENCE_FROM_BEGIN,
+                             filesystem::Whence::FROM_BEGIN,
                              Capture(&error, &num_bytes_written));
   GetFSFile(sql_file).WaitForIncomingResponse();
-  if (error != filesystem::FILE_ERROR_OK) {
+  if (error != filesystem::FileError::OK) {
     // TODO(erg): Better implementation here.
     NOTIMPLEMENTED();
     return SQLITE_IOERR_WRITE;
   }
   if (num_bytes_written != static_cast<uint32_t>(size)) {
     NOTIMPLEMENTED();
     return SQLITE_IOERR_WRITE;
   }
 
   return SQLITE_OK;
 }
 
 int MojoVFSTruncate(sqlite3_file* sql_file, sqlite_int64 size) {
   DVLOG(1) << "MojoVFSTruncate(*, " << size << ")";
   TRACE_EVENT0("sql", "MojoVFSTruncate");
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   GetFSFile(sql_file)->Truncate(size, Capture(&error));
   GetFSFile(sql_file).WaitForIncomingResponse();
-  if (error != filesystem::FILE_ERROR_OK) {
+  if (error != filesystem::FileError::OK) {
     // TODO(erg): Better implementation here.
     NOTIMPLEMENTED();
     return SQLITE_IOERR_TRUNCATE;
   }
 
   return SQLITE_OK;
 }
 
 int MojoVFSSync(sqlite3_file* sql_file, int flags) {
   DVLOG(1) << "MojoVFSSync(*, " << flags << ")";
   TRACE_EVENT0("sql", "MojoVFSSync");
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   GetFSFile(sql_file)->Flush(Capture(&error));
   GetFSFile(sql_file).WaitForIncomingResponse();
-  if (error != filesystem::FILE_ERROR_OK) {
+  if (error != filesystem::FileError::OK) {
     // TODO(erg): Better implementation here.
     NOTIMPLEMENTED();
     return SQLITE_IOERR_FSYNC;
   }
 
   return SQLITE_OK;
 }
 
 int MojoVFSFileSize(sqlite3_file* sql_file, sqlite_int64* size) {
   DVLOG(1) << "MojoVFSFileSize(*)";
   TRACE_EVENT0("sql", "MojoVFSFileSize");
 
-  filesystem::FileError err = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError err = filesystem::FileError::FAILED;
   filesystem::FileInformationPtr file_info;
   GetFSFile(sql_file)->Stat(Capture(&err, &file_info));
   GetFSFile(sql_file).WaitForIncomingResponse();
 
-  if (err != filesystem::FILE_ERROR_OK) {
+  if (err != filesystem::FileError::OK) {
     // TODO(erg): Better implementation here.
     NOTIMPLEMENTED();
     return SQLITE_IOERR_FSTAT;
   }
 
   *size = file_info->size;
   return SQLITE_OK;
 }
 
 // TODO(erg): The current base::File interface isn't sufficient to handle
@@ skipping 89 matching lines @@
     CHECK(strncmp("Temp_", name, 5) != 0);
     mojo_name = name;
   } else {
     DCHECK(flags & SQLITE_OPEN_DELETEONCLOSE);
     static int temp_number = 0;
     mojo_name = base::StringPrintf("Temp_%d.db", temp_number++);
   }
 
   // Grab the incoming file
   filesystem::FilePtr file_ptr;
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   GetRootDirectory(mojo_vfs)->OpenFile(mojo_name, GetProxy(&file_ptr),
                                        open_flags, Capture(&error));
   GetRootDirectory(mojo_vfs).WaitForIncomingResponse();
-  if (error != filesystem::FILE_ERROR_OK) {
+  if (error != filesystem::FileError::OK) {
     // TODO(erg): Translate more of the mojo error codes into sqlite error
     // codes.
     return SQLITE_CANTOPEN;
   }
 
   // Set the method table so we can be closed (and run the manual dtor call to
   // match the following placement news).
   file->pMethods = &mojo_vfs_io_methods;
 
   // |file| is actually a malloced buffer of size szOsFile. This means that we
   // need to manually use placement new to construct the C++ object which owns
   // the pipe to our file.
   new (&GetFSFile(file)) filesystem::FilePtr(std::move(file_ptr));
 
   return SQLITE_OK;
 }
 
 int MojoVFSDelete(sqlite3_vfs* mojo_vfs, const char* filename, int sync_dir) {
   DVLOG(1) << "MojoVFSDelete(*, " << filename << ", " << sync_dir << ")";
   TRACE_EVENT2("sql", "MojoVFSDelete",
                "name", filename,
                "sync_dir", sync_dir);
   // TODO(erg): The default windows sqlite VFS has retry code to work around
   // antivirus software keeping files open. We'll probably have to do something
   // like that in the far future if we ever support Windows.
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
   GetRootDirectory(mojo_vfs)->Delete(filename, 0, Capture(&error));
   GetRootDirectory(mojo_vfs).WaitForIncomingResponse();
 
-  if (error == filesystem::FILE_ERROR_OK && sync_dir) {
+  if (error == filesystem::FileError::OK && sync_dir) {
     GetRootDirectory(mojo_vfs)->Flush(Capture(&error));
     GetRootDirectory(mojo_vfs).WaitForIncomingResponse();
   }
 
-  return error == filesystem::FILE_ERROR_OK ? SQLITE_OK : SQLITE_IOERR_DELETE;
+  return error == filesystem::FileError::OK ? SQLITE_OK : SQLITE_IOERR_DELETE;
 }
 
 int MojoVFSAccess(sqlite3_vfs* mojo_vfs,
                   const char* filename,
                   int flags,
                   int* result) {
   DVLOG(1) << "MojoVFSAccess(*, " << filename << ", " << flags << ", *)";
   TRACE_EVENT2("sql", "MojoVFSAccess",
                "name", filename,
                "flags", flags);
-  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::FileError error = filesystem::FileError::FAILED;
 
   if (flags == SQLITE_ACCESS_READWRITE || flags == SQLITE_ACCESS_READ) {
     bool is_writable = false;
     GetRootDirectory(mojo_vfs)
         ->IsWritable(filename, Capture(&error, &is_writable));
     GetRootDirectory(mojo_vfs).WaitForIncomingResponse();
     *result = is_writable;
     return SQLITE_OK;
   }
 
@@ skipping 99 matching lines @@
 
   CHECK(sqlite3_vfs_register(parent_, 1) == SQLITE_OK);
   CHECK(sqlite3_vfs_unregister(&mojo_vfs) == SQLITE_OK);
 }
 
 filesystem::DirectoryPtr& ScopedMojoFilesystemVFS::GetDirectory() {
   return root_directory_;
 }
 
 }  // namespace sql