[dart:io] Namespaces for file IO

runtime/bin/main.cc

 // Copyright (c) 2012, 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.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 564 matching lines @@
   if (commandline_root_certs_file != NULL) {
     Log::PrintErr(
         "Only one of --root-certs-file and --root-certs-cache "
         "may be specified");
     return false;
   }
   commandline_root_certs_cache = arg;
   return true;
 }
 
+const char* commandline_namespace = NULL;
+static bool ProcessNamespaceOption(const char* arg,
+                                   CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg == '-') {
+    return false;
+  }
+  if (commandline_namespace != NULL) {
+    Log::PrintErr("Only one --namespace argument is allowed.");
+    return false;
+  }
+  commandline_namespace = arg;
+  return true;
+}
+
 static struct {
   const char* option_name;
   bool (*process)(const char* option, CommandLineOptions* vm_options);
 } main_options[] = {
     // Standard options shared with dart2js.
     {"-D", ProcessEnvironmentOption},
     {"-h", ProcessHelpOption},
     {"--help", ProcessHelpOption},
     {"--packages=", ProcessPackagesOption},
     {"--package-root=", ProcessPackageRootOption},
@@ skipping 21 matching lines @@
     {"--load-compilation-trace=", ProcessLoadCompilationTraceOption},
     {"--save-feedback=", ProcessSaveFeedbackOption},
     {"--load-feedback=", ProcessLoadFeedbackOption},
     {"--trace-loading", ProcessTraceLoadingOption},
     {"--hot-reload-test-mode", ProcessHotReloadTestModeOption},
     {"--hot-reload-rollback-test-mode", ProcessHotReloadRollbackTestModeOption},
     {"--short_socket_read", ProcessShortSocketReadOption},
     {"--short_socket_write", ProcessShortSocketWriteOption},
     {"--root-certs-file=", ProcessRootCertsFileOption},
     {"--root-certs-cache=", ProcessRootCertsCacheOption},
+    {"--namespace=", ProcessNamespaceOption},
     {NULL, NULL}};
 
 static bool ProcessMainOptions(const char* option,
                                CommandLineOptions* vm_options) {
   int i = 0;
   const char* name = main_options[0].option_name;
   int option_length = strlen(option);
   while (name != NULL) {
     int length = strlen(name);
     if ((option_length >= length) && (strncmp(option, name, length) == 0)) {
@@ skipping 269 matching lines @@
   CHECK_RESULT(result);
 
   // Setup package root if specified.
   result = DartUtils::SetupPackageRoot(package_root, packages_config);
   CHECK_RESULT(result);
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
   if (isolate_run_app_snapshot) {
-    result = DartUtils::SetupIOLibrary(script_uri);
+    result = DartUtils::SetupIOLibrary(commandline_namespace, script_uri);
     CHECK_RESULT(result);
     Loader::InitForSnapshot(script_uri);
 #if !defined(DART_PRECOMPILED_RUNTIME)
     if (is_main_isolate) {
       // Find the canonical uri of the app snapshot. We'll use this to decide if
       // other isolates should use the app snapshot or the core snapshot.
       const char* resolved_script_uri = NULL;
       result = Dart_StringToCString(
           DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri)),
           &resolved_script_uri);
@@ skipping 15 matching lines @@
       // relative URIs and perform other related tasks. We need Loader to be
       // initialized for this to work because loading from Kernel binary
       // bypasses normal source code loading paths that initialize it.
       Loader::InitForSnapshot(script_uri);
     }
 
     Dart_TimelineEvent("LoadScript", Dart_TimelineGetMicros(),
                        Dart_GetMainPortId(), Dart_Timeline_Event_Async_End, 0,
                        NULL, NULL);
 
-    result = DartUtils::SetupIOLibrary(script_uri);
+    result = DartUtils::SetupIOLibrary(commandline_namespace, script_uri);
     CHECK_RESULT(result);
   }
 
   // Make the isolate runnable so that it is ready to handle messages.
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   if (!retval) {
     *error = strdup("Invalid isolate state - Unable to make it runnable");
     Dart_EnterIsolate(isolate);
@@ skipping 351 matching lines @@
 "  (default port number is 8181, default bind address is localhost).\n"
 #if !defined(HOST_OS_MACOS)
 "\n"
 "--root-certs-file=<path>\n"
 "  The path to a file containing the trusted root certificates to use for\n"
 "  secure socket connections.\n"
 "--root-certs-cache=<path>\n"
 "  The path to a cache directory containing the trusted root certificates to\n"
 "  use for secure socket connections.\n"
 #endif  // !defined(HOST_OS_MACOS)
+#if defined(HOST_OS_LINUX)
+"--namespace=<path>\n"
+"  The path to a directory that dart:io calls will treat as the root of the\n"
+"  filesystem.\n"
+#endif  // defined(HOST_OS_LINUX)
 "\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
     const char* print_flags = "--print_flags";
     Dart_SetVMFlags(1, &print_flags);
   }
 }
 // clang-format on
 
 char* BuildIsolateName(const char* script_name, const char* func_name) {
@@ skipping 43 matching lines @@
   }
 }
 
 static bool FileModifiedCallback(const char* url, int64_t since) {
   if (strncmp(url, "file:///", 8) == 0) {
     // If it isn't a file on local disk, we don't know if it has been
     // modified.
     return true;
   }
   int64_t data[File::kStatSize];
-  File::Stat(url + 7, data);
+  File::Stat(NULL, url + 7, data);
   if (data[File::kType] == File::kDoesNotExist) {
     return true;
   }
   bool modified = data[File::kModifiedTime] > since;
   return modified;
 }
 
 static void EmbedderInformationCallback(Dart_EmbedderInformation* info) {
   info->version = DART_EMBEDDER_INFORMATION_CURRENT_VERSION;
   info->name = "Dart VM";
@@ skipping 12 matching lines @@
   if (Dart_IsError(result)) {                                                  \
     const int exit_code = Dart_IsCompilationError(result)                      \
                               ? kCompilationErrorExitCode                      \
                               : kErrorExitCode;                                \
     ErrorExit(exit_code, "%s\n", Dart_GetError(result));                       \
   }
 
 static void WriteFile(const char* filename,
                       const uint8_t* buffer,
                       const intptr_t size) {
-  File* file = File::Open(filename, File::kWriteTruncate);
+  File* file = File::Open(NULL, filename, File::kWriteTruncate);
   if (file == NULL) {
     ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
   }
   if (!file->WriteFully(buffer, size)) {
     ErrorExit(kErrorExitCode, "Unable to write file %s\n", filename);
   }
   file->Release();
 }
 
 static void ReadFile(const char* filename, uint8_t** buffer, intptr_t* size) {
-  File* file = File::Open(filename, File::kRead);
+  File* file = File::Open(NULL, filename, File::kRead);
   if (file == NULL) {
     ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
   }
   *size = file->Length();
   *buffer = reinterpret_cast<uint8_t*>(malloc(*size));
   if (!file->ReadFully(*buffer, *size)) {
     ErrorExit(kErrorExitCode, "Unable to read file %s\n", filename);
   }
   file->Release();
 }
@@ skipping 19 matching lines @@
     {"dart:io", "HandshakeException", "HandshakeException."},
     {"dart:io", "Link", "Link."},
     {"dart:io", "OSError", "OSError."},
     {"dart:io", "TlsException", "TlsException."},
     {"dart:io", "X509Certificate", "X509Certificate._"},
     {"dart:io", "_ExternalBuffer", "get:end"},
     {"dart:io", "_ExternalBuffer", "get:start"},
     {"dart:io", "_ExternalBuffer", "set:data"},
     {"dart:io", "_ExternalBuffer", "set:end"},
     {"dart:io", "_ExternalBuffer", "set:start"},
+    {"dart:io", "_Namespace", "_setupNamespace"},
     {"dart:io", "_Platform", "set:_nativeScript"},
     {"dart:io", "_ProcessStartStatus", "set:_errorCode"},
     {"dart:io", "_ProcessStartStatus", "set:_errorMessage"},
     {"dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE"},
     {"dart:io", "_SecureFilterImpl", "get:SIZE"},
     {"dart:io", "_SecureFilterImpl", "get:buffers"},
     {"dart:isolate", "::", "_getIsolateScheduleImmediateClosure"},
     {"dart:isolate", "::", "_setupHooks"},
     {"dart:isolate", "::", "_startMainIsolate"},
     {"dart:vmservice_io", "::", "main"},
@@ skipping 99 matching lines @@
       Dart_ExitScope();
       // Shutdown the isolate.
       Dart_ShutdownIsolate();
       return false;
     }
 
     if (gen_snapshot_kind == kAppAOT) {
       uint8_t* feedback_buffer = NULL;
       intptr_t feedback_length = 0;
       if (load_feedback_filename != NULL) {
-        File* file = File::Open(load_feedback_filename, File::kRead);
+        File* file = File::Open(NULL, load_feedback_filename, File::kRead);
         if (file == NULL) {
           ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
         }
         feedback_length = file->Length();
         feedback_buffer = reinterpret_cast<uint8_t*>(malloc(feedback_length));
         if (!file->ReadFully(feedback_buffer, feedback_length)) {
           ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
         }
         file->Release();
       }
@@ skipping 88 matching lines @@
     }
   }
 
   if (snapshot_deps_filename != NULL) {
     Loader::ResolveDependenciesAsFilePaths();
     IsolateData* isolate_data =
         reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
     ASSERT(isolate_data != NULL);
     MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
     ASSERT(dependencies != NULL);
-    File* file = File::Open(snapshot_deps_filename, File::kWriteTruncate);
+    File* file = File::Open(NULL, snapshot_deps_filename, File::kWriteTruncate);
     if (file == NULL) {
       ErrorExit(kErrorExitCode,
                 "Error: Unable to open snapshot depfile: %s\n\n",
                 snapshot_deps_filename);
     }
     bool success = true;
     success &= file->Print("%s: ", snapshot_filename);
     for (intptr_t i = 0; i < dependencies->length(); i++) {
       char* dep = dependencies->At(i);
       success &= file->Print("%s ", dep);
@@ skipping 213 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }