- Move the Timer interface to the dart:isolate library so that it

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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 487 matching lines @@
   Dart_Isolate isolate =
       Dart_CreateIsolate(script_uri, main, snapshot_buffer, data, error);
   if (isolate == NULL) {
     return false;
   }
 
   Dart_EnterScope();
 
   if (snapshot_buffer != NULL) {
     // Setup the native resolver as the snapshot does not carry it.
-    Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
-    Builtin::SetNativeResolver(Builtin::kIOLibrary);
+    Builtin::SetupLibrary(Builtin::LoadLibrary(Builtin::kBuiltinLibrary),
+                          Builtin::kBuiltinLibrary);
+    Builtin::SetupLibrary(Builtin::LoadLibrary(Builtin::kIOLibrary),
+                          Builtin::kIOLibrary);

[siva, 2012/06/13 17:05:23]

I would prefer if we did a Dart_LookupLibrary here instead
of Builtin::LoadLibrary. We are expected to find the library here. If for some
reason there is a bug in the snapshot generation we want to assert out when the
library is not found instead of silently loading it.

[Ivan Posva, 2012/06/21 16:17:06]

Agreed, but this needs a whole restructuring of the Builtin loading code which
is not part of this change. Also you currently get an assert within
Builtin::LoadLibrary if the library is not found, even if this is not
necessarily the way you wanted to.

If we want to make this change then it should come together with a change to
reduce the standalone snapshot size and making some of the non-critical
libraries loadable from source.

   }
 
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(LibraryTagHandler);
   if (Dart_IsError(result)) {
     *error = strdup(Dart_GetError(result));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return false;
   }
@@ skipping 16 matching lines @@
     return false;
   }
   Dart_Handle builtin_lib = Builtin::LoadLibrary(Builtin::kBuiltinLibrary);
   if (Dart_IsError(builtin_lib)) {
     *error = strdup(Dart_GetError(builtin_lib));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return false;
   }
 
+  // Setup the IO library.
+  Dart_Handle io_lib = Builtin::LoadLibrary(Builtin::kIOLibrary);
+  Builtin::SetupIOLibrary(io_lib);
+
   if (package_root != NULL) {
     const int kNumArgs = 1;
     Dart_Handle dart_args[kNumArgs];
 
     Dart_Handle handle = Dart_NewString(package_root);
     if (Dart_IsError(handle)) {
       *error = strdup(Dart_GetError(handle));
       Dart_ExitScope();
       Dart_ShutdownIsolate();
       return false;
@@ skipping 226 matching lines @@
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   free(const_cast<char*>(original_working_directory));
 
   return 0;
 }