http: cache parser callbacks

Cache the kOnHeadersComplete, kOnBody and kOnMessageComplete callback
lookups per parser instead of doing an object property Get on every
message. These callbacks are assigned once when the parser object is
created and never change; the cache is cleared in Init() so
re-initialized parsers (direct binding users) stay correct.

No observable behavior change; all header/parser tests pass. On a
keep-alive server this is a small but consistent CPU reduction.

Signed-off-by: Matteo Collina <hello@matteocollina.com>

Author: mcollina

src/node_http_parser.cc

@@ -441,9 +441,8 @@ class Parser : public AsyncWrap, public StreamListener {
     };
 
     Local<Value> argv[A_MAX];
-    Local<Object> obj = object();
-    Local<Value> cb = obj->Get(env()->context(),
-                               kOnHeadersComplete).ToLocalChecked();
+    Local<Value> cb =
+        CachedCallback(kOnHeadersComplete, &on_headers_complete_cb_);
 
     if (!cb->IsFunction())
       return 0;
@@ -521,7 +520,7 @@ class Parser : public AsyncWrap, public StreamListener {
     Environment* env = this->env();
     HandleScope handle_scope(env->isolate());
 
-    Local<Value> cb = object()->Get(env->context(), kOnBody).ToLocalChecked();
+    Local<Value> cb = CachedCallback(kOnBody, &on_body_cb_);
 
     if (!cb->IsFunction())
       return 0;
@@ -554,9 +553,8 @@ class Parser : public AsyncWrap, public StreamListener {
 
     header_pairs_ = 0;
 
-    Local<Object> obj = object();
-    Local<Value> cb = obj->Get(env()->context(),
-                               kOnMessageComplete).ToLocalChecked();
+    Local<Value> cb =
+        CachedCallback(kOnMessageComplete, &on_message_complete_cb_);
 
     if (!cb->IsFunction())
       return 0;
@@ -940,6 +938,9 @@ class Parser : public AsyncWrap, public StreamListener {
     Local<Value> headers_v[kMaxHeaderFieldsCount * 2];
 
     for (size_t i = 0; i < num_values_; ++i) {
+      // Field names are not internalized: header names are attacker
+      // controlled, so a flood of unique names would grow V8's string table
+      // and pay the interning cost on every request with no dedup benefit.
       headers_v[i * 2] = fields_[i].ToString(env());
       headers_v[i * 2 + 1] = values_[i].ToTrimmedString(env());
     }
@@ -975,10 +976,28 @@ class Parser : public AsyncWrap, public StreamListener {
   }
 
 
+  // Caches a set-once callback property; the cache is cleared in Init().
+  Local<Value> CachedCallback(uint32_t index, v8::Global<v8::Value>* cache) {
+    Isolate* isolate = env()->isolate();
+    if (!cache->IsEmpty()) {
+      return cache->Get(isolate);
+    }
+    Local<Value> cb =
+        object()->Get(env()->context(), index).ToLocalChecked();
+    if (cb->IsFunction()) {
+      cache->Reset(isolate, cb);
+    }
+    return cb;
+  }
+
   void Init(llhttp_type_t type, uint64_t max_http_header_size,
             uint32_t lenient_flags) {
     llhttp_init(&parser_, type, &settings);
 
+    on_headers_complete_cb_.Reset();
+    on_body_cb_.Reset();
+    on_message_complete_cb_.Reset();
+
     if (lenient_flags & kLenientHeaders) {
       llhttp_set_lenient_headers(&parser_, 1);
     }
@@ -1102,6 +1121,10 @@ class Parser : public AsyncWrap, public StreamListener {
   size_t header_pairs_ = 0;
   double max_header_pairs_ = -1;
   bool pending_pause_ = false;
+
+  v8::Global<v8::Value> on_headers_complete_cb_;
+  v8::Global<v8::Value> on_body_cb_;
+  v8::Global<v8::Value> on_message_complete_cb_;
   bool received_data_ = false;
   uint64_t header_nread_ = 0;
   uint64_t chunk_extensions_nread_ = 0;