[scheduler] Plumb information about active webrtc connections to scheduler

third_party/WebKit/Source/modules/peerconnection/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 503 matching lines @@
       .client()
       ->dispatchWillStartUsingPeerConnectionHandler(m_peerHandler.get());
 
   if (!m_peerHandler->initialize(configuration, constraints)) {
     m_closed = true;
     m_stopped = true;
     exceptionState.throwDOMException(
         NotSupportedError, "Failed to initialize native PeerConnection.");
     return;
   }
+
+  m_connectionHandleForScheduler =
+      document->frame()->frameScheduler()->onActiveConnectionCreated();

[haraken, 2017/02/10 16:51:20]

Another possible API would be to use an observer pattern like
ActiveScriptWrappable::hasPendingActivity().

class RTCPeerConnection : public HasUnthrottledTask {
  bool hasUnthrottledTask() override { return !m_closed || !m_stopped; }
};

Then developers don't need to write .reset() in many places. The observer
pattern would be less error-prone than the .reset() pattern.

[altimin, 2017/02/10 16:57:00]

I would argue that you still need to notify the scheduler when active connection
has gone away (checking all HasActiveTask subclasses is slow and will probably
involve troubles with ownership models and weak pointers). Thus some kind of
call is needed, and resetting handlers is arguably one of the best options: e.g.
calling reset on an empty handle or calling reset twice will work as intended.

 }
 
 RTCPeerConnection::~RTCPeerConnection() {
   // This checks that close() or stop() is called before the destructor.
   // We are assuming that a wrapper is always created when RTCPeerConnection is
   // created.
   DCHECK(m_closed || m_stopped);
 }
 
 void RTCPeerConnection::dispose() {
@@ skipping 811 matching lines @@
   if (m_stopped)
     return;
 
   m_stopped = true;
   m_iceConnectionState = ICEConnectionStateClosed;
   m_signalingState = SignalingStateClosed;
 
   m_dispatchScheduledEventRunner->stop();
 
   m_peerHandler.reset();
+
+  m_connectionHandleForScheduler.reset();
 }
 
 void RTCPeerConnection::closePeerConnection() {
   DCHECK(m_signalingState != RTCPeerConnection::SignalingStateClosed);
   closeInternal();
 }
 
 const AtomicString& RTCPeerConnection::interfaceName() const {
   return EventTargetNames::RTCPeerConnection;
 }
@@ skipping 54 matching lines @@
   DCHECK(m_signalingState != RTCPeerConnection::SignalingStateClosed);
   m_peerHandler->stop();
   m_closed = true;
 
   changeIceConnectionState(ICEConnectionStateClosed);
   changeIceGatheringState(ICEGatheringStateComplete);
   changeSignalingState(SignalingStateClosed);
   Document* document = toDocument(getExecutionContext());
   HostsUsingFeatures::countAnyWorld(
       *document, HostsUsingFeatures::Feature::RTCPeerConnectionUsed);
+
+  m_connectionHandleForScheduler.reset();
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(Event* event) {
   scheduleDispatchEvent(event, nullptr);
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(
     Event* event,
     std::unique_ptr<BoolFunction> setupFunction) {
   m_scheduledEvents.push_back(
@@ skipping 47 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink