Move //mojo/services/X/public/... to //mojo/services/X/... (part 1).

mojo/services/files/public/cpp/lib/input_stream_file.cc

Index: mojo/services/files/public/cpp/lib/input_stream_file.cc
diff --git a/mojo/services/files/public/cpp/lib/input_stream_file.cc b/mojo/services/files/public/cpp/lib/input_stream_file.cc
deleted file mode 100644
index 7408442575dd912606493f49849172e005d57a32..0000000000000000000000000000000000000000
--- a/mojo/services/files/public/cpp/lib/input_stream_file.cc
+++ /dev/null
@@ -1,302 +0,0 @@
-// 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/public/cpp/input_stream_file.h"
-
-#include <utility>
-
-#include "mojo/public/cpp/environment/logging.h"
-
-namespace files_impl {
-
-InputStreamFile::PendingRead::PendingRead(uint32_t num_bytes,
-                                          const ReadCallback& callback)
-    : num_bytes(num_bytes), callback(callback) {}
-
-InputStreamFile::PendingRead::~PendingRead() {}
-
-// static
-std::unique_ptr<InputStreamFile> InputStreamFile::Create(
-    Client* client,
-    mojo::InterfaceRequest<mojo::files::File> request) {
-  // TODO(vtl): Use make_unique when we have C++14.
-  return std::unique_ptr<InputStreamFile>(
-      new InputStreamFile(client, request.Pass()));
-}
-
-InputStreamFile::~InputStreamFile() {
-  if (was_destroyed_)
-    *was_destroyed_ = true;
-}
-
-InputStreamFile::InputStreamFile(
-    Client* client,
-    mojo::InterfaceRequest<mojo::files::File> request)
-    : client_(client),
-      is_closed_(false),
-      was_destroyed_(nullptr),
-      binding_(this, request.Pass()) {
-  binding_.set_connection_error_handler([this]() {
-    if (client_)
-      client_->OnClosed();
-  });
-}
-
-void InputStreamFile::Close(const CloseCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl): Call pending read callbacks?
-
-  is_closed_ = true;
-  callback.Run(mojo::files::Error::OK);
-
-  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>());
-    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>());
-    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,
-                            int64_t offset,
-                            mojo::files::Whence whence,
-                            const WriteCallback& callback) {
-  MOJO_DCHECK(!bytes_to_write.is_null());
-
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, 0);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE, 0);
-}
-
-void InputStreamFile::ReadToStream(mojo::ScopedDataPipeProducerHandle source,
-                                   int64_t offset,
-                                   mojo::files::Whence whence,
-                                   int64_t num_bytes_to_read,
-                                   const ReadToStreamCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl)
-  MOJO_DLOG(ERROR) << "Not implemented";
-  callback.Run(mojo::files::Error::UNIMPLEMENTED);
-}
-
-void InputStreamFile::WriteFromStream(mojo::ScopedDataPipeConsumerHandle sink,
-                                      int64_t offset,
-                                      mojo::files::Whence whence,
-                                      const WriteFromStreamCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE);
-}
-
-void InputStreamFile::Tell(const TellCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, 0);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE, 0);
-}
-
-void InputStreamFile::Seek(int64_t offset,
-                           mojo::files::Whence whence,
-                           const SeekCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, 0);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE, 0);
-}
-
-void InputStreamFile::Stat(const StatCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, nullptr);
-    return;
-  }
-
-  // TODO(vtl)
-  MOJO_DLOG(ERROR) << "Not implemented";
-  callback.Run(mojo::files::Error::UNIMPLEMENTED, nullptr);
-}
-
-void InputStreamFile::Truncate(int64_t size, const TruncateCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE);
-}
-
-void InputStreamFile::Touch(mojo::files::TimespecOrNowPtr atime,
-                            mojo::files::TimespecOrNowPtr mtime,
-                            const TouchCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE);
-}
-
-void InputStreamFile::Dup(mojo::InterfaceRequest<mojo::files::File> file,
-                          const DupCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE);
-}
-
-void InputStreamFile::Reopen(mojo::InterfaceRequest<mojo::files::File> file,
-                             uint32_t open_flags,
-                             const ReopenCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED);
-    return;
-  }
-
-  // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
-  // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::Error::UNAVAILABLE);
-}
-
-void InputStreamFile::AsBuffer(const AsBufferCallback& callback) {
-  if (is_closed_) {
-    callback.Run(mojo::files::Error::CLOSED, mojo::ScopedSharedBufferHandle());
-    return;
-  }
-
-  // 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>());
-    return;
-  }
-
-  callback.Run(mojo::files::Error::UNIMPLEMENTED, mojo::Array<uint32_t>());
-}
-
-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>());
-      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_.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;
-    // Detect if we were destroyed inside |RequestData()|.
-    bool was_destroyed = false;
-    MOJO_CHECK(!was_destroyed_);
-    was_destroyed_ = &was_destroyed;
-    bool synchronous_completion = client_->RequestData(
-        pending_read_queue_.front().num_bytes, &error, &data,
-        [this](mojo::files::Error e, mojo::Array<uint8_t> d) {
-          CompleteRead(e, d.Pass());
-          if (!pending_read_queue_.empty())
-            StartRead();
-        });
-    if (was_destroyed)
-      return;
-    was_destroyed_ = nullptr;
-    if (synchronous_completion)
-      CompleteRead(error, data.Pass());
-    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_.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