Stop using old AudioCodingModule::RegisterReceiveCodec overloads

webrtc/modules/audio_coding/test/APITest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 123 matching lines @@
         && (dummyCodec.plfreq == 32000)) {
       continue;
     }
 
     printf("Register Receive Codec %s  ", dummyCodec.plname);
 
     if ((n != 0) && !FixedPayloadTypeCodec(dummyCodec.plname)) {
       // Check registration with an already occupied payload type
       int currentPayloadType = dummyCodec.pltype;
       dummyCodec.pltype = 97;  //lastPayloadType;
-      CHECK_ERROR(_acmB->RegisterReceiveCodec(dummyCodec));
+      EXPECT_EQ(true, _acmB->RegisterReceiveCodec(dummyCodec.pltype,

[ossu, 2016/10/05 13:39:58]

Come to think of it, would it make sense to have the old RegisterReceiveCodec
just delegate to the new one (sort-of like this) and keep the tests using the
old call for now? I bet we still want to test that the old call works, since
that's what is currently used.

[kwiberg-webrtc, 2016/10/06 12:14:52]

That would make sense if we were planning to keep the old methods. But I'm
hoping to remove them rather soon: https://codereview.webrtc.org/2392743004/

I'm hoping that the old methods can survive without being tested for the ~three
weeks it'll take to get the removal landed. But then I'm an optimist...

+                                                  CodecInstToSdp(dummyCodec)));
       dummyCodec.pltype = currentPayloadType;
     }
 
     if ((n < numCodecs - 1) && !FixedPayloadTypeCodec(dummyCodec.plname)) {
       // test if re-registration works;
       CodecInst nextCodec;
       int currentPayloadType = dummyCodec.pltype;
       AudioCodingModule::Codec(n + 1, &nextCodec);
       dummyCodec.pltype = nextCodec.pltype;
       if (!FixedPayloadTypeCodec(nextCodec.plname)) {
-        _acmB->RegisterReceiveCodec(dummyCodec);
+        _acmB->RegisterReceiveCodec(dummyCodec.pltype,
+                                    CodecInstToSdp(dummyCodec));
       }
       dummyCodec.pltype = currentPayloadType;
     }
 
     if ((n < numCodecs - 1) && !FixedPayloadTypeCodec(dummyCodec.plname)) {
       // test if un-registration works;
       CodecInst nextCodec;
       AudioCodingModule::Codec(n + 1, &nextCodec);
       nextCodec.pltype = dummyCodec.pltype;
       if (!FixedPayloadTypeCodec(nextCodec.plname)) {
-        CHECK_ERROR_MT(_acmA->RegisterReceiveCodec(nextCodec));
+        EXPECT_EQ(true, _acmA->RegisterReceiveCodec(nextCodec.pltype,
+                                                    CodecInstToSdp(nextCodec)));
         CHECK_ERROR_MT(_acmA->UnregisterReceiveCodec(nextCodec.pltype));
       }
     }
 
-    CHECK_ERROR_MT(_acmA->RegisterReceiveCodec(dummyCodec));
+    EXPECT_EQ(true, _acmA->RegisterReceiveCodec(dummyCodec.pltype,
+                                                CodecInstToSdp(dummyCodec)));
     printf("   side A done!");
-    CHECK_ERROR_MT(_acmB->RegisterReceiveCodec(dummyCodec));
+    EXPECT_EQ(true, _acmB->RegisterReceiveCodec(dummyCodec.pltype,
+                                                CodecInstToSdp(dummyCodec)));
     printf("   side B done!\n");
 
     if (!strcmp(dummyCodec.plname, "CN")) {
       CHECK_ERROR_MT(_acmA->RegisterSendCodec(dummyCodec));
       CHECK_ERROR_MT(_acmB->RegisterSendCodec(dummyCodec));
     }
     lastPayloadType = dummyCodec.pltype;
     if ((lastPayloadType >= 96) && (lastPayloadType <= 127)) {
       _payloadUsed[lastPayloadType - 96] = true;
     }
@@ skipping 680 matching lines @@
         //myEvent->Wait(20);
         //CHECK_ERROR_MT(receiveACM->UnregisterReceiveCodec(myCodec->pltype));
         Wait(1000);
 
         myCodec->pltype = currentPayload;
         if (!_randomTest) {
           fprintf(stdout,
                   "Register receive codec with default Payload, AUDIO BACK.\n");
           fflush (stdout);
         }
-        CHECK_ERROR_MT(receiveACM->RegisterReceiveCodec(*myCodec));
+        EXPECT_EQ(true, receiveACM->RegisterReceiveCodec(
+                            myCodec->pltype, CodecInstToSdp(*myCodec)));
         //CHECK_ERROR_MT(sendACM->RegisterSendCodec(*myCodec));
         myEvent->Wait(20);
         {
           WriteLockScoped wl(_apiTestRWLock);
           *thereIsDecoder = true;
         }
         Wait(1000);
 
         break;
       }
     }
     if (i == 32) {
-      CHECK_ERROR_MT(receiveACM->RegisterReceiveCodec(*myCodec));
+      EXPECT_EQ(true, receiveACM->RegisterReceiveCodec(
+                          myCodec->pltype, CodecInstToSdp(*myCodec)));
       {
         WriteLockScoped wl(_apiTestRWLock);
         *thereIsDecoder = true;
       }
     }
   } else {
     if (!_randomTest) {
       fprintf(stdout,
               "Register receive codec with fixed Payload, AUDIO BACK.\n");
       fflush (stdout);
     }
-    CHECK_ERROR_MT(receiveACM->RegisterReceiveCodec(*myCodec));
+    EXPECT_EQ(true, receiveACM->RegisterReceiveCodec(myCodec->pltype,
+                                                     CodecInstToSdp(*myCodec)));
     //CHECK_ERROR_MT(receiveACM->UnregisterReceiveCodec(myCodec->pltype));
     //CHECK_ERROR_MT(receiveACM->RegisterReceiveCodec(*myCodec));
     myEvent->Wait(20);
     {
       WriteLockScoped wl(_apiTestRWLock);
       *thereIsDecoder = true;
     }
   }
   delete myEvent;
   if (!_randomTest) {
@@ skipping 187 matching lines @@
   CHECK_ERROR_MT(myACM->RegisterSendCodec(myCodec));
   myChannel->ResetStats();
   {
     WriteLockScoped wl(_apiTestRWLock);
     *thereIsEncoder = true;
   }
   Wait(500);
 }
 
 }  // namespace webrtc