Wire up the stub native resolver for all libraries in gen_snapshot

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, 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.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <cstdarg>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
 #include "bin/file.h"
 #include "bin/loader.h"
 #include "bin/log.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
+#include "include/dart_tools_api.h"
 
 #include "platform/hashmap.h"
 #include "platform/globals.h"
 
 namespace dart {
 namespace bin {
 
 // Exit code indicating an API error.
 static const int kApiErrorExitCode = 253;
 // Exit code indicating a compilation error.
@@ skipping 642 matching lines @@
   }
   ASSERT(Dart_IsLibrary(library));
 }
 
 
 static const char StubNativeFunctionName[] = "StubNativeFunction";
 
 
 void StubNativeFunction(Dart_NativeArguments arguments) {
   // This is a stub function for the resolver
-  UNREACHABLE();
+  Dart_SetReturnValue(
+      arguments, Dart_NewApiError("<EMBEDDER DID NOT SETUP NATIVE RESOLVER>"));
 }
 
 
 static Dart_NativeFunction StubNativeLookup(Dart_Handle name,
                                             int argument_count,
                                             bool* auto_setup_scope) {
   return &StubNativeFunction;
 }
 
 
@@ skipping 30 matching lines @@
     library = Dart_LookupLibrary(library_string);
   }
 
   DART_CHECK_VALID(library);
   Dart_Handle result =
       Dart_SetNativeResolver(library, &StubNativeLookup, &StubNativeSymbol);
   DART_CHECK_VALID(result);
 }
 
 
+// Iterate over all libraries and setup the stub native lookup. This must be
+// run after |SetupStubNativeResolversForPrecompilation| because the former
+// loads some libraries.
+static void SetupStubNativeResolvers() {
+  Dart_Handle library_ids = Dart_GetLibraryIds();
+  intptr_t library_ids_length;
+  Dart_ListLength(library_ids, &library_ids_length);
+  for (intptr_t i = 0; i < library_ids_length; i++) {
+    Dart_Handle library_id_handle = Dart_ListGetAt(library_ids, i);
+    DART_CHECK_VALID(library_id_handle);
+    int64_t library_id;
+    Dart_IntegerToInt64(library_id_handle, &library_id);
+    Dart_Handle library = Dart_GetLibraryFromId(library_id);
+    DART_CHECK_VALID(library);
+    Dart_NativeEntryResolver old_resolver = NULL;
+    Dart_GetNativeResolver(library, &old_resolver);
+    if (old_resolver == NULL) {
+      Dart_Handle result =
+          Dart_SetNativeResolver(library, &StubNativeLookup, &StubNativeSymbol);
+      DART_CHECK_VALID(result);
+    }
+  }
+}
+
+
 static void ImportNativeEntryPointLibrariesIntoRoot(
     const Dart_QualifiedFunctionName* entries) {
   if (entries == NULL) {
     return;
   }
 
   size_t index = 0;
   while (true) {
     Dart_QualifiedFunctionName entry = entries[index++];
     if (entry.library_uri == NULL) {
@@ skipping 550 matching lines @@
       if (Dart_IsError(library)) FATAL("Failed to load app from Kernel IR");
     } else {
       // Set up the library tag handler in such a manner that it will use the
       // URL mapping specified on the command line to load the libraries.
       result = Dart_SetLibraryTagHandler(CreateSnapshotLibraryTagHandler);
       CHECK_RESULT(result);
     }
 
     SetupStubNativeResolversForPrecompilation(entry_points);
 
+    SetupStubNativeResolvers();
+
     if (!is_kernel_file) {
       // Load the specified script.
       library = LoadSnapshotCreationScript(app_script_name);
       VerifyLoaded(library);
 
       ImportNativeEntryPointLibrariesIntoRoot(entry_points);
     }
 
     // Ensure that we mark all libraries as loaded.
     result = Dart_FinalizeLoading(false);
@@ skipping 21 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }