tree a4e1dc9258ed20fc1527a8ff369f3fe0f4883480
parent c3f31dc395f4791e141a312ced239c5fbab7aeab
author Guido Urdaneta <guidou@webrtc.org> 1555410254 +0200
committer Commit Bot <commit-bot@chromium.org> 1555416273 +0000

Reland "Make negotiationneeded processing in PeerConnection spec compliant."

The new processing applies only in Unified Plan mode.
Plan B retains the old-style processing.

This is a reland of 1fa06041bcd8a0119e557d16e7b54a9110c5ad03

Original change's description:
> Make negotiationneeded processing in PeerConnection spec compliant.
>
> This CL fixes the problem of misfired negotiationneeded notifications due
> to the lack of a NegotiationNeeded slot and the proper procedure to
> update it.
>
>
> Change-Id: Ie273c691f11316c9846606446f6cf838226b5d5c
> Bug: chromium:740501
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/131283
> Commit-Queue: Guido Urdaneta <guidou@webrtc.org>
> Reviewed-by: Steve Anton <steveanton@webrtc.org>
> Reviewed-by: Henrik Boström <hbos@webrtc.org>
> Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#27594}

Bug: chromium:740501
Change-Id: I048ae81b2b00086f6d669e94eecf426f0db0ec08
TBR: steveanton@webrtc.org
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/133162
Commit-Queue: Guido Urdaneta <guidou@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27640}