VM: Re-format to use at most one newline between functions

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 28 matching lines @@
             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;
@@ skipping 132 matching lines @@
                 error.ToErrorCString());
       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)) {
     // Not kernel isolate.
     return;
   }
   ASSERT(!Exists());
   if (FLAG_trace_kernel) {
     OS::Print(DART_KERNEL_ISOLATE_NAME ": InitCallback for %s.\n", I->name());
   }
   SetKernelIsolate(I);
 }
 
-
 bool KernelIsolate::IsKernelIsolate(const Isolate* isolate) {
   MonitorLocker ml(monitor_);
   return isolate == isolate_;
 }
 
-
 bool KernelIsolate::IsRunning() {
   MonitorLocker ml(monitor_);
   return (kernel_port_ != ILLEGAL_PORT) && (isolate_ != NULL);
 }
 
-
 bool KernelIsolate::Exists() {
   MonitorLocker ml(monitor_);
   return isolate_ != NULL;
 }
 
-
 void KernelIsolate::SetKernelIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   isolate_ = isolate;
 }
 
-
 void KernelIsolate::SetLoadPort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   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()
       : monitor_(new Monitor()),
         port_(Dart_NewNativePort("kernel-compilation-port",
                                  &HandleResponse,
                                  false)),
         next_(NULL),
         prev_(NULL) {
     ASSERT(port_ != ILLEGAL_PORT);
@@ skipping 187 matching lines @@
     result.status = Dart_KernelCompilationStatus_Unknown;
     result.error = strdup("Error while initializing Kernel isolate");
     return result;
   }
 
   KernelCompilationRequest request;
   return request.SendAndWaitForResponse(kernel_port, script_uri,
                                         source_file_count, source_files);
 }
 
-
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart