Files: Add basic implementation of Directory and some basic tests.

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>
-#include <time.h>
 #include <unistd.h>
 
 #include <limits>
 
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
-#include "services/files/futimens.h"
+#include "services/files/shared_impl.h"
 #include "services/files/util.h"
 
 static_assert(sizeof(off_t) <= sizeof(int64_t), "off_t too big");
 static_assert(sizeof(size_t) >= sizeof(uint32_t), "size_t too small");
 
 namespace mojo {
 namespace files {
 
 const size_t kMaxReadSize = 1 * 1024 * 1024;  // 1 MB.
 
@@ skipping 207 matching lines @@
   }
 
   callback.Run(ERROR_OK, static_cast<int64>(position));
 }
 
 void FileImpl::Stat(const Callback<void(Error, FileInformationPtr)>& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED, nullptr);
     return;
   }
-
-  struct stat buf;
-  if (fstat(file_fd_.get(), &buf) != 0) {
-    callback.Run(ErrnoToError(errno), nullptr);
-    return;
-  }
-
-  FileInformationPtr file_info(FileInformation::New());
-  file_info->size = static_cast<int64_t>(buf.st_size);
-  file_info->atime = Timespec::New();
-  file_info->mtime = Timespec::New();
-#if defined(OS_ANDROID)
-  file_info->atime->seconds = static_cast<int64_t>(buf.st_atime);
-  file_info->atime->nanoseconds = static_cast<int32_t>(buf.st_atime_nsec);
-  file_info->mtime->seconds = static_cast<int64_t>(buf.st_mtime);
-  file_info->mtime->nanoseconds = static_cast<int32_t>(buf.st_mtime_nsec);
-#else
-  file_info->atime->seconds = static_cast<int64_t>(buf.st_atim.tv_sec);
-  file_info->atime->nanoseconds = static_cast<int32_t>(buf.st_atim.tv_nsec);
-  file_info->mtime->seconds = static_cast<int64_t>(buf.st_mtim.tv_sec);
-  file_info->mtime->nanoseconds = static_cast<int32_t>(buf.st_mtim.tv_nsec);
-#endif
-
-  callback.Run(ERROR_OK, file_info.Pass());
+  StatFD(file_fd_.get(), callback);
 }
 
 void FileImpl::Truncate(int64_t size, const Callback<void(Error)>& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED);
     return;
   }
   if (size < 0) {
     callback.Run(ERROR_INVALID_ARGUMENT);
     return;
@@ skipping 11 matching lines @@
   callback.Run(ERROR_OK);
 }
 
 void FileImpl::Touch(TimespecOrNowPtr atime,
                      TimespecOrNowPtr mtime,
                      const Callback<void(Error)>& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED);
     return;
   }
-
-  struct timespec times[2];
-  if (Error error = TimespecOrNowToStandardTimespec(atime.get(), &times[0])) {
-    callback.Run(error);
-    return;
-  }
-  if (Error error = TimespecOrNowToStandardTimespec(mtime.get(), &times[1])) {
-    callback.Run(error);
-    return;
-  }
-
-  if (futimens(file_fd_.get(), times) != 0) {
-    callback.Run(ErrnoToError(errno));
-    return;
-  }
-
-  callback.Run(ERROR_OK);
+  TouchFD(file_fd_.get(), atime.Pass(), mtime.Pass(), callback);
 }
 
 void FileImpl::Dup(InterfaceRequest<File> file,
                    const Callback<void(Error)>& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED);
     return;
   }
 
   base::ScopedFD file_fd(dup(file_fd_.get()));
@@ skipping 26 matching lines @@
     return;
   }
 
   // TODO(vtl): FIXME soon
   NOTIMPLEMENTED();
   callback.Run(ERROR_UNIMPLEMENTED, ScopedSharedBufferHandle());
 }
 
 }  // namespace files
 }  // namespace mojo