Initialize the shared memory to appease Valgrind.

content/renderer/media/audio_device_unittest.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 <vector>
 
 #include "base/at_exit.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
@@ skipping 93 matching lines @@
 ACTION_P2(SendPendingBytes, socket, pending_bytes) {
   socket->Send(&pending_bytes, sizeof(pending_bytes));
 }
 
 // Used to terminate a loop from a different thread than the loop belongs to.
 // |loop| should be a MessageLoopProxy.
 ACTION_P(QuitLoop, loop) {
   loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
+// Zeros out all the buffers in the |audio_data| vector.
+void FillData(const std::vector<float*>& audio_data,
+             int number_of_frames,

[henrika (OOO until Aug 14), 2012/07/23 11:17:07]

Odd indentation. int is not aligned with const.

[tommi (sloooow) - chröme, 2012/07/23 12:23:10]

Done.

+             int audio_delay_milliseconds) {
+  std::vector<float*>::const_iterator it = audio_data.begin();
+  for (; it != audio_data.end(); ++it) {
+    float* channel = *it;
+    for (int j = 0; j < number_of_frames; ++j) {
+      channel[j] = 0.0f;
+    }
+  }
+}
+
 }  // namespace.
 
 class AudioDeviceTest : public testing::Test {
  public:
   AudioDeviceTest()
       : default_audio_parameters_(media::AudioParameters::AUDIO_PCM_LINEAR,
                                   CHANNEL_LAYOUT_STEREO,
                                   48000, 16, 1024),
         stream_id_(-1) {
   }
@@ skipping 66 matching lines @@
   // stream id.
   ASSERT_NE(stream_id_, -1);
 
   // This is where it gets a bit hacky.  The shared memory contract between
   // AudioDevice and its browser side counter part includes a bit more than
   // just the audio data, so we must call TotalSharedMemorySizeInBytes() to get
   // the actual size needed to fit the audio data plus the extra data.
   int memory_size = media::TotalSharedMemorySizeInBytes(
       default_audio_parameters_.GetBytesPerBuffer());
   SharedMemory shared_memory;
-  ASSERT_TRUE(shared_memory.CreateAnonymous(memory_size));
+  ASSERT_TRUE(shared_memory.CreateAndMapAnonymous(memory_size));
+  // Initialize the memory.
+  memset(shared_memory.memory(), 0xff, memory_size);
 
   CancelableSyncSocket browser_socket, renderer_socket;
   ASSERT_TRUE(CancelableSyncSocket::CreatePair(&browser_socket,
                                                &renderer_socket));
 
   // Create duplicates of the handles we pass to AudioDevice since ownership
   // will be transferred and AudioDevice is responsible for freeing.
   SyncSocket::Handle audio_device_socket = SyncSocket::kInvalidHandle;
   ASSERT_TRUE(DuplicateSocketHandle(renderer_socket.handle(),
                                     &audio_device_socket));
@@ skipping 10 matching lines @@
 
   // We expect calls to our audio renderer callback, which returns the number
   // of frames written to the memory section.
   // Here's the second place where it gets hacky:  There's no way for us to
   // know (without using a sleep loop!) when the AudioDevice has finished
   // writing the interleaved audio data into the shared memory section.
   // So, for the sake of this test, we consider the call to Render a sign
   // of success and quit the loop.
   EXPECT_CALL(callback_, Render(_, _, _))
       .WillOnce(DoAll(
+          WithArgs<0, 1, 2>(Invoke(&FillData)),

[henrika (OOO until Aug 14), 2012/07/23 11:17:07]

Mind adding a comment?

[tommi (sloooow) - chröme, 2012/07/23 12:23:10]

Done.

           QuitLoop(io_loop_.message_loop_proxy()),
           Return(1)));

[henrika (OOO until Aug 14), 2012/07/23 11:17:07]

Why 1 here?

 
   audio_device->OnStreamCreated(duplicated_memory_handle, audio_device_socket,
                                 memory_size);
 
   io_loop_.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                            TestTimeouts::action_timeout());
   io_loop_.Run();
 
   // Close the stream sequence.
 
   EXPECT_CALL(*audio_message_filter_, OnCloseStream(stream_id_));
 
   audio_device->Stop();
   io_loop_.RunAllPending();
 }