- reorganize DartUtils::PrepareForScriptLoading so that it does not have the wait for service load …

runtime/bin/dartutils.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 "bin/dartutils.h"
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
 #include "include/dart_native_api.h"
 
@@ skipping 287 matching lines @@
     ASSERT(td_len == len);
     ASSERT(td_data != NULL);
     memmove(td_data, buffer, td_len);
     result = Dart_TypedDataReleaseData(array);
     RETURN_IF_ERROR(result);
   }
   return array;
 }
 
 
-Dart_Handle DartUtils::SetWorkingDirectory(Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::SetWorkingDirectory() {
+  IsolateData* isolate_data =

[zra, 2016/02/04 04:12:41]

This pattern is repeated a lot. Maybe something like this would useful:

Dart_Handle DartUtils::BuiltinLib() {
  IsolateData* isolate_data =
    reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
  return isolate_data->builtin_lib();
}

[siva, 2016/02/04 16:59:00]

Done.

+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  Dart_Handle builtin_lib = isolate_data->builtin_lib();
   Dart_Handle directory = NewString(original_working_directory);

[zra, 2016/02/04 04:12:41]

RETURN_IF_ERROR(directory)

Sometimes we check the result of NewString to see if it's an error and sometimes
we don't. I suspect that checking all of them is the safer bet so that we don't
end up going back into Dart code after we could have detected e.g. an OOM
exception.

Maybe not in this CL, though.

[siva, 2016/02/04 16:59:00]

NewString is used in a number of places sometimes inline as a parameter, it is
going to require a lot of changes. Maybe another CL or a cleanup when time
permits.

   return SingleArgDart_Invoke(builtin_lib, "_setWorkingDirectory", directory);
 }
 
 
-Dart_Handle DartUtils::ResolveUriInWorkingDirectory(Dart_Handle script_uri,
-                                                    Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::ResolveUriInWorkingDirectory(Dart_Handle script_uri) {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  Dart_Handle builtin_lib = isolate_data->builtin_lib();
   const int kNumArgs = 1;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = script_uri;
   return Dart_Invoke(builtin_lib,
                      NewString("_resolveInWorkingDirectory"),
                      kNumArgs,
                      dart_args);
 }
 
 
-Dart_Handle DartUtils::FilePathFromUri(Dart_Handle script_uri,
-                                       Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::FilePathFromUri(Dart_Handle script_uri) {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  Dart_Handle builtin_lib = isolate_data->builtin_lib();
   const int kNumArgs = 1;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = script_uri;
   return Dart_Invoke(builtin_lib,
                      NewString("_filePathFromUri"),
                      kNumArgs,
                      dart_args);
 }
 
 
-Dart_Handle DartUtils::ExtensionPathFromUri(Dart_Handle extension_uri,
-                                            Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::ExtensionPathFromUri(Dart_Handle extension_uri) {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  Dart_Handle builtin_lib = isolate_data->builtin_lib();
   const int kNumArgs = 1;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = extension_uri;
   return Dart_Invoke(builtin_lib,
                      NewString("_extensionPathFromUri"),
                      kNumArgs,
                      dart_args);
 }
 
 
-Dart_Handle DartUtils::ResolveUri(Dart_Handle library_url,
-                                  Dart_Handle url,
-                                  Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::ResolveUri(Dart_Handle library_url, Dart_Handle url) {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  Dart_Handle builtin_lib = isolate_data->builtin_lib();
   const int kNumArgs = 2;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = library_url;
   dart_args[1] = url;
   return Dart_Invoke(
       builtin_lib, NewString("_resolveUri"), kNumArgs, dart_args);
 }
 
 
 static Dart_Handle LoadDataAsync_Invoke(Dart_Handle tag,
                                         Dart_Handle url,
-                                        Dart_Handle library_url,
-                                        Dart_Handle builtin_lib) {
+                                        Dart_Handle library_url) {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  Dart_Handle builtin_lib = isolate_data->builtin_lib();
   const int kNumArgs = 3;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = tag;
   dart_args[1] = url;
   dart_args[2] = library_url;
   return Dart_Invoke(builtin_lib,
                      DartUtils::NewString("_loadDataAsync"),
                      kNumArgs,
                      dart_args);
 }
@@ skipping 24 matching lines @@
   bool is_io_library = DartUtils::IsDartIOLibURL(library_url_string);
 
   // Handle URI canonicalization requests.
   if (tag == Dart_kCanonicalizeUrl) {
     // If this is a Dart Scheme URL or 'part' of a io library
     // then it is not modified as it will be handled internally.
     if (is_dart_scheme_url || is_io_library) {
       return url;
     }
     // Resolve the url within the context of the library's URL.
-    Dart_Handle builtin_lib =
-        Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
-    RETURN_IF_ERROR(builtin_lib);
-    return ResolveUri(library_url, url, builtin_lib);
+    return ResolveUri(library_url, url);
   }
 
   // Handle 'import' of dart scheme URIs (i.e they start with 'dart:').
   if (is_dart_scheme_url) {
     if (tag == Dart_kImportTag) {
       // Handle imports of other built-in libraries present in the SDK.
       if (DartUtils::IsDartIOLibURL(url_string)) {
         return Builtin::LoadLibrary(url, Builtin::kIOLibrary);
       }
       return NewError("The built-in library '%s' is not available"
@@ skipping 16 matching lines @@
       return Dart_LoadSource(
           library,
           part_uri_obj,
           Builtin::PartSource(Builtin::kIOLibrary, url_string), 0, 0);
     } else {
       ASSERT(tag == Dart_kImportTag);
       return NewError("Unable to import '%s' ", url_string);
     }
   }
 
-  Dart_Handle builtin_lib =
-      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
-  RETURN_IF_ERROR(builtin_lib);
   if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
     // Load a native code shared library to use in a native extension
     if (tag != Dart_kImportTag) {
       return NewError("Dart extensions must use import: '%s'", url_string);
     }
-    Dart_Handle path_parts = DartUtils::ExtensionPathFromUri(url, builtin_lib);
+    Dart_Handle path_parts = DartUtils::ExtensionPathFromUri(url);
     if (Dart_IsError(path_parts)) {
       return path_parts;
     }
     const char* extension_directory = NULL;
     Dart_StringToCString(Dart_ListGetAt(path_parts, 0), &extension_directory);
     const char* extension_filename = NULL;
     Dart_StringToCString(Dart_ListGetAt(path_parts, 1), &extension_filename);
     const char* extension_name = NULL;
     Dart_StringToCString(Dart_ListGetAt(path_parts, 2), &extension_name);
 
     return Extensions::LoadExtension(extension_directory,
                                      extension_filename,
                                      extension_name,
                                      library);
   }
 
   // Handle 'import' or 'part' requests for all other URIs. Call dart code to
   // read the source code asynchronously.
-  return LoadDataAsync_Invoke(Dart_NewInteger(tag),
-                              url,
-                              library_url,
-                              builtin_lib);
+  return LoadDataAsync_Invoke(Dart_NewInteger(tag), url, library_url);
 }
 
 
 const uint8_t* DartUtils::SniffForMagicNumber(const uint8_t* text_buffer,
                                               intptr_t* buffer_len,
                                               bool* is_snapshot) {
   intptr_t len = sizeof(magic_number);
   if (*buffer_len <= len) {
     *is_snapshot = false;
     return text_buffer;
@@ skipping 11 matching lines @@
 }
 
 
 void DartUtils::WriteMagicNumber(File* file) {
   // Write a magic number and version information into the snapshot file.
   bool bytes_written = file->WriteFully(magic_number, sizeof(magic_number));
   ASSERT(bytes_written);
 }
 
 
-Dart_Handle DartUtils::LoadScript(const char* script_uri,
-                                  Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::LoadScript(const char* script_uri) {
   Dart_Handle uri = Dart_NewStringFromCString(script_uri);
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   Dart_TimelineAsyncBegin("LoadScript", &(isolate_data->load_async_id));
-  return LoadDataAsync_Invoke(Dart_Null(), uri, Dart_Null(), builtin_lib);
+  return LoadDataAsync_Invoke(Dart_Null(), uri, Dart_Null());
 }
 
 
 // Callback function, gets called from asynchronous script and library
 // reading code when there is an i/o error.
 void FUNCTION_NAME(Builtin_AsyncLoadError)(Dart_NativeArguments args) {
   //  Dart_Handle source_uri = Dart_GetNativeArgument(args, 0);
   Dart_Handle library_uri = Dart_GetNativeArgument(args, 1);
   Dart_Handle error = Dart_GetNativeArgument(args, 2);
 
@@ skipping 120 matching lines @@
   } else {
     Dart_Handle err = DartUtils::NewError("Failed to get current directory.");
     Dart_PropagateError(err);
   }
 }
 
 
 Dart_Handle DartUtils::PrepareBuiltinLibrary(Dart_Handle builtin_lib,
                                              Dart_Handle internal_lib,
                                              bool is_service_isolate,
-                                             bool trace_loading,
-                                             const char* package_root,
-                                             const char* packages_config) {
+                                             bool trace_loading) {
   // Setup the internal library's 'internalPrint' function.
   Dart_Handle print = Dart_Invoke(
       builtin_lib, NewString("_getPrintClosure"), 0, NULL);
   RETURN_IF_ERROR(print);
   Dart_Handle result =
       Dart_SetField(internal_lib, NewString("_printClosure"), print);
   RETURN_IF_ERROR(result);
 
   if (!is_service_isolate) {
     if (IsWindowsHost()) {
       result = Dart_SetField(builtin_lib, NewString("_isWindows"), Dart_True());
       RETURN_IF_ERROR(result);
     }
     if (trace_loading) {
       result = Dart_SetField(builtin_lib,
                              NewString("_traceLoading"), Dart_True());
       RETURN_IF_ERROR(result);
     }
     // Set current working directory.
-    result = SetWorkingDirectory(builtin_lib);
-    RETURN_IF_ERROR(result);
-    // Wait for the service isolate to initialize the load port.
-    Dart_Port load_port = Dart_ServiceWaitForLoadPort();
-    if (load_port == ILLEGAL_PORT) {
-      return Dart_NewUnhandledExceptionError(
-          NewDartUnsupportedError("Service did not return load port."));
-    }
-    result = Builtin::SetLoadPort(load_port);
-    RETURN_IF_ERROR(result);
-  }
-
-  // Set up package root if specified.
-  if (package_root != NULL) {
-    ASSERT(packages_config == NULL);
-    result = NewString(package_root);
-    RETURN_IF_ERROR(result);
-    const int kNumArgs = 1;
-    Dart_Handle dart_args[kNumArgs];
-    dart_args[0] = result;
-    result = Dart_Invoke(builtin_lib,
-                         NewString("_setPackageRoot"),
-                         kNumArgs,
-                         dart_args);
-    RETURN_IF_ERROR(result);
-  } else if (packages_config != NULL) {
-    result = NewString(packages_config);
-    RETURN_IF_ERROR(result);
-    const int kNumArgs = 1;
-    Dart_Handle dart_args[kNumArgs];
-    dart_args[0] = result;
-    result = Dart_Invoke(builtin_lib,
-                         NewString("_loadPackagesMap"),
-                         kNumArgs,
-                         dart_args);
+    result = SetWorkingDirectory();
     RETURN_IF_ERROR(result);
   }
   return Dart_True();
 }
 
 
 Dart_Handle DartUtils::PrepareCoreLibrary(Dart_Handle core_lib,
                                           Dart_Handle builtin_lib,
                                           bool is_service_isolate) {
   if (!is_service_isolate) {
@@ skipping 26 matching lines @@
 Dart_Handle DartUtils::PrepareIOLibrary(Dart_Handle io_lib) {
   return Dart_Invoke(io_lib, NewString("_setupHooks"), 0, NULL);
 }
 
 
 Dart_Handle DartUtils::PrepareIsolateLibrary(Dart_Handle isolate_lib) {
   return Dart_Invoke(isolate_lib, NewString("_setupHooks"), 0, NULL);
 }
 
 
-Dart_Handle DartUtils::PrepareForScriptLoading(const char* package_root,
-                                               const char* packages_config,
-                                               bool is_service_isolate,
-                                               bool trace_loading,
-                                               Dart_Handle builtin_lib) {
+Dart_Handle DartUtils::SetupServiceLoadPort() {
+  // Wait for the service isolate to initialize the load port.
+  Dart_Port load_port = Dart_ServiceWaitForLoadPort();
+  if (load_port == ILLEGAL_PORT) {
+    return Dart_NewUnhandledExceptionError(
+        NewDartUnsupportedError("Service did not return load port."));
+  }
+  return Builtin::SetLoadPort(load_port);
+}
+
+
+Dart_Handle DartUtils::SetupPackageRoot(const char* package_root,
+                                        const char* packages_config) {
+  // Set up package root if specified.
+  if (package_root != NULL) {
+    ASSERT(packages_config == NULL);
+    Dart_Handle result = NewString(package_root);
+    RETURN_IF_ERROR(result);
+    IsolateData* isolate_data =
+        reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+    Dart_Handle builtin_lib = isolate_data->builtin_lib();
+    const int kNumArgs = 1;
+    Dart_Handle dart_args[kNumArgs];
+    dart_args[0] = result;
+    result = Dart_Invoke(builtin_lib,
+                         NewString("_setPackageRoot"),
+                         kNumArgs,
+                         dart_args);
+    RETURN_IF_ERROR(result);
+  } else if (packages_config != NULL) {
+    Dart_Handle result = NewString(packages_config);
+    RETURN_IF_ERROR(result);
+    IsolateData* isolate_data =
+        reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+    Dart_Handle builtin_lib = isolate_data->builtin_lib();
+    const int kNumArgs = 1;
+    Dart_Handle dart_args[kNumArgs];
+    dart_args[0] = result;
+    result = Dart_Invoke(builtin_lib,
+                         NewString("_loadPackagesMap"),
+                         kNumArgs,
+                         dart_args);
+    RETURN_IF_ERROR(result);
+  }
+  return Dart_True();
+}
+
+
+Dart_Handle DartUtils::PrepareForScriptLoading(bool is_service_isolate,
+                                               bool trace_loading) {
   // First ensure all required libraries are available.
   Dart_Handle url = NewString(kCoreLibURL);
   RETURN_IF_ERROR(url);
   Dart_Handle core_lib = Dart_LookupLibrary(url);
   RETURN_IF_ERROR(core_lib);
   url = NewString(kAsyncLibURL);
   RETURN_IF_ERROR(url);
   Dart_Handle async_lib = Dart_LookupLibrary(url);
   RETURN_IF_ERROR(async_lib);
   url = NewString(kIsolateLibURL);
   RETURN_IF_ERROR(url);
   Dart_Handle isolate_lib = Dart_LookupLibrary(url);
   RETURN_IF_ERROR(isolate_lib);
   url = NewString(kInternalLibURL);
   RETURN_IF_ERROR(url);
   Dart_Handle internal_lib = Dart_LookupLibrary(url);
   RETURN_IF_ERROR(internal_lib);
+  Dart_Handle builtin_lib =
+      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
+  RETURN_IF_ERROR(builtin_lib);
   Dart_Handle io_lib = Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
   RETURN_IF_ERROR(io_lib);
 
+  // Setup the builtin library in a persistent handle attached the isolate
+  // specific data as we seem to lookup and use builtin lib a lot.
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  ASSERT(isolate_data != NULL);
+  isolate_data->set_builtin_lib(builtin_lib);
+
   // We need to ensure that all the scripts loaded so far are finalized
   // as we are about to invoke some Dart code below to setup closures.
   Dart_Handle result = Dart_FinalizeLoading(false);
   RETURN_IF_ERROR(result);
 
   result = PrepareBuiltinLibrary(builtin_lib,
                                  internal_lib,
                                  is_service_isolate,
-                                 trace_loading,
-                                 package_root,
-                                 packages_config);
+                                 trace_loading);
   RETURN_IF_ERROR(result);
 
   RETURN_IF_ERROR(PrepareAsyncLibrary(async_lib, isolate_lib));
   RETURN_IF_ERROR(PrepareCoreLibrary(
       core_lib, builtin_lib, is_service_isolate));
   RETURN_IF_ERROR(PrepareIsolateLibrary(isolate_lib));
   RETURN_IF_ERROR(PrepareIOLibrary(io_lib));
   return result;
 }
 
@@ skipping 454 matching lines @@
       new CObjectString(CObject::NewString(os_error->message()));
   CObjectArray* result = new CObjectArray(CObject::NewArray(3));
   result->SetAt(0, new CObjectInt32(CObject::NewInt32(kOSError)));
   result->SetAt(1, new CObjectInt32(CObject::NewInt32(os_error->code())));
   result->SetAt(2, error_message);
   return result;
 }
 
 }  // namespace bin
 }  // namespace dart