Record QuicTransport use counters manually

We're introducing a new interface, WebTransport, which will replace
QuicTransport. WebTransport may also cover HTTP3Transport, so record
use counters rather than relying on MeasureAs.

Bug: 1123413
Change-Id: I17c22599eb82463756851a8d781eb6bebef50ac3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2399165
Auto-Submit: Yutaka Hirano <yhirano@chromium.org>
Commit-Queue: Adam Rice <ricea@chromium.org>
Reviewed-by: Adam Rice <ricea@chromium.org>
Cr-Commit-Position: refs/heads/master@{#805523}

third_party/blink/renderer/modules/webtransport/quic_transport.cc

@@ -21,6 +21,7 @@
 #include "third_party/blink/renderer/bindings/modules/v8/v8_rtc_dtls_fingerprint.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
+#include "third_party/blink/renderer/core/frame/web_feature.h"
 #include "third_party/blink/renderer/core/streams/readable_stream.h"
 #include "third_party/blink/renderer/core/streams/readable_stream_default_controller_with_script_scope.h"
 #include "third_party/blink/renderer/core/streams/underlying_sink_base.h"
@@ -347,6 +348,7 @@ QuicTransport* QuicTransport::Create(ScriptState* script_state,
                                      ExceptionState& exception_state) {
   DVLOG(1) << "QuicTransport::Create() url=" << url;
   DCHECK(options);
+  ExecutionContext::From(script_state)->CountUse(WebFeature::kQuicTransport);
   auto* transport =
       MakeGarbageCollected<QuicTransport>(PassKey(), script_state, url);
   transport->Init(url, *options, exception_state);
@@ -372,6 +374,7 @@ ScriptPromise QuicTransport::createSendStream(ScriptState* script_state,
                                               ExceptionState& exception_state) {
   DVLOG(1) << "QuicTransport::createSendStream() this=" << this;
 
+  GetExecutionContext()->CountUse(WebFeature::kQuicTransportStreamApis);
   if (!quic_transport_.is_bound()) {
     // TODO(ricea): Should we wait if we're still connecting?
     exception_state.ThrowDOMException(DOMExceptionCode::kNetworkError,
@@ -398,11 +401,17 @@ ScriptPromise QuicTransport::createSendStream(ScriptState* script_state,
   return resolver->Promise();
 }
 
+ReadableStream* QuicTransport::receiveStreams() {
+  GetExecutionContext()->CountUse(WebFeature::kQuicTransportStreamApis);
+  return received_streams_;
+}
+
 ScriptPromise QuicTransport::createBidirectionalStream(
     ScriptState* script_state,
     ExceptionState& exception_state) {
   DVLOG(1) << "QuicTransport::createBidirectionalStream() this=" << this;
 
+  GetExecutionContext()->CountUse(WebFeature::kQuicTransportStreamApis);
   if (!quic_transport_.is_bound()) {
     // TODO(ricea): We should wait if we are still connecting.
     exception_state.ThrowDOMException(DOMExceptionCode::kNetworkError,
@@ -442,6 +451,21 @@ ScriptPromise QuicTransport::createBidirectionalStream(
   return resolver->Promise();
 }
 
+ReadableStream* QuicTransport::receiveBidirectionalStreams() {
+  GetExecutionContext()->CountUse(WebFeature::kQuicTransportStreamApis);
+  return received_bidirectional_streams_;
+}
+
+WritableStream* QuicTransport::sendDatagrams() {
+  GetExecutionContext()->CountUse(WebFeature::kQuicTransportDatagramApis);
+  return outgoing_datagrams_;
+}
+
+ReadableStream* QuicTransport::receiveDatagrams() {
+  GetExecutionContext()->CountUse(WebFeature::kQuicTransportDatagramApis);
+  return received_datagrams_;
+}
+
 void QuicTransport::close(const WebTransportCloseInfo* close_info) {
   DVLOG(1) << "QuicTransport::close() this=" << this;
   // TODO(ricea): Send |close_info| to the network service.

third_party/blink/renderer/modules/webtransport/quic_transport.h

@@ -60,15 +60,13 @@ class MODULES_EXPORT QuicTransport final
 
   // QuicTransport IDL implementation.
   ScriptPromise createSendStream(ScriptState*, ExceptionState&);
-  ReadableStream* receiveStreams() { return received_streams_; }
+  ReadableStream* receiveStreams();
 
   ScriptPromise createBidirectionalStream(ScriptState*, ExceptionState&);
-  ReadableStream* receiveBidirectionalStreams() {
-    return received_bidirectional_streams_;
-  }
+  ReadableStream* receiveBidirectionalStreams();
 
-  WritableStream* sendDatagrams() { return outgoing_datagrams_; }
-  ReadableStream* receiveDatagrams() { return received_datagrams_; }
+  WritableStream* sendDatagrams();
+  ReadableStream* receiveDatagrams();
   void close(const WebTransportCloseInfo*);
   ScriptPromise ready() { return ready_; }
   ScriptPromise closed() { return closed_; }

third_party/blink/renderer/modules/webtransport/quic_transport.idl

@@ -8,27 +8,27 @@
     Exposed=(Window,Worker),
     RuntimeEnabled=QuicTransport
 ] interface QuicTransport {
-  [CallWith=ScriptState, RaisesException, MeasureAs=QuicTransport] constructor(USVString url, optional QuicTransportOptions options = {});
+  [CallWith=ScriptState, RaisesException] constructor(USVString url, optional QuicTransportOptions options = {});
   // QuicTransport is the first, and at this moment only, transport which is
   // implemented. In the (draft) spec there are many mix-in interfaces which
   // QuicTransport includes, but we define all their methods/attributes here
   // for simplicity.
 
   // From UnidirectionalStreamsTransport
-  [CallWith=ScriptState, RaisesException, MeasureAs=QuicTransportStreamApis] Promise<SendStream>
+  [CallWith=ScriptState, RaisesException] Promise<SendStream>
       createSendStream();
   // TODO(ricea): This should probably be changed to an attribute in the
   // standard.
-  [MeasureAs=QuicTransportStreamApis] ReadableStream receiveStreams();
+  ReadableStream receiveStreams();
 
   // From BidirectionalStreamsTransport
-  [CallWith=ScriptState, RaisesException, MeasureAs=QuicTransportStreamApis] Promise<BidirectionalStream>
+  [CallWith=ScriptState, RaisesException] Promise<BidirectionalStream>
       createBidirectionalStream();
-  [MeasureAs=QuicTransportStreamApis] ReadableStream receiveBidirectionalStreams();
+  ReadableStream receiveBidirectionalStreams();
 
   // From DatagramTransport mixin
-  [MeasureAs=QuicTransportDatagramApis] WritableStream sendDatagrams();
-  [MeasureAs=QuicTransportDatagramApis] ReadableStream receiveDatagrams();
+  WritableStream sendDatagrams();
+  ReadableStream receiveDatagrams();
 
   // From WebTransport mixin
   void close(optional WebTransportCloseInfo closeInfo = {});