Changed AudioPacket data to a repeated field.

remoting/client/plugin/pepper_audio_player.cc

 // 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.
 
 #include "remoting/client/plugin/pepper_audio_player.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
 
@@ skipping 56 matching lines @@
   // Immediately start the player.
   bool success = audio_.StartPlayback();
   if (!success)
     LOG(ERROR) << "Failed to start Pepper audio player";
   return success;
 }
 
 void PepperAudioPlayer::ProcessAudioPacket(scoped_ptr<AudioPacket> packet) {
   // TODO(kxing): Limit the size of the queue so that latency doesn't grow
   // too large.
-  if (packet->data().size() % (kChannels * kSampleSizeBytes) != 0) {
+
+  // Drop null packets.
+  if (!packet.get())

[Sergey Ulanov, 2012/08/15 00:47:20]

You don't need this. scoped_ptr's -> operation will dcheck below if packet is
null, and we expect this method to be called only for non-null packets.

[kxing, 2012/08/15 16:00:05]

A packet might end up null if some malicious host sends corrupted packets.

[Sergey Ulanov, 2012/08/15 17:38:10]

Oh, I see. Maybe better to handle this case in AudioDecodeScheduler?

+    return;
+
+  CHECK_EQ(1, packet->data_size());
+  CHECK_EQ(AudioPacket::ENCODING_RAW, packet->encoding());

[Sergey Ulanov, 2012/08/15 00:47:20]

nit: this doesn't really need to be CHECK - DCHECK() would be sufficient

[kxing, 2012/08/15 16:00:05]

Done.

+  if (packet->data(0).size() % (kChannels * kSampleSizeBytes) != 0) {
     LOG(WARNING) << "Received corrupted packet.";
     return;
   }
   base::AutoLock auto_lock(lock_);
 
   // No-op if the Pepper player won't start.
   if (start_failed_) {
     return;
   }
 
@@ skipping 34 matching lines @@
   size_t bytes_extracted = 0;
 
   while (bytes_extracted < bytes_needed) {
     // Check if we've run out of samples for this packet.
     if (queued_packets_.empty()) {
       memset(next_sample, 0, bytes_needed - bytes_extracted);
       return;
     }
 
     // Pop off the packet if we've already consumed all its bytes.
-    if (queued_packets_.front()->data().size() == bytes_consumed_) {
+    if (queued_packets_.front()->data(0).size() == bytes_consumed_) {
       delete queued_packets_.front();
       queued_packets_.pop_front();
       bytes_consumed_ = 0;
       continue;
     }
 
-    const std::string& packet_data = queued_packets_.front()->data();
+    const std::string& packet_data = queued_packets_.front()->data(0);
     size_t bytes_to_copy = std::min(
         packet_data.size() - bytes_consumed_,
         bytes_needed - bytes_extracted);
     memcpy(next_sample, packet_data.data() + bytes_consumed_, bytes_to_copy);
 
     next_sample += bytes_to_copy;
     bytes_consumed_ += bytes_to_copy;
     bytes_extracted += bytes_to_copy;
   }
 }
 
 }  // namespace remoting