Prototype of Files service.

services/files/files_impl.cc

Index: services/files/files_impl.cc
diff --git a/services/files/files_impl.cc b/services/files/files_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e43d5770af731411c9d4bc78d6262cde123a9827
--- /dev/null
+++ b/services/files/files_impl.cc
@@ -0,0 +1,98 @@
+// 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/files_impl.h"
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "services/files/directory_impl.h"
+
+namespace mojo {
+namespace files {
+
+namespace {
+
+base::ScopedFD CreateAndOpenTemporaryDirectory(base::FilePath* temp_dir_name) {
+  DCHECK(temp_dir_name);
+  CHECK(base::CreateNewTempDirectory(base::FilePath::StringType(),
+                                     temp_dir_name));
+  base::ScopedFD temp_dir_fd(HANDLE_EINTR(
+      open(temp_dir_name->value().c_str(), O_RDONLY | O_DIRECTORY, 0)));
+  PCHECK(temp_dir_fd.is_valid());
+  DVLOG(1) << "Made a temporary directory: " << temp_dir_name->value();
+  return temp_dir_fd.Pass();
+}
+
+#ifndef NDEBUG
+base::ScopedFD OpenMojoDebugDirectory() {
+  const char* home_dir_name = getenv("HOME");
+  if (!home_dir_name || !home_dir_name[0]) {
+    LOG(ERROR) << "HOME not set";
+    return base::ScopedFD();
+  }
+  base::FilePath mojo_debug_dir_name =
+      base::FilePath(home_dir_name).Append("MojoDebug");
+  return base::ScopedFD(HANDLE_EINTR(
+      open(mojo_debug_dir_name.value().c_str(), O_RDONLY | O_DIRECTORY, 0)));
+}
+#endif
+
+}  // namespace
+
+FilesImpl::FilesImpl(ApplicationConnection* connection,
+                     InterfaceRequest<Files> request)
+    : binding_(this, request.Pass()) {
+  // TODO(vtl): record other app's URL
+}
+
+FilesImpl::~FilesImpl() {
+}
+
+void FilesImpl::OpenFileSystem(FileSystem file_system,
+                               InterfaceRequest<Directory> directory,
+                               const Callback<void(Error)>& callback) {
+  base::ScopedFD dir_fd;
+  // Set only if the |DirectoryImpl| will own this directory (and should delete
+  // it on destruction).
+  base::FilePath owned_dir_name;
+  switch (file_system) {
+    case FILE_SYSTEM_TEMPORARY:
+      // TODO(vtl): ScopedGeneric (hence ScopedFD) doesn't have an operator=!
+      dir_fd.reset(CreateAndOpenTemporaryDirectory(&owned_dir_name).release());
+      DCHECK(!owned_dir_name.empty());
+      break;
+    case FILE_SYSTEM_DEBUG:
+#ifdef NDEBUG
+      LOG(WARNING) << "~/MojoDebug only available in Debug builds";

[qsr, 2015/03/02 12:46:40]

You should call the callback, otherwise client will not be notified.

[qsr, 2015/03/03 11:56:44]

You didn't change this -> I really think this should be modified to call the
callback with an error here. As it is now, you fill create a Directory with a
null directory fd, but still return a ERROR_OK.

[viettrungluu, 2015/03/03 18:50:35]

Oops, missed your previous comment. Sorry.

I had meant to put the #endif after the dir_fd.reset(). Fixed.

+#else
+      // TODO(vtl): ScopedGeneric (hence ScopedFD) doesn't have an operator=!
+      dir_fd.reset(OpenMojoDebugDirectory().release());
+      if (!dir_fd.is_valid()) {
+        LOG(ERROR) << "~/MojoDebug unavailable";
+        callback.Run(ERROR_UNAVAILABLE);
+        return;
+      }
+#endif
+      break;
+    default:
+      LOG(ERROR) << "Unknown file system type: " << file_system;
+      callback.Run(ERROR_UNIMPLEMENTED);
+      return;
+  }
+
+  new DirectoryImpl(directory.Pass(), dir_fd.Pass(), owned_dir_name);
+  callback.Run(ERROR_OK);
+}
+
+}  // namespace files
+}  // namespace mojo