- Convert all isolate flags to a bit field.

runtime/vm/kernel_isolate.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 "vm/kernel_isolate.h"
 
 #include "bin/dartutils.h"
 #include "include/dart_native_api.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 13 matching lines @@
 #include "vm/timeline.h"
 
 namespace dart {
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #define Z (T->zone())
 
 DEFINE_FLAG(bool, trace_kernel, false, "Trace Kernel service requests.");
 DEFINE_FLAG(bool,
-            use_dart_frontend,
-            false,
-            "Parse scripts with Dart-to-Kernel parser");
-DEFINE_FLAG(bool,
             show_kernel_isolate,
             false,
             "Show Kernel service isolate as normal isolate.");
 
 const char* KernelIsolate::kName = DART_KERNEL_ISOLATE_NAME;
 Dart_IsolateCreateCallback KernelIsolate::create_callback_ = NULL;
 Monitor* KernelIsolate::monitor_ = new Monitor();
 Isolate* KernelIsolate::isolate_ = NULL;
 bool KernelIsolate::initializing_ = true;
 Dart_Port KernelIsolate::kernel_port_ = ILLEGAL_PORT;
 
 class RunKernelTask : public ThreadPool::Task {
  public:
   virtual void Run() {
     ASSERT(Isolate::Current() == NULL);
-
-    if (!FLAG_use_dart_frontend) {
-      ASSERT(FLAG_use_dart_frontend);
-      // In release builds, make this a no-op. In debug builds, the
-      // assert shows that this is not supposed to happen.
-      return;
-    }
-
 #ifndef PRODUCT
     TimelineDurationScope tds(Timeline::GetVMStream(), "KernelIsolateStartup");
 #endif  // !PRODUCT
     char* error = NULL;
     Isolate* isolate = NULL;
 
     Dart_IsolateCreateCallback create_callback =
         KernelIsolate::create_callback();
 
     if (create_callback == NULL) {
@@ skipping 121 matching lines @@
       return false;
     }
     ASSERT(result.IsReceivePort());
     const ReceivePort& rp = ReceivePort::Cast(result);
     KernelIsolate::SetLoadPort(rp.Id());
     return true;
   }
 };
 
 void KernelIsolate::Run() {
-  if (!FLAG_use_dart_frontend) {
-    return;
-  }
   // Grab the isolate create callback here to avoid race conditions with tests
   // that change this after Dart_Initialize returns.
   create_callback_ = Isolate::CreateCallback();
   Dart::thread_pool()->Run(new RunKernelTask());
 }
 
 void KernelIsolate::InitCallback(Isolate* I) {
   Thread* T = Thread::Current();
   ASSERT(I == T->isolate());
   ASSERT(I != NULL);
   ASSERT(I->name() != NULL);
-  if (!FLAG_use_dart_frontend ||
-      (strstr(I->name(), DART_KERNEL_ISOLATE_NAME) == NULL)) {
+  if (strstr(I->name(), DART_KERNEL_ISOLATE_NAME) == NULL) {
     // Not kernel isolate.
     return;
   }
   ASSERT(!Exists());
   if (FLAG_trace_kernel) {
     OS::Print(DART_KERNEL_ISOLATE_NAME ": InitCallback for %s.\n", I->name());
   }
   SetKernelIsolate(I);
 }
 
@@ skipping 22 matching lines @@
   kernel_port_ = port;
 }
 
 void KernelIsolate::FinishedInitializing() {
   MonitorLocker ml(monitor_);
   initializing_ = false;
   ml.NotifyAll();
 }
 
 Dart_Port KernelIsolate::WaitForKernelPort() {
-  if (!FLAG_use_dart_frontend) {
-    return ILLEGAL_PORT;
-  }
   MonitorLocker ml(monitor_);
   while (initializing_ && (kernel_port_ == ILLEGAL_PORT)) {
     ml.Wait();
   }
   return kernel_port_;
 }
 
 class KernelCompilationRequest : public ValueObject {
  public:
   KernelCompilationRequest()
@@ skipping 197 matching lines @@
   }
 
   KernelCompilationRequest request;
   return request.SendAndWaitForResponse(kernel_port, script_uri,
                                         source_file_count, source_files);
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart