AcmReceiver::InsertPacket and NetEq::InsertPacket: Take ArrayView arguments

webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc

 /*
  *  Copyright (c) 2013 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 87 matching lines @@
       next_arrival_time = GetArrivalTime(next_send_time);
     } while (Lost());  // If lost, immediately read the next packet.
 
     EXPECT_CALL(*external_decoder_,
                 Decode(_, payload_size_bytes_, 1000 * samples_per_ms_, _, _, _))
         .Times(NumExpectedDecodeCalls(num_loops));
 
     uint32_t time_now = 0;
     for (int k = 0; k < num_loops; ++k) {
       while (time_now >= next_arrival_time) {
-        InsertPacket(rtp_header_, encoded_, payload_size_bytes_,
+        InsertPacket(rtp_header_, rtc::ArrayView<const uint8_t>(
+                                      encoded_, payload_size_bytes_),
                      next_arrival_time);
         // Get next input packet.
         do {
           next_send_time = GetNewPacket();
           next_arrival_time = GetArrivalTime(next_send_time);
         } while (Lost());  // If lost, immediately read the next packet.
       }
 
       std::ostringstream ss;
       ss << "Lap number " << k << ".";
       SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
       // Compare mono and multi-channel.
       ASSERT_NO_FATAL_FAILURE(GetAndVerifyOutput());
 
       time_now += kOutputLengthMs;
     }
   }
 
-  void InsertPacket(WebRtcRTPHeader rtp_header, const uint8_t* payload,
-                    size_t payload_size_bytes,
+  void InsertPacket(WebRtcRTPHeader rtp_header,
+                    rtc::ArrayView<const uint8_t> payload,
                     uint32_t receive_timestamp) override {
-    EXPECT_CALL(*external_decoder_,
-                IncomingPacket(_,
-                               payload_size_bytes,
-                               rtp_header.header.sequenceNumber,
-                               rtp_header.header.timestamp,
-                               receive_timestamp));
+    EXPECT_CALL(
+        *external_decoder_,
+        IncomingPacket(_, payload.size(), rtp_header.header.sequenceNumber,
+                       rtp_header.header.timestamp, receive_timestamp));
     NetEqExternalDecoderTest::InsertPacket(rtp_header, payload,
-                                           payload_size_bytes,
                                            receive_timestamp);
   }
 
   MockExternalPcm16B* external_decoder() { return external_decoder_.get(); }
 
   void ResetRtpGenerator(test::RtpGenerator* rtp_generator) {
     rtp_generator_.reset(rtp_generator);
   }
 
   int samples_per_ms() const { return samples_per_ms_; }
@@ skipping 55 matching lines @@
 
     // Get audio from external decoder instance.
     samples_per_channel = GetOutputAudio(kMaxBlockSize, output_, &output_type);
 
     for (size_t i = 0; i < samples_per_channel; ++i) {
       ASSERT_EQ(output_[i], output_internal_[i]) <<
           "Diff in sample " << i << ".";
     }
   }
 
-  void InsertPacket(WebRtcRTPHeader rtp_header, const uint8_t* payload,
-                    size_t payload_size_bytes,
+  void InsertPacket(WebRtcRTPHeader rtp_header,
+                    rtc::ArrayView<const uint8_t> payload,
                     uint32_t receive_timestamp) override {
     // Insert packet in internal decoder.
-    ASSERT_EQ(
-        NetEq::kOK,
-        neteq_internal_->InsertPacket(
-            rtp_header, payload, payload_size_bytes, receive_timestamp));
+    ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(rtp_header, payload,
+                                                        receive_timestamp));
 
     // Insert packet in external decoder instance.
     NetEqExternalDecoderUnitTest::InsertPacket(rtp_header, payload,
-                                               payload_size_bytes,
                                                receive_timestamp);
   }
 
   int NumExpectedDecodeCalls(int num_loops) override { return num_loops; }
 
  private:
   int sample_rate_hz_;
   rtc::scoped_ptr<NetEq> neteq_internal_;
   int16_t output_internal_[kMaxBlockSize];
   int16_t output_[kMaxBlockSize];
@@ skipping 219 matching lines @@
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
 }  // namespace webrtc