Replace (most) occurrences of mojo::Array<T>() with nullptr.

services/files/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 "services/files/file_impl.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 46 matching lines @@
 
   callback.Run(Error::OK);
 }
 
 // TODO(vtl): Move the implementation to a thread pool.
 void FileImpl::Read(uint32_t num_bytes_to_read,
                     int64_t offset,
                     Whence whence,
                     const ReadCallback& callback) {
   if (!file_fd_.is_valid()) {
-    callback.Run(Error::CLOSED, Array<uint8_t>());
+    callback.Run(Error::CLOSED, nullptr);
     return;
   }
   if (num_bytes_to_read > kMaxReadSize) {
-    callback.Run(Error::OUT_OF_RANGE, Array<uint8_t>());
+    callback.Run(Error::OUT_OF_RANGE, nullptr);
     return;
   }
 
   Error error = IsOffsetValid(offset);
   if (error != Error::OK) {
-    callback.Run(error, Array<uint8_t>());
+    callback.Run(error, nullptr);
     return;
   }
 
   error = IsWhenceValid(whence);
   if (error != Error::OK) {
-    callback.Run(error, Array<uint8_t>());
+    callback.Run(error, nullptr);
     return;
   }
 
   if (offset != 0 || whence != Whence::FROM_CURRENT) {
     // TODO(vtl): Use |pread()| below in the |Whence::FROM_START| case. This
     // implementation is obviously not atomic. (If someone seeks simultaneously,
     // we'll end up writing somewhere else. Or, well, we would if we were
     // multithreaded.) Maybe we should do an |ftell()| and always use |pread()|.
     // TODO(vtl): Possibly, at least sometimes we should not change the file
     // position. See TODO in file.mojom.
     if (lseek(file_fd_.get(), static_cast<off_t>(offset),
               WhenceToStandardWhence(whence)) < 0) {
-      callback.Run(ErrnoToError(errno), Array<uint8_t>());
+      callback.Run(ErrnoToError(errno), nullptr);
       return;
     }
   }
 
   auto bytes_read = Array<uint8_t>::New(num_bytes_to_read);
   ssize_t num_bytes_read = HANDLE_EINTR(
       read(file_fd_.get(), &bytes_read.front(), num_bytes_to_read));
   if (num_bytes_read < 0) {
-    callback.Run(ErrnoToError(errno), Array<uint8_t>());
+    callback.Run(ErrnoToError(errno), nullptr);
     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(Error::OK, bytes_read.Pass());
 }
 
 // TODO(vtl): Move the implementation to a thread pool.
 void FileImpl::Write(Array<uint8_t> bytes_to_write,
@@ skipping 221 matching lines @@
 
   // TODO(vtl): FIXME soon
   NOTIMPLEMENTED();
   callback.Run(Error::UNIMPLEMENTED, ScopedSharedBufferHandle());
 }
 
 void FileImpl::Ioctl(uint32_t request,
                      Array<uint32_t> in_values,
                      const IoctlCallback& callback) {
   if (!file_fd_.is_valid()) {
-    callback.Run(Error::CLOSED, Array<uint32_t>());
+    callback.Run(Error::CLOSED, nullptr);
     return;
   }
 
   // TODO(vtl): The "correct" error code should be one that can be translated to
   // ENOTTY!
-  callback.Run(Error::UNAVAILABLE, Array<uint32_t>());
+  callback.Run(Error::UNAVAILABLE, nullptr);
 }
 
 }  // namespace files
 }  // namespace mojo