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

mojo/services/files/cpp/lib/input_stream_file.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 "mojo/services/files/cpp/input_stream_file.h"
 
 #include <utility>
 
 #include "mojo/public/cpp/environment/logging.h"
 
@@ skipping 45 matching lines @@
 
   if (client_)
     client_->OnClosed();
 }
 
 void InputStreamFile::Read(uint32_t num_bytes_to_read,
                            int64_t offset,
                            mojo::files::Whence whence,
                            const ReadCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, mojo::Array<uint8_t>());
+    callback.Run(mojo::files::Error::CLOSED, nullptr);
     return;
   }
 
   if (offset != 0 || whence != mojo::files::Whence::FROM_CURRENT) {
     // TODO(vtl): Is this the "right" behavior?
-    callback.Run(mojo::files::Error::INVALID_ARGUMENT, mojo::Array<uint8_t>());
+    callback.Run(mojo::files::Error::INVALID_ARGUMENT, nullptr);
     return;
   }
 
   bool should_start_read = pending_read_queue_.empty();
   pending_read_queue_.push_back(PendingRead(num_bytes_to_read, callback));
   if (should_start_read)
     StartRead();
 }
 
 void InputStreamFile::Write(mojo::Array<uint8_t> bytes_to_write,
@@ skipping 134 matching lines @@
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
   callback.Run(mojo::files::Error::UNAVAILABLE,
                mojo::ScopedSharedBufferHandle());
 }
 
 void InputStreamFile::Ioctl(uint32_t request,
                             mojo::Array<uint32_t> in_values,
                             const IoctlCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, mojo::Array<uint32_t>());
+    callback.Run(mojo::files::Error::CLOSED, nullptr);
     return;
   }
 
-  callback.Run(mojo::files::Error::UNIMPLEMENTED, mojo::Array<uint32_t>());
+  callback.Run(mojo::files::Error::UNIMPLEMENTED, nullptr);
 }
 
 void InputStreamFile::StartRead() {
   MOJO_DCHECK(!pending_read_queue_.empty());
 
   // If we don't have a client, just drain all the reads.
   if (!client_) {
     while (!pending_read_queue_.empty()) {
       // TODO(vtl): Is this what we want?
       pending_read_queue_.front().callback.Run(mojo::files::Error::UNAVAILABLE,
-                                               mojo::Array<uint8_t>());
+                                               nullptr);
       pending_read_queue_.pop_front();
     }
     return;
   }
 
   do {
     // Find a non-zero-byte read, completing any zero-byte reads at the front of
     // the queue. Note that we do this in FIFO order (thus couldn't have
     // completed them earlier).
     while (!pending_read_queue_.front().num_bytes) {
-      pending_read_queue_.front().callback.Run(mojo::files::Error::OK,
-                                               mojo::Array<uint8_t>());
+      pending_read_queue_.front().callback.Run(mojo::files::Error::OK, nullptr);
       pending_read_queue_.pop_front();
 
       if (pending_read_queue_.empty())
         return;
     }
 
     // Binding |this| is OK, since the client must not call the callback if we
     // are destroyed.
     mojo::files::Error error = mojo::files::Error::INTERNAL;
     mojo::Array<uint8_t> data;
@@ skipping 16 matching lines @@
     else
       return;  // Asynchronous completion.
   } while (!pending_read_queue_.empty());
 }
 
 void InputStreamFile::CompleteRead(mojo::files::Error error,
                                    mojo::Array<uint8_t> data) {
   MOJO_CHECK(!pending_read_queue_.empty());
 
   if (error != mojo::files::Error::OK) {
-    pending_read_queue_.front().callback.Run(error, mojo::Array<uint8_t>());
+    pending_read_queue_.front().callback.Run(error, nullptr);
     pending_read_queue_.pop_front();
     return;
   }
 
   MOJO_CHECK(!data.is_null());
   MOJO_CHECK(data.size() <= pending_read_queue_.front().num_bytes);
   pending_read_queue_.front().callback.Run(mojo::files::Error::OK, data.Pass());
   pending_read_queue_.pop_front();
 }
 
 }  // namespace files_impl