Add thread safety to AudioManagerBase to protect access to the audio thread member variable.

media/audio/audio_output_proxy_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 "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/threading/platform_thread.h"
 #include "media/audio/audio_output_dispatcher.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
@@ skipping 27 matching lines @@
   MOCK_METHOD1(MakeAudioOutputStream, AudioOutputStream*(
       const AudioParameters& params));
   MOCK_METHOD1(MakeAudioOutputStreamProxy, AudioOutputStream*(
       const AudioParameters& params));
   MOCK_METHOD2(MakeAudioInputStream, AudioInputStream*(
       const AudioParameters& params, const std::string& device_id));
   MOCK_METHOD0(MuteAll, void());
   MOCK_METHOD0(UnMuteAll, void());
   MOCK_METHOD0(CanShowAudioInputSettings, bool());
   MOCK_METHOD0(ShowAudioInputSettings, void());
-  MOCK_METHOD0(GetMessageLoop, MessageLoop*());
+  MOCK_METHOD0(GetMessageLoop, scoped_refptr<base::MessageLoopProxy>());
   MOCK_METHOD1(GetAudioInputDeviceNames, void(
       media::AudioDeviceNames* device_name));
   MOCK_METHOD0(IsRecordingInProcess, bool());
 };
 
 class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
   MOCK_METHOD4(OnMoreData, uint32(AudioOutputStream* stream,
                                   uint8* dest, uint32 max_size,
                                   AudioBuffersState buffers_state));
   MOCK_METHOD2(OnError, void(AudioOutputStream* stream, int code));
 };
 
 class AudioOutputProxyTest : public testing::Test {
  protected:
   virtual void SetUp() {
     MockAudioManager* manager = new MockAudioManager();
     EXPECT_CALL(*manager, GetMessageLoop())
-        .WillRepeatedly(Return(&message_loop_));
+        .WillRepeatedly(Return(message_loop_.message_loop_proxy()));
     manager_ = manager;
     InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
   }
 
   virtual void TearDown() {
     // All paused proxies should have been closed at this point.
     EXPECT_EQ(0u, dispatcher_->paused_proxies_);
 
     // This is necessary to free all proxy objects that have been
     // closed by the test.
@@ skipping 282 matching lines @@
 
   EXPECT_CALL(callback_, OnError(_, _))
       .Times(1);
 
   proxy->Start(&callback_);
 
   Mock::VerifyAndClear(&callback_);
 
   proxy->Close();
 }