[dart:io] Namespaces for file IO

runtime/bin/namespace.h

+// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#ifndef RUNTIME_BIN_NAMESPACE_H_
+#define RUNTIME_BIN_NAMESPACE_H_
+
+#include "bin/builtin.h"
+#include "bin/dartutils.h"
+#include "bin/log.h"
+#include "bin/reference_counting.h"
+
+namespace dart {
+namespace bin {
+
+class Namespace : public ReferenceCounted<Namespace> {
+ public:
+  // Assumes namespc is a value that can be directly used as namespc_.
+  static Namespace* Create(intptr_t namespc) { return new Namespace(namespc); }
+
+  // Uses path to compute a value that can be used as namespc_.
+  static Namespace* Create(const char* path);
+
+  // Gives a safe default value for namespc_ for the standalone Dart VM.
+  static intptr_t Default();
+
+  // Tells whether the given namespace is the default namespace.
+  static bool IsDefault(Namespace* namespc);
+
+  // Returns the native namespace wrapper if the argument at the supplied index
+  // is a _NamespaceImpl object. If it is not, calls Dart_PropagateError().
+  static Namespace* GetNamespace(Dart_NativeArguments args, intptr_t index);
+
+  // Get and set the current working directory through the namespace if there
+  // is one.
+  static const char* GetCurrent(Namespace* namespc);
+  static bool SetCurrent(Namespace* namespc, const char* path);
+
+  intptr_t namespc() const { return namespc_; }
+
+ private:
+  // When namespc_ has this value, it indicates that there is currently
+  // no namespace for resolving absolute paths.
+  static const intptr_t kNone = 0;
+
+  explicit Namespace(intptr_t namespc)
+      : ReferenceCounted(), namespc_(namespc) {}
+
+  ~Namespace();
+
+  // When the native argument at |index| is a _NamespaceImpl object,
+  // write the valueof its native field into |namespc|.
+  static Dart_Handle GetNativeNamespaceArgument(Dart_NativeArguments args,
+                                                intptr_t index,
+                                                Namespace** namespc);
+
+  // Given a namespace and a path, computes the information needed to access the
+  // path relative to the namespace. This can include massaging the path and
+  // returning a platform specific value in dirfd that together are used to
+  // access the path. Returns true if the caller should take ownership of
+  // dirfd, and false if the namespace retains ownership of dirfd.
+  static bool ResolvePath(Namespace* namespc,
+                          const char* path,
+                          intptr_t* dirfd,
+                          const char** resolved_path);
+
+  intptr_t namespc_;
+  // TODO(zra): When Isolate-specific cwds are added, we'll need some more
+  // fields here to track them.
+
+  friend class NamespaceScope;
+  friend class ReferenceCounted<Namespace>;
+  DISALLOW_COPY_AND_ASSIGN(Namespace);
+};
+
+class NamespaceScope {
+ public:
+  NamespaceScope(Namespace* namespc, const char* path);
+  ~NamespaceScope();
+
+  intptr_t fd() const { return fd_; }
+  const char* path() const { return path_; }
+
+ private:
+  intptr_t fd_;
+  const char* path_;
+  bool owns_fd_;
+
+  DISALLOW_ALLOCATION();
+  DISALLOW_COPY_AND_ASSIGN(NamespaceScope);
+};
+
+}  // namespace bin
+}  // namespace dart
+
+#endif  // RUNTIME_BIN_NAMESPACE_H_