Fix deferred load errors / bug #26482

runtime/bin/loader.cc

 // Copyright (c) 2016, 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/loader.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/extensions.h"
@@ skipping 194 matching lines @@
     if (pending_operations_ == 0) {
       break;
     }
 
     // Wait to be notified about new I/O results.
     ml.Wait();
   }
 }
 
 
+static bool LibraryHandleError(Dart_Handle library, Dart_Handle error) {
+  if (!Dart_IsNull(library) && !Dart_IsError(library)) {
+    ASSERT(Dart_IsLibrary(library));
+    Dart_Handle res = Dart_LibraryHandleError(library, error);
+    if (Dart_IsNull(res)) {
+      // Error was handled by library.
+      return true;
+    }
+  }
+  return false;
+}
+
+
 bool Loader::ProcessResultLocked(Loader::IOResult* result) {
-  // A negative result tag indicates a loading error occurred in the service
-  // isolate. The payload is a C string of the error message.
-  if (result->tag < 0) {
-    error_ =
-        Dart_NewUnhandledExceptionError(
-            Dart_NewStringFromUTF8(result->payload,
-                                   result->payload_length));
-
-    return false;
-  }
-
   // We have to copy everything we care about out of |result| because after
   // dropping the lock below |result| may no longer valid.
   Dart_Handle uri =
       Dart_NewStringFromCString(reinterpret_cast<char*>(result->uri));
   Dart_Handle library_uri = Dart_Null();
   if (result->library_uri != NULL) {
     library_uri =
         Dart_NewStringFromCString(reinterpret_cast<char*>(result->library_uri));
   }
+
+  // A negative result tag indicates a loading error occurred in the service
+  // isolate. The payload is a C string of the error message.
+  if (result->tag < 0) {
+    Dart_Handle library = Dart_LookupLibrary(uri);
+    Dart_Handle error = Dart_NewStringFromUTF8(result->payload,
+                                               result->payload_length);
+    // If a library with the given uri exists, give it a chance to handle
+    // the error. If the load requests stems from a deferred library load,
+    // an IO error is not fatal.
+    if (LibraryHandleError(library, error)) {
+      return true;
+    }
+    // Fall through
+    error_ = Dart_NewUnhandledExceptionError(error);
+    return false;
+  }
+
+
   // Check for payload and load accordingly.
   bool is_snapshot = false;
   const uint8_t* payload = result->payload;
   intptr_t payload_length = result->payload_length;
   payload =
       DartUtils::SniffForMagicNumber(payload,
                                      &payload_length,
                                      &is_snapshot);
   Dart_Handle source = Dart_Null();
   if (!is_snapshot) {
@@ skipping 149 matching lines @@
 
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   ASSERT(isolate_data != NULL);
 
   // Grab this isolate's loader.
   Loader* loader = NULL;
 
   // The outer invocation of the tag handler for this isolate. We make the outer
   // invocation block and allow any nested invocations to operate in parallel.
-  bool blocking_call = !isolate_data->HasLoader();
+  const bool blocking_call = !isolate_data->HasLoader();
 
+  // If we are the outer invocation of the tag handler and the tag is an import
+  // this means that we are starting a deferred library load.
+  const bool is_deferred_import = blocking_call && (tag == Dart_kImportTag);
   if (!isolate_data->HasLoader()) {
     // The isolate doesn't have a loader -- this is the outer invocation which
     // will block.
 
     // Setup the loader. The constructor does a bunch of leg work.
     loader = new Loader(isolate_data);
     loader->Init(isolate_data->package_root,
                  isolate_data->packages_file,
                  DartUtils::original_working_directory,
                  (tag == Dart_kScriptTag) ? url_string : NULL);
@@ skipping 16 matching lines @@
     // The outer invocation of the tag handler will block here until all nested
     // invocations complete.
     loader->BlockUntilComplete();
 
     // Remember the error (if any).
     Dart_Handle error = loader->error();
     // Destroy the loader. The destructor does a bunch of leg work.
     delete loader;
 
     // An error occurred during loading.
-    if (Dart_IsError(error)) {
-      return error;
+    if (!Dart_IsNull(error)) {
+      if (false && is_deferred_import) {
+        // This blocks handles transitive load errors caused by a deferred
+        // import. Non-transitive load errors are handled above (see callers of
+        // |LibraryHandleError|). To handle the transitive case, we give the
+        // originating deferred library an opportunity to handle it.
+        Dart_Handle deferred_library = Dart_LookupLibrary(url);
+        if (!LibraryHandleError(deferred_library, error)) {
+          // Library did not handle it, return to caller as an unhandled
+          // exception.
+          return Dart_NewUnhandledExceptionError(error);
+        }
+      } else {
+        // We got an error during loading but we aren't loading a deferred
+        // library, return the error to the caller.
+        return error;
+      }
     }
 
     // Finalize loading. This will complete any futures for completed deferred
     // loads.
     error = Dart_FinalizeLoading(true);
     if (Dart_IsError(error)) {
       return error;
     }
   }
   return Dart_Null();
@@ skipping 121 matching lines @@
   MutexLocker ml(&loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart