Remove the deprecated PeerConnection that uses the ROAP protocol.

chrome/test/functional/webrtc_call.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import os
 import subprocess
 import time
 import unittest
 
@@ skipping 40 matching lines @@
 
     self._server_process = subprocess.Popen(binary_path)
 
   def tearDown(self):
     self._server_process.kill()
 
     pyauto.PyUITest.tearDown(self)
     self.assertEquals('', self.CheckErrorsAndCrashes())
 
   def _SimpleWebRtcCall(self, test_page):
-    """Tests we can call and hang up with WebRTC using ROAP/JSEP.
+    """Tests we can call and hang up with WebRTC.
 
     This test exercises pretty much the whole happy-case for the WebRTC
     JavaScript API. Currently, it exercises a normal call setup using the API
     defined at http://dev.w3.org/2011/webrtc/editor/webrtc.html. The API is
     still evolving.
 
     The test will load the supplied HTML file, which in turn will load different
-    javascript files depending on if we are running ROAP or JSEP.
+    javascript files depending on which version of the signaling protocol
+    we are running.
     The supplied HTML file will be loaded in two tabs and tell the web
     pages to start up WebRTC, which will acquire video and audio devices on the
     system. This will launch a dialog in Chrome which we click past using the
     automation controller. Then, we will order both tabs to connect the server,
     which will make the two tabs aware of each other. Once that is done we order
     one tab to call the other.
 
     We make sure that the javascript tells us that the call succeeded, lets it
     run for a while and try to hang up the call after that. We verify video is
     playing by using the video detector.
@@ skipping 17 matching lines @@
     self._HangUp(from_tab_with_index=0)
     self._VerifyHungUp(tab_index=1)
 
     self._Disconnect(tab_index=0)
     self._Disconnect(tab_index=1)
 
     # Ensure we didn't miss any errors.
     self._AssertNoFailures(tab_index=0)
     self._AssertNoFailures(tab_index=1)
 
-  def testSimpleWebRtcRoapCall(self):
-    self._SimpleWebRtcCall('webrtc_roap_test.html')
-
   def testSimpleWebRtcJsepCall(self):
     self._SimpleWebRtcCall('webrtc_jsep_test.html')
 
   def testLocalPreview(self):
     """Brings up a local preview and ensures video is playing.
 
     This test will launch a window with a single tab and run a getUserMedia call
     which will give us access to the webcam and microphone. Then the javascript
     code will hook up the webcam data to the local_view video tag. We will
     detect video in that tag using the video detector, and if we see video
@@ skipping 88 matching lines @@
     self.assertTrue(video_playing,
                     msg='Timed out while trying to detect video.')
 
   def _AssertNoFailures(self, tab_index):
     self.assertEquals('ok-no-errors', self.ExecuteJavascript(
         'getAnyTestFailures()', tab_index=tab_index))
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()