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.
  */
 
 #include "webrtc/modules/audio_coding/test/APITest.h"
 
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <iostream>
 #include <ostream>
 #include <string>
 
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/acm2/acm_common_defs.h"
+#include "webrtc/modules/audio_coding/codecs/audio_format_conversion.h"
 #include "webrtc/modules/audio_coding/test/utility.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/voice_engine_configurations.h"
 
 namespace webrtc {
 
 #define TEST_DURATION_SEC 600
@@ skipping 98 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,
+                                                  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