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

runtime/bin/filter.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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "bin/filter.h"
 
 #include "bin/dartutils.h"
 #include "bin/io_buffer.h"
@@ skipping 16 matching lines @@
     return err;
   }
   if (result == NULL) {
     return Dart_NewApiError("Filter was destroyed");
   }
 
   *filter = result;
   return Dart_Null();
 }
 
-
 static Dart_Handle CopyDictionary(Dart_Handle dictionary_obj,
                                   uint8_t** dictionary) {
   ASSERT(dictionary != NULL);
   uint8_t* src = NULL;
   intptr_t size;
   Dart_TypedData_Type type;
 
   Dart_Handle err = Dart_ListLength(dictionary_obj, &size);
   if (Dart_IsError(err)) {
     return err;
@@ skipping 14 matching lines @@
     if (Dart_IsError(err)) {
       delete[] result;
       return err;
     }
   }
 
   *dictionary = result;
   return Dart_Null();
 }
 
-
 void FUNCTION_NAME(Filter_CreateZLibInflate)(Dart_NativeArguments args) {
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Dart_Handle window_bits_obj = Dart_GetNativeArgument(args, 1);
   int64_t window_bits = DartUtils::GetIntegerValue(window_bits_obj);
   Dart_Handle dict_obj = Dart_GetNativeArgument(args, 2);
   Dart_Handle raw_obj = Dart_GetNativeArgument(args, 3);
   bool raw = DartUtils::GetBooleanValue(raw_obj);
 
   Dart_Handle err;
   uint8_t* dictionary = NULL;
@@ skipping 25 matching lines @@
         DartUtils::NewInternalError("Failed to create ZLibInflateFilter"));
   }
   err = Filter::SetFilterAndCreateFinalizer(
       filter_obj, filter, sizeof(*filter) + dictionary_length);
   if (Dart_IsError(err)) {
     delete filter;
     Dart_PropagateError(err);
   }
 }
 
-
 void FUNCTION_NAME(Filter_CreateZLibDeflate)(Dart_NativeArguments args) {
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Dart_Handle gzip_obj = Dart_GetNativeArgument(args, 1);
   bool gzip = DartUtils::GetBooleanValue(gzip_obj);
   Dart_Handle level_obj = Dart_GetNativeArgument(args, 2);
   int64_t level =
       DartUtils::GetInt64ValueCheckRange(level_obj, kMinInt32, kMaxInt32);
   Dart_Handle window_bits_obj = Dart_GetNativeArgument(args, 3);
   int64_t window_bits = DartUtils::GetIntegerValue(window_bits_obj);
   Dart_Handle mLevel_obj = Dart_GetNativeArgument(args, 4);
@@ skipping 36 matching lines @@
         DartUtils::NewInternalError("Failed to create ZLibDeflateFilter"));
   }
   Dart_Handle result = Filter::SetFilterAndCreateFinalizer(
       filter_obj, filter, sizeof(*filter) + dictionary_length);
   if (Dart_IsError(result)) {
     delete filter;
     Dart_PropagateError(result);
   }
 }
 
-
 void FUNCTION_NAME(Filter_Process)(Dart_NativeArguments args) {
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Dart_Handle data_obj = Dart_GetNativeArgument(args, 1);
   intptr_t start = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
   intptr_t end = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
   intptr_t chunk_length = end - start;
   intptr_t length;
   Dart_TypedData_Type type;
   uint8_t* buffer = NULL;
 
@@ skipping 37 matching lines @@
     }
   }
   // Process will take ownership of buffer, if successful.
   if (!filter->Process(buffer, chunk_length)) {
     delete[] buffer;
     Dart_ThrowException(DartUtils::NewInternalError(
         "Call to Process while still processing data"));
   }
 }
 
-
 void FUNCTION_NAME(Filter_Processed)(Dart_NativeArguments args) {
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Dart_Handle flush_obj = Dart_GetNativeArgument(args, 1);
   bool flush = DartUtils::GetBooleanValue(flush_obj);
   Dart_Handle end_obj = Dart_GetNativeArgument(args, 2);
   bool end = DartUtils::GetBooleanValue(end_obj);
 
   Filter* filter = NULL;
   Dart_Handle err = GetFilter(filter_obj, &filter);
   if (Dart_IsError(err)) {
     Dart_PropagateError(err);
   }
 
   intptr_t read = filter->Processed(
       filter->processed_buffer(), filter->processed_buffer_size(), flush, end);
   if (read < 0) {
     Dart_ThrowException(DartUtils::NewInternalError("Filter error, bad data"));
   } else if (read == 0) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     uint8_t* io_buffer;
     Dart_Handle result = IOBuffer::Allocate(read, &io_buffer);
     memmove(io_buffer, filter->processed_buffer(), read);
     Dart_SetReturnValue(args, result);
   }
 }
 
-
 static void DeleteFilter(void* isolate_data,
                          Dart_WeakPersistentHandle handle,
                          void* filter_pointer) {
   Filter* filter = reinterpret_cast<Filter*>(filter_pointer);
   delete filter;
 }
 
-
 Dart_Handle Filter::SetFilterAndCreateFinalizer(Dart_Handle filter,
                                                 Filter* filter_pointer,
                                                 intptr_t size) {
   Dart_Handle err =
       Dart_SetNativeInstanceField(filter, kFilterPointerNativeField,
                                   reinterpret_cast<intptr_t>(filter_pointer));
   if (Dart_IsError(err)) {
     return err;
   }
   Dart_NewWeakPersistentHandle(filter, reinterpret_cast<void*>(filter_pointer),
                                size, DeleteFilter);
   return err;
 }
 
-
 Dart_Handle Filter::GetFilterNativeField(Dart_Handle filter,
                                          Filter** filter_pointer) {
   return Dart_GetNativeInstanceField(
       filter, kFilterPointerNativeField,
       reinterpret_cast<intptr_t*>(filter_pointer));
 }
 
-
 ZLibDeflateFilter::~ZLibDeflateFilter() {
   delete[] dictionary_;
   delete[] current_buffer_;
   if (initialized()) {
     deflateEnd(&stream_);
   }
 }
 
-
 bool ZLibDeflateFilter::Init() {
   int window_bits = window_bits_;
   if (raw_) {
     window_bits = -window_bits;
   } else if (gzip_) {
     window_bits += kZLibFlagUseGZipHeader;
   }
   stream_.next_in = Z_NULL;
   stream_.zalloc = Z_NULL;
   stream_.zfree = Z_NULL;
   stream_.opaque = Z_NULL;
   int result = deflateInit2(&stream_, level_, Z_DEFLATED, window_bits,
                             mem_level_, strategy_);
   if (result != Z_OK) {
     return false;
   }
   if ((dictionary_ != NULL) && !gzip_ && !raw_) {
     result = deflateSetDictionary(&stream_, dictionary_, dictionary_length_);
     delete[] dictionary_;
     dictionary_ = NULL;
     if (result != Z_OK) {
       return false;
     }
   }
   set_initialized(true);
   return true;
 }
 
-
 bool ZLibDeflateFilter::Process(uint8_t* data, intptr_t length) {
   if (current_buffer_ != NULL) {
     return false;
   }
   stream_.avail_in = length;
   stream_.next_in = current_buffer_ = data;
   return true;
 }
 
 intptr_t ZLibDeflateFilter::Processed(uint8_t* buffer,
@@ skipping 19 matching lines @@
     case Z_STREAM_ERROR:
       error = true;
   }
 
   delete[] current_buffer_;
   current_buffer_ = NULL;
   // Either 0 Byte processed or error
   return error ? -1 : 0;
 }
 
-
 ZLibInflateFilter::~ZLibInflateFilter() {
   delete[] dictionary_;
   delete[] current_buffer_;
   if (initialized()) {
     inflateEnd(&stream_);
   }
 }
 
-
 bool ZLibInflateFilter::Init() {
   int window_bits =
       raw_ ? -window_bits_ : window_bits_ | kZLibFlagAcceptAnyHeader;
 
   stream_.next_in = Z_NULL;
   stream_.avail_in = 0;
   stream_.zalloc = Z_NULL;
   stream_.zfree = Z_NULL;
   stream_.opaque = Z_NULL;
   int result = inflateInit2(&stream_, window_bits);
   if (result != Z_OK) {
     return false;
   }
   set_initialized(true);
   return true;
 }
 
-
 bool ZLibInflateFilter::Process(uint8_t* data, intptr_t length) {
   if (current_buffer_ != NULL) {
     return false;
   }
   stream_.avail_in = length;
   stream_.next_in = current_buffer_ = data;
   return true;
 }
 
-
 intptr_t ZLibInflateFilter::Processed(uint8_t* buffer,
                                       intptr_t length,
                                       bool flush,
                                       bool end) {
   stream_.avail_out = length;
   stream_.next_out = buffer;
   bool error = false;
   int v;
   switch (v = inflate(&stream_,
                       end ? Z_FINISH : flush ? Z_SYNC_FLUSH : Z_NO_FLUSH)) {
@@ skipping 33 matching lines @@
   delete[] current_buffer_;
   current_buffer_ = NULL;
   // Either 0 Byte processed or error
   return error ? -1 : 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // !defined(DART_IO_DISABLED)