Add "checked" parameter to Isolate.spawnUri.

runtime/vm/isolate.h

 // 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.
 
 #ifndef VM_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/base_isolate.h"
@@ skipping 365 matching lines @@
 
   void set_single_step(bool value) { single_step_ = value; }
   bool single_step() const { return single_step_; }
   static intptr_t single_step_offset() {
     return OFFSET_OF(Isolate, single_step_);
   }
 
   void set_has_compiled(bool value) { has_compiled_ = value; }
   bool has_compiled() const { return has_compiled_; }
 
   void set_strict_compilation(bool value) { strict_compilation_ = value; }

[Ivan Posva, 2015/05/29 15:18:17]

I know this is not from your change. "strict compilation" is not a concept the
VM really knows. What we are interested in here is are assertions enabled and
are type checks enabled. We should split these two up similarly to the two flags
that can be given to the VM.

If no override is given when spawning an isolate these two values should be
inherited independently.

[Lasse Reichstein Nielsen, 2015/06/02 15:26:44]

I'll leave that for a later CL.

   bool strict_compilation() const { return strict_compilation_; }
   bool TypeChecksEnabled() {
     return FLAG_enable_type_checks || strict_compilation_;
   }
   bool AssertsEnabled() {
     return FLAG_enable_asserts || strict_compilation_;
   }
   bool ErrorOnBadTypeEnabled() {
     return FLAG_error_on_bad_type || strict_compilation_;
   }
@@ skipping 528 matching lines @@
  public:
   IsolateSpawnState(Dart_Port parent_port,
                     const Function& func,
                     const Instance& message,
                     bool paused);
   IsolateSpawnState(Dart_Port parent_port,
                     const char* script_url,
                     const char* package_root,
                     const Instance& args,
                     const Instance& message,
-                    bool paused);
+                    bool paused,
+                    bool checked);
   ~IsolateSpawnState();
 
   Isolate* isolate() const { return isolate_; }
   void set_isolate(Isolate* value) { isolate_ = value; }
 
   Dart_Port parent_port() const { return parent_port_; }
   char* script_url() const { return script_url_; }
   char* package_root() const { return package_root_; }
   char* library_url() const { return library_url_; }
   char* class_name() const { return class_name_; }
   char* function_name() const { return function_name_; }
   bool is_spawn_uri() const { return library_url_ == NULL; }
   bool paused() const { return paused_; }
+  bool checked_mode() const { return checked_; }
 
   RawObject* ResolveFunction();
   RawInstance* BuildArgs(Zone* zone);
   RawInstance* BuildMessage(Zone* zone);
   void Cleanup();
 
  private:
   Isolate* isolate_;
   Dart_Port parent_port_;
   char* script_url_;
   char* package_root_;
   char* library_url_;
   char* class_name_;
   char* function_name_;
   uint8_t* serialized_args_;
   intptr_t serialized_args_len_;
   uint8_t* serialized_message_;
   intptr_t serialized_message_len_;
   bool paused_;
+  bool checked_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_