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

runtime/bin/vmservice_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 "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
@@ skipping 74 matching lines @@
     return NULL;
   }
   static ResourcesEntry* ResourcesTable() {
     return &__service_bin_resources_[0];
   }
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Resources);
 };
 
-
 void NotifyServerState(Dart_NativeArguments args) {
   Dart_EnterScope();
   const char* uri_chars;
   Dart_Handle uri_arg = Dart_GetNativeArgument(args, 0);
   if (Dart_IsError(uri_arg)) {
     VmService::SetServerAddress("");
     Dart_ExitScope();
     return;
   }
   Dart_Handle result = Dart_StringToCString(uri_arg, &uri_chars);
   if (Dart_IsError(result)) {
     VmService::SetServerAddress("");
     Dart_ExitScope();
     return;
   }
   VmService::SetServerAddress(uri_chars);
   Dart_ExitScope();
 }
 
-
 static void Shutdown(Dart_NativeArguments args) {
   // NO-OP.
 }
 
-
 struct VmServiceIONativeEntry {
   const char* name;
   int num_arguments;
   Dart_NativeFunction function;
 };
 
-
 static VmServiceIONativeEntry _VmServiceIONativeEntries[] = {
     {"VMServiceIO_NotifyServerState", 1, NotifyServerState},
     {"VMServiceIO_Shutdown", 0, Shutdown},
 };
 
-
 static Dart_NativeFunction VmServiceIONativeResolver(Dart_Handle name,
                                                      int num_arguments,
                                                      bool* auto_setup_scope) {
   const char* function_name = NULL;
   Dart_Handle result = Dart_StringToCString(name, &function_name);
   ASSERT(!Dart_IsError(result));
   ASSERT(function_name != NULL);
   *auto_setup_scope = true;
   intptr_t n =
       sizeof(_VmServiceIONativeEntries) / sizeof(_VmServiceIONativeEntries[0]);
   for (intptr_t i = 0; i < n; i++) {
     VmServiceIONativeEntry entry = _VmServiceIONativeEntries[i];
     if ((strcmp(function_name, entry.name) == 0) &&
         (num_arguments == entry.num_arguments)) {
       return entry.function;
     }
   }
   return NULL;
 }
 
-
 const char* VmService::error_msg_ = NULL;
 char VmService::server_uri_[kServerUriStringBufferSize];
 
-
 bool VmService::LoadForGenPrecompiled(void* vmservice_kernel) {
   Dart_Handle result;
   Dart_SetLibraryTagHandler(LibraryTagHandler);
   Dart_Handle library;
   if (vmservice_kernel != NULL) {
     library = Dart_LoadLibrary(
         Dart_NewStringFromCString(kVMServiceIOLibraryUri), Dart_Null(),
         reinterpret_cast<Dart_Handle>(vmservice_kernel), 0, 0);
   } else {
     library = LookupOrLoadLibrary(kVMServiceIOLibraryScriptResourceName);
   }
   ASSERT(library != Dart_Null());
   SHUTDOWN_ON_ERROR(library);
   result = Dart_SetNativeResolver(library, VmServiceIONativeResolver, NULL);
   SHUTDOWN_ON_ERROR(result);
   result = Dart_FinalizeLoading(false);
   SHUTDOWN_ON_ERROR(result);
   return true;
 }
 
-
 bool VmService::Setup(const char* server_ip,
                       intptr_t server_port,
                       bool running_precompiled,
                       bool dev_mode_server,
                       bool trace_loading) {
   Dart_Isolate isolate = Dart_CurrentIsolate();
   ASSERT(isolate != NULL);
   SetServerAddress("");
 
   Dart_Handle result;
@@ skipping 94 matching lines @@
   SHUTDOWN_ON_ERROR(function_name);
   Dart_Handle signal_watch = Dart_Invoke(io_lib, function_name, 0, NULL);
   SHUTDOWN_ON_ERROR(signal_watch);
   Dart_Handle field_name = Dart_NewStringFromCString("_signalWatch");
   SHUTDOWN_ON_ERROR(field_name);
   result = Dart_SetField(library, field_name, signal_watch);
   SHUTDOWN_ON_ERROR(field_name);
   return true;
 }
 
-
 const char* VmService::GetErrorMessage() {
   return (error_msg_ == NULL) ? "No error." : error_msg_;
 }
 
-
 void VmService::SetServerAddress(const char* server_uri) {
   if (server_uri == NULL) {
     server_uri = "";
   }
   const intptr_t server_uri_len = strlen(server_uri);
   if (server_uri_len >= (kServerUriStringBufferSize - 1)) {
     FATAL1("vm-service: Server URI exceeded length: %s\n", server_uri);
   }
   strncpy(server_uri_, server_uri, kServerUriStringBufferSize);
   server_uri_[kServerUriStringBufferSize - 1] = '\0';
 }
 
-
 Dart_Handle VmService::GetSource(const char* name) {
   const intptr_t kBufferSize = 512;
   char buffer[kBufferSize];
   snprintf(&buffer[0], kBufferSize - 1, "%s/%s", kLibrarySourceNamePrefix,
            name);
   const char* vmservice_source = NULL;
   int r = Resources::ResourceLookup(buffer, &vmservice_source);
   if (r == Resources::kNoSuchInstance) {
     FATAL1("vm-service: Could not find embedded source file: %s ", buffer);
   }
   ASSERT(r != Resources::kNoSuchInstance);
   return Dart_NewStringFromCString(vmservice_source);
 }
 
-
 Dart_Handle VmService::LoadScript(const char* name) {
   Dart_Handle uri = Dart_NewStringFromCString(kVMServiceIOLibraryUri);
   Dart_Handle source = GetSource(name);
   return Dart_LoadScript(uri, Dart_Null(), source, 0, 0);
 }
 
-
 Dart_Handle VmService::LookupOrLoadLibrary(const char* name) {
   Dart_Handle uri = Dart_NewStringFromCString(kVMServiceIOLibraryUri);
   Dart_Handle library = Dart_LookupLibrary(uri);
   if (!Dart_IsLibrary(library)) {
     Dart_Handle source = GetSource(name);
     library = Dart_LoadLibrary(uri, Dart_Null(), source, 0, 0);
   }
   return library;
 }
 
-
 Dart_Handle VmService::LoadSource(Dart_Handle library, const char* name) {
   Dart_Handle uri = Dart_NewStringFromCString(name);
   Dart_Handle source = GetSource(name);
   return Dart_LoadSource(library, uri, Dart_Null(), source, 0, 0);
 }
 
-
 Dart_Handle VmService::LibraryTagHandler(Dart_LibraryTag tag,
                                          Dart_Handle library,
                                          Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   if (!Dart_IsString(url)) {
     return Dart_NewApiError("url is not a string");
   }
   const char* url_string = NULL;
@@ skipping 16 matching lines @@
     // url is already canonicalized.
     return url;
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, Dart_Null(), source, 0, 0);
 }
 
-
 }  // namespace bin
 }  // namespace dart