quic: Fix linting

Author: martenrichter

src/dataqueue/queue.cc

@@ -1068,8 +1068,7 @@ class FdEntry final : public EntryImpl {
 
 class FeederEntry final : public EntryImpl {
  public:
-  FeederEntry(DataQueueFeeder* feeder) : feeder_(feeder) {
-  }
+  FeederEntry(DataQueueFeeder* feeder) : feeder_(feeder) {}
 
   static std::unique_ptr<FeederEntry> Create(DataQueueFeeder* feeder) {
     return std::make_unique<FeederEntry>(feeder);
@@ -1080,9 +1079,9 @@ class FeederEntry final : public EntryImpl {
   }
 
   std::unique_ptr<Entry> slice(
-      uint64_t start, std::optional<uint64_t> end = std::nullopt) override {
-      // we are not idempotent
-      return std::unique_ptr<Entry>(nullptr);
+    uint64_t start, std::optional<uint64_t> end = std::nullopt) override {
+    // we are not idempotent
+    return std::unique_ptr<Entry>(nullptr);
   }
 
   std::optional<uint64_t> size() const override {
@@ -1103,11 +1102,10 @@ class FeederEntry final : public EntryImpl {
    public:
     static std::shared_ptr<ReaderImpl> Create(FeederEntry* entry) {
       return std::make_shared<ReaderImpl>(entry);
-    };
-
-    explicit ReaderImpl(FeederEntry* entry) : entry_(entry) {
     }
 
+    explicit ReaderImpl(FeederEntry* entry) : entry_(entry) {}
+
     ~ReaderImpl() {
       entry_->feeder_->DrainAndClose();
     }
@@ -1122,7 +1120,7 @@ class FeederEntry final : public EntryImpl {
         return bob::STATUS_EOS;
       }
       entry_->feeder_->addPendingPull(
-        DataQueueFeeder::PendingPull(std::move(next)));
+          DataQueueFeeder::PendingPull(std::move(next)));
       entry_->feeder_->tryWakePulls();
       return bob::STATUS_WAIT;
     }
@@ -1138,7 +1136,6 @@ class FeederEntry final : public EntryImpl {
 
 // ============================================================================
 
-
 std::shared_ptr<DataQueue> DataQueue::CreateIdempotent(
     std::vector<std::unique_ptr<Entry>> list) {
   // Any entry is invalid for an idempotent DataQueue if any of the entries

src/dataqueue/queue.h

@@ -16,8 +16,8 @@
 #include <vector>
 
 namespace node {
-    using v8::Local;
-    using v8::Value;
+using v8::Local;
+using v8::Value;
 
 // Represents a sequenced collection of data sources that can be
 // consumed as a single logical stream of data. Sources can be

src/quic/streams.cc

@@ -229,7 +229,6 @@ Maybe<std::shared_ptr<DataQueue>> Stream::GetDataQueueFromSource(
     return Just(dataQueue);
   }
 
-
   THROW_ERR_INVALID_ARG_TYPE(env, "Invalid data source type");
   return Nothing<std::shared_ptr<DataQueue>>();
 }
@@ -1337,8 +1336,7 @@ void Stream::Unschedule() {
 
 }  // namespace quic
 
-DataQueueFeeder::DataQueueFeeder(Environment* env,
-                   Local<Object> object)
+DataQueueFeeder::DataQueueFeeder(Environment* env, Local<Object> object)
     : AsyncWrap(env, object) {
   MakeWeak();
 }
@@ -1367,7 +1365,6 @@ void DataQueueFeeder::DrainAndClose() {
   done = true;
 }
 
-
 JS_METHOD_IMPL(DataQueueFeeder::New) {
   DCHECK(args.IsConstructCall());
   auto env = Environment::GetCurrent(args);
@@ -1383,7 +1380,7 @@ JS_METHOD_IMPL(DataQueueFeeder::Ready) {
     return;
   } else {
     Local<Promise::Resolver> readFinish =
-      Promise::Resolver::New(env->context()).ToLocalChecked();
+        Promise::Resolver::New(env->context()).ToLocalChecked();
     feeder->readFinish_.Reset(env->isolate(), readFinish);
     args.GetReturnValue().Set(readFinish->GetPromise());
     return;
@@ -1397,7 +1394,7 @@ JS_METHOD_IMPL(DataQueueFeeder::Submit) {
 
   bool done = false;
   if (args[1]->IsBoolean() && args[1].As<v8::Boolean>()->Value()) {
-     done = true;
+    done = true;
   }
   if (!args[0].IsEmpty()) {
     CHECK_GT(feeder->pendingPulls_.size(), 0);
@@ -1408,8 +1405,8 @@ JS_METHOD_IMPL(DataQueueFeeder::Submit) {
       chunk = Uint8Array::New(buffer, 0, buffer->ByteLength());
     }
     if (!chunk->IsTypedArray()) {
-       THROW_ERR_INVALID_ARG_TYPE(env,
-        "Invalid data must be Arraybuffer or TypedArray");
+      THROW_ERR_INVALID_ARG_TYPE(
+        env, "Invalid data must be Arraybuffer or TypedArray");
     }
     Local<TypedArray> typedArray = chunk.As<TypedArray>();
     // now we create a copy
@@ -1423,10 +1420,10 @@ JS_METHOD_IMPL(DataQueueFeeder::Submit) {
     JS_TRY_ALLOCATE_BACKING(env, backingUniq, nread);
     std::shared_ptr<BackingStore> backing = std::move(backingUniq);
 
-    auto originalStore  = typedArray->Buffer()->GetBackingStore();
-    const void* originalData = static_cast<char*>(originalStore->Data())
-                      + typedArray->ByteOffset();
-    memcpy(backing->Data(), originalData,  nread);
+    auto originalStore = typedArray->Buffer()->GetBackingStore();
+    const void* originalData =
+        static_cast<char*>(originalStore->Data()) + typedArray->ByteOffset();
+    memcpy(backing->Data(), originalData, nread);
     auto& pending = feeder->pendingPulls_.front();
     auto pop = OnScopeLeave([feeder] { feeder->pendingPulls_.pop_front(); });
     DataQueue::Vec vec;
@@ -1446,7 +1443,7 @@ JS_METHOD_IMPL(DataQueueFeeder::Submit) {
       return;
     } else {
       Local<Promise::Resolver> readFinish =
-        Promise::Resolver::New(env->context()).ToLocalChecked();
+          Promise::Resolver::New(env->context()).ToLocalChecked();
       feeder->readFinish_.Reset(env->isolate(), readFinish);
       args.GetReturnValue().Set(readFinish->GetPromise());
       return;
@@ -1467,15 +1464,14 @@ JS_CONSTRUCTOR_IMPL(DataQueueFeeder, dataqueuefeeder_constructor_template, {
   JS_NEW_CONSTRUCTOR();
   JS_INHERIT(AsyncWrap);
   JS_CLASS(dataqueuefeeder);
-  SetProtoMethod(isolate, tmpl, "error",  Error);
+  SetProtoMethod(isolate, tmpl, "error", Error);
   SetProtoMethod(isolate, tmpl, "submit", Submit);
-  SetProtoMethod(isolate, tmpl, "ready",  Ready);
+  SetProtoMethod(isolate, tmpl, "ready", Ready);
 })
 
 
-void DataQueueFeeder::InitPerIsolate(
-  IsolateData* data,
-  Local<ObjectTemplate> target) {
+void DataQueueFeeder::InitPerIsolate(IsolateData* data,
+                                     Local<ObjectTemplate> target) {
   // TODO(@jasnell): Implement the per-isolate state
 }
 
@@ -1487,8 +1483,7 @@ void DataQueueFeeder::InitPerContext(Realm* realm, Local<Object> target) {
 }
 
 void DataQueueFeeder::RegisterExternalReferences(
-  ExternalReferenceRegistry* registry
-) {
+  ExternalReferenceRegistry* registry) {
   registry->Register(New);
   registry->Register(Submit);
   registry->Register(Error);

src/quic/streams.h

@@ -26,7 +26,6 @@ class Stream;
 
 using Ngtcp2Source = bob::SourceImpl<ngtcp2_vec>;
 
-
 // When a request to open a stream is made before a Session is able to actually
 // open a stream (either because the handshake is not yet sufficiently complete
 // or concurrency limits are temporarily reached) then the request to open the
@@ -393,36 +392,32 @@ class Stream final : public AsyncWrap,
   void Unschedule();
 };
 }  // namespace quic
-class DataQueueFeeder final: public AsyncWrap {
+class DataQueueFeeder final : public AsyncWrap {
  public:
-using Next = bob::Next<DataQueue::Vec>;
+  using Next = bob::Next<DataQueue::Vec>;
 
-  DataQueueFeeder(Environment* env,
-           v8::Local<v8::Object> object);
+  DataQueueFeeder(Environment* env, v8::Local<v8::Object> object);
 
   JS_CONSTRUCTOR(DataQueueFeeder);
   JS_BINDING_INIT_BOILERPLATE();
 
   static BaseObjectPtr<DataQueueFeeder> Create();
 
-  void setDataQueue(std::shared_ptr<DataQueue> queue) {
-    dataQueue_ = queue;
-  }
+  void setDataQueue(std::shared_ptr<DataQueue> queue) { dataQueue_ = queue; }
 
   void tryWakePulls();
   void DrainAndClose();
 
   struct PendingPull {
     Next next;
-    explicit PendingPull(Next next)
-        : next(std::move(next)) {}
+    explicit PendingPull(Next next) : next(std::move(next)) {}
   };
 
   void addPendingPull(PendingPull toAdd) {
     pendingPulls_.emplace_back(std::move(toAdd));
   }
 
-  bool Done() {return done;};
+  bool Done() { return done; }
 
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(DataQueueFeeder)
@@ -433,13 +428,10 @@ using Next = bob::Next<DataQueue::Vec>;
   JS_METHOD(Error);
   JS_METHOD(Ready);
 
-
  private:
   std::shared_ptr<DataQueue> dataQueue_;
   Global<Promise::Resolver> readFinish_;
 
-
-
   std::deque<PendingPull> pendingPulls_;
   bool done = false;
 };