Fix http://dartbug.com/23578:

runtime/vm/dart_api_impl.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.
 
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 1269 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, "%s$%s", script_uri, main) + 1;
   chars = reinterpret_cast<char*>(malloc(len));
   OS::SNPrint(chars, len, "%s$%s", script_uri, main);
   return chars;
 }
 
 
 DART_EXPORT Dart_Isolate Dart_CreateIsolate(const char* script_uri,
                                             const char* main,
                                             const uint8_t* snapshot,
+                                            Dart_IsolateFlags* flags,
                                             void* callback_data,
                                             char** error) {
   CHECK_NO_ISOLATE(Isolate::Current());
   char* isolate_name = BuildIsolateName(script_uri, main);
   Thread::EnsureInit();
-  Isolate* isolate = Dart::CreateIsolate(isolate_name);
+
+  // Setup default flags in case none were passed.
+  Dart_IsolateFlags api_flags;
+  if (flags == NULL) {
+    Isolate::Flags vm_flags;
+    vm_flags.CopyTo(&api_flags);
+    flags = &api_flags;
+  }
+  Isolate* isolate = Dart::CreateIsolate(isolate_name, *flags);
   free(isolate_name);
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   // We enter an API scope here as InitializeIsolate could compile some
   // bootstrap library files which call out to a tag handler that may create
   // Api Handles when an error is encountered.
   Dart_EnterScope();
   const Error& error_obj =
       Error::Handle(isolate, Dart::InitializeIsolate(snapshot, callback_data));
   if (error_obj.IsNull()) {
@@ skipping 92 matching lines @@
   profiler_data->Unblock();
 }
 
 
 DART_EXPORT void Dart_ExitIsolate() {
   CHECK_ISOLATE(Isolate::Current());
   Thread::ExitIsolate();
 }
 
 
+// TODO(iposva): Remove this API and instead expose the underlying flags.
 DART_EXPORT Dart_Handle Dart_IsolateSetStrictCompilation(bool value) {
   CHECK_ISOLATE(Isolate::Current());
   Isolate* isolate = Isolate::Current();
   if (isolate->has_compiled()) {
     return Api::NewError(
         "%s expects that the isolate has not yet compiled code.", CURRENT_FUNC);
   }
-  Isolate::Current()->set_strict_compilation(value);
+  if (!value) {
+    return Api::NewError(
+        "%s expects that the value is set to true only.", CURRENT_FUNC);
+  }
+  Isolate::Current()->set_strict_compilation();
   return Api::Null();
 }
 
 
 static uint8_t* ApiReallocate(uint8_t* ptr,
                               intptr_t old_size,
                               intptr_t new_size) {
   return Api::TopScope(Isolate::Current())->zone()->Realloc<uint8_t>(
       ptr, old_size, new_size);
 }
@@ skipping 2566 matching lines @@
                                     Dart_Handle name,
                                     int number_of_arguments,
                                     Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   // TODO(turnidge): This is a bit simplistic.  It overcounts when
   // other operations (gc, compilation) are active.
   TIMERSCOPE(isolate, time_dart_execution);
 
-  isolate->set_has_compiled(true);
-
   const String& function_name = Api::UnwrapStringHandle(isolate, name);
   if (function_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, name, String);
   }
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
@@ skipping 1567 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart