Reland of Move ScriptState::GetExecutionContext (Part 5)

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 382 matching lines @@
  public:
   // Takes ownership of |resolver|.
   static std::unique_ptr<WebRTCStatsReportCallback> Create(
       ScriptPromiseResolver* resolver) {
     return std::unique_ptr<WebRTCStatsReportCallback>(
         new WebRTCStatsReportCallbackResolver(resolver));
   }
 
   ~WebRTCStatsReportCallbackResolver() override {
     DCHECK(
-        resolver_->GetScriptState()->GetExecutionContext()->IsContextThread());
+        ExecutionContext::From(resolver_->GetScriptState())->IsContextThread());
   }
 
  private:
   WebRTCStatsReportCallbackResolver(ScriptPromiseResolver* resolver)
       : resolver_(resolver) {}
 
   void OnStatsDelivered(std::unique_ptr<WebRTCStatsReport> report) override {
     DCHECK(
-        resolver_->GetScriptState()->GetExecutionContext()->IsContextThread());
+        ExecutionContext::From(resolver_->GetScriptState())->IsContextThread());
     resolver_->Resolve(new RTCStatsReport(std::move(report)));
   }
 
   Persistent<ScriptPromiseResolver> resolver_;
 };
 
 }  // namespace
 
 RTCPeerConnection::EventWrapper::EventWrapper(
     Event* event,
@@ skipping 134 matching lines @@
   if (signaling_state_ == kSignalingStateClosed)
     return ScriptPromise::RejectWithDOMException(
         script_state,
         DOMException::Create(kInvalidStateError, kSignalingStateClosedMessage));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   RTCSessionDescriptionRequest* request =
       RTCSessionDescriptionRequestPromiseImpl::Create(this, resolver);
   if (options.hasOfferToReceiveAudio() || options.hasOfferToReceiveVideo()) {
-    ExecutionContext* context = script_state->GetExecutionContext();
+    ExecutionContext* context = ExecutionContext::From(script_state);
     UseCounter::Count(
         context,
         UseCounter::kRTCPeerConnectionCreateOfferOptionsOfferToReceive);
   }
   peer_handler_->CreateOffer(request, ConvertToWebRTCOfferOptions(options));
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::createOffer(
     ScriptState* script_state,
     RTCSessionDescriptionCallback* success_callback,
     RTCPeerConnectionErrorCallback* error_callback,
     const Dictionary& rtc_offer_options,
     ExceptionState& exception_state) {
   DCHECK(success_callback);
   DCHECK(error_callback);
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   UseCounter::Count(
       context, UseCounter::kRTCPeerConnectionCreateOfferLegacyFailureCallback);
   if (CallErrorCallbackIfSignalingStateClosed(signaling_state_, error_callback))
     return ScriptPromise::CastUndefined(script_state);
 
   RTCOfferOptionsPlatform* offer_options =
       ParseOfferOptions(rtc_offer_options, exception_state);
   if (exception_state.HadException())
     return ScriptPromise();
   RTCSessionDescriptionRequest* request =
@@ skipping 52 matching lines @@
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::createAnswer(
     ScriptState* script_state,
     RTCSessionDescriptionCallback* success_callback,
     RTCPeerConnectionErrorCallback* error_callback,
     const Dictionary& media_constraints) {
   DCHECK(success_callback);
   DCHECK(error_callback);
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   UseCounter::Count(
       context, UseCounter::kRTCPeerConnectionCreateAnswerLegacyFailureCallback);
   if (media_constraints.IsObject())
     UseCounter::Count(
         context, UseCounter::kRTCPeerConnectionCreateAnswerLegacyConstraints);
   else
     UseCounter::Count(
         context, UseCounter::kRTCPeerConnectionCreateAnswerLegacyCompliant);
 
   if (CallErrorCallbackIfSignalingStateClosed(signaling_state_, error_callback))
@@ skipping 34 matching lines @@
       request, WebRTCSessionDescription(session_description_init.type(),
                                         session_description_init.sdp()));
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::setLocalDescription(
     ScriptState* script_state,
     const RTCSessionDescriptionInit& session_description_init,
     VoidCallback* success_callback,
     RTCPeerConnectionErrorCallback* error_callback) {
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   if (success_callback && error_callback) {
     UseCounter::Count(
         context,
         UseCounter::kRTCPeerConnectionSetLocalDescriptionLegacyCompliant);
   } else {
     if (!success_callback)
       UseCounter::Count(
           context,
           UseCounter::
               kRTCPeerConnectionSetLocalDescriptionLegacyNoSuccessCallback);
@@ skipping 39 matching lines @@
       request, WebRTCSessionDescription(session_description_init.type(),
                                         session_description_init.sdp()));
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::setRemoteDescription(
     ScriptState* script_state,
     const RTCSessionDescriptionInit& session_description_init,
     VoidCallback* success_callback,
     RTCPeerConnectionErrorCallback* error_callback) {
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   if (success_callback && error_callback) {
     UseCounter::Count(
         context,
         UseCounter::kRTCPeerConnectionSetRemoteDescriptionLegacyCompliant);
   } else {
     if (!success_callback)
       UseCounter::Count(
           context,
           UseCounter::
               kRTCPeerConnectionSetRemoteDescriptionLegacyNoSuccessCallback);
@@ skipping 25 matching lines @@
 }
 
 void RTCPeerConnection::setConfiguration(
     ScriptState* script_state,
     const RTCConfiguration& rtc_configuration,
     ExceptionState& exception_state) {
   if (ThrowExceptionIfSignalingStateClosed(signaling_state_, exception_state))
     return;
 
   WebRTCConfiguration configuration = ParseConfiguration(
-      script_state->GetExecutionContext(), rtc_configuration, exception_state);
+      ExecutionContext::From(script_state), rtc_configuration, exception_state);
 
   if (exception_state.HadException())
     return;
 
   MediaErrorState media_error_state;
   if (media_error_state.HadException()) {
     media_error_state.RaiseException(exception_state);
     return;
   }
 
@@ skipping 146 matching lines @@
     return ScriptPromise::Reject(
         script_state,
         V8ThrowException::CreateTypeError(
             script_state->GetIsolate(),
             "Candidate missing values for both sdpMid and sdpMLineIndex"));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   RTCVoidRequest* request = RTCVoidRequestPromiseImpl::Create(this, resolver);
   WebRTCICECandidate web_candidate = ConvertToWebRTCIceCandidate(
-      script_state->GetExecutionContext(), candidate);
+      ExecutionContext::From(script_state), candidate);
   bool implemented = peer_handler_->AddICECandidate(request, web_candidate);
   if (!implemented)
     resolver->Reject(DOMException::Create(
         kOperationError, "This operation could not be completed."));
 
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::addIceCandidate(
     ScriptState* script_state,
     const RTCIceCandidateInitOrRTCIceCandidate& candidate,
     VoidCallback* success_callback,
     RTCPeerConnectionErrorCallback* error_callback) {
   DCHECK(success_callback);
   DCHECK(error_callback);
 
   if (CallErrorCallbackIfSignalingStateClosed(signaling_state_, error_callback))
     return ScriptPromise::CastUndefined(script_state);
 
   if (IsIceCandidateMissingSdp(candidate))
     return ScriptPromise::Reject(
         script_state,
         V8ThrowException::CreateTypeError(
             script_state->GetIsolate(),
             "Candidate missing values for both sdpMid and sdpMLineIndex"));
 
   RTCVoidRequest* request = RTCVoidRequestImpl::Create(
       GetExecutionContext(), this, success_callback, error_callback);
   WebRTCICECandidate web_candidate = ConvertToWebRTCIceCandidate(
-      script_state->GetExecutionContext(), candidate);
+      ExecutionContext::From(script_state), candidate);
   bool implemented = peer_handler_->AddICECandidate(request, web_candidate);
   if (!implemented)
     AsyncCallErrorCallback(
         error_callback,
         DOMException::Create(kOperationError,
                              "This operation could not be completed."));
 
   return ScriptPromise::CastUndefined(script_state);
 }
 
@@ skipping 65 matching lines @@
         kTypeMismatchError,
         ExceptionMessages::ArgumentNullOrIncorrectType(1, "MediaStream"));
     return;
   }
 
   if (local_streams_.Contains(stream))
     return;
 
   MediaErrorState media_error_state;
   WebMediaConstraints constraints =
-      MediaConstraintsImpl::Create(script_state->GetExecutionContext(),
+      MediaConstraintsImpl::Create(ExecutionContext::From(script_state),
                                    media_constraints, media_error_state);
   if (media_error_state.HadException()) {
     media_error_state.RaiseException(exception_state);
     return;
   }
 
   local_streams_.push_back(stream);
 
   bool valid = peer_handler_->AddStream(stream->Descriptor(), constraints);
   if (!valid)
@@ skipping 42 matching lines @@
     if ((*iter)->id() == stream_id)
       return iter->Get();
   }
 
   return 0;
 }
 
 ScriptPromise RTCPeerConnection::getStats(ScriptState* script_state,
                                           RTCStatsCallback* success_callback,
                                           MediaStreamTrack* selector) {
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   UseCounter::Count(context,
                     UseCounter::kRTCPeerConnectionGetStatsLegacyNonCompliant);
   RTCStatsRequest* stats_request = RTCStatsRequestImpl::Create(
       GetExecutionContext(), this, success_callback, selector);
   // FIXME: Add passing selector as part of the statsRequest.
   peer_handler_->GetStats(stats_request);
 
   resolver->Resolve();
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::getStats(ScriptState* script_state) {
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   UseCounter::Count(context, UseCounter::kRTCPeerConnectionGetStats);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   peer_handler_->GetStats(WebRTCStatsReportCallbackResolver::Create(resolver));
 
   return promise;
 }
 
 HeapVector<Member<RTCRtpReceiver>> RTCPeerConnection::getReceivers() {
@@ skipping 26 matching lines @@
     const Dictionary& options,
     ExceptionState& exception_state) {
   if (ThrowExceptionIfSignalingStateClosed(signaling_state_, exception_state))
     return nullptr;
 
   WebRTCDataChannelInit init;
   DictionaryHelper::Get(options, "ordered", init.ordered);
   DictionaryHelper::Get(options, "negotiated", init.negotiated);
 
   unsigned short value = 0;
-  ExecutionContext* context = script_state->GetExecutionContext();
+  ExecutionContext* context = ExecutionContext::From(script_state);
   if (DictionaryHelper::Get(options, "id", value))
     init.id = value;
   if (DictionaryHelper::Get(options, "maxRetransmits", value)) {
     UseCounter::Count(
         context, UseCounter::kRTCPeerConnectionCreateDataChannelMaxRetransmits);
     init.max_retransmits = value;
   }
   if (DictionaryHelper::Get(options, "maxRetransmitTime", value)) {
     UseCounter::Count(
         context,
@@ skipping 328 matching lines @@
   visitor->Trace(local_streams_);
   visitor->Trace(remote_streams_);
   visitor->Trace(rtp_receivers_);
   visitor->Trace(dispatch_scheduled_event_runner_);
   visitor->Trace(scheduled_events_);
   EventTargetWithInlineData::Trace(visitor);
   SuspendableObject::Trace(visitor);
 }
 
 }  // namespace blink