Mojo C++ bindings: switch components/filesystem mojom target to use STL types.

components/filesystem/file_impl.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 "components/filesystem/file_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <limits>
 #include <utility>
@@ skipping 71 matching lines @@
   file_.Close();
   callback.Run(mojom::FileError::OK);
 }
 
 // TODO(vtl): Move the implementation to a thread pool.
 void FileImpl::Read(uint32_t num_bytes_to_read,
                     int64_t offset,
                     mojom::Whence whence,
                     const ReadCallback& callback) {
   if (!file_.IsValid()) {
-    callback.Run(GetError(file_), mojo::Array<uint8_t>());
+    callback.Run(GetError(file_), base::nullopt);
     return;
   }
   if (num_bytes_to_read > kMaxReadSize) {
-    callback.Run(mojom::FileError::INVALID_OPERATION, mojo::Array<uint8_t>());
+    callback.Run(mojom::FileError::INVALID_OPERATION, base::nullopt);
     return;
   }
   mojom::FileError error = IsOffsetValid(offset);
   if (error != mojom::FileError::OK) {
-    callback.Run(error, mojo::Array<uint8_t>());
+    callback.Run(error, base::nullopt);
     return;
   }
   error = IsWhenceValid(whence);
   if (error != mojom::FileError::OK) {
-    callback.Run(error, mojo::Array<uint8_t>());
+    callback.Run(error, base::nullopt);
     return;
   }
 
   if (file_.Seek(static_cast<base::File::Whence>(whence), offset) == -1) {
-    callback.Run(mojom::FileError::FAILED, mojo::Array<uint8_t>());
+    callback.Run(mojom::FileError::FAILED, base::nullopt);
     return;
   }
 
-  mojo::Array<uint8_t> bytes_read(num_bytes_to_read);
+  std::vector<uint8_t> bytes_read(num_bytes_to_read);
   int num_bytes_read = file_.ReadAtCurrentPos(
       reinterpret_cast<char*>(&bytes_read.front()), num_bytes_to_read);
   if (num_bytes_read < 0) {
-    callback.Run(mojom::FileError::FAILED, mojo::Array<uint8_t>());
+    callback.Run(mojom::FileError::FAILED, base::nullopt);
     return;
   }
 
   DCHECK_LE(static_cast<size_t>(num_bytes_read), num_bytes_to_read);
   bytes_read.resize(static_cast<size_t>(num_bytes_read));
   callback.Run(mojom::FileError::OK, std::move(bytes_read));
 }
 
 // TODO(vtl): Move the implementation to a thread pool.
-void FileImpl::Write(mojo::Array<uint8_t> bytes_to_write,
+void FileImpl::Write(const std::vector<uint8_t>& bytes_to_write,
                      int64_t offset,
                      mojom::Whence whence,
                      const WriteCallback& callback) {
-  DCHECK(!bytes_to_write.is_null());
   if (!file_.IsValid()) {
     callback.Run(GetError(file_), 0);
     return;
   }
   // Who knows what |write()| would return if the size is that big (and it
   // actually wrote that much).
   if (bytes_to_write.size() >
 #if defined(OS_WIN)
       static_cast<size_t>(std::numeric_limits<int>::max())) {
 #else
@@ skipping 12 matching lines @@
     callback.Run(error, 0);
     return;
   }
 
   if (file_.Seek(static_cast<base::File::Whence>(whence), offset) == -1) {
     callback.Run(mojom::FileError::FAILED, 0);
     return;
   }
 
   const char* buf = (bytes_to_write.size() > 0)
-                        ? reinterpret_cast<char*>(&bytes_to_write.front())
+                        ? reinterpret_cast<const char*>(&bytes_to_write.front())
                         : nullptr;
   int num_bytes_written = file_.WriteAtCurrentPos(
       buf, static_cast<int>(bytes_to_write.size()));
   if (num_bytes_written < 0) {
     callback.Run(mojom::FileError::FAILED, 0);
     return;
   }
 
   DCHECK_LE(static_cast<size_t>(num_bytes_written),
             std::numeric_limits<uint32_t>::max());
@@ skipping 174 matching lines @@
   if (info.is_directory) {
     callback.Run(mojom::FileError::NOT_A_FILE, ScopedHandle());
     return;
   }
 
   callback.Run(mojom::FileError::OK,
                mojo::WrapPlatformFile(new_file.TakePlatformFile()));
 }
 
 }  // namespace filesystem