Home | History | Annotate | Download | only in test 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
      6 #define CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
      7 
      8 #include <string>
      9 
     10 #include "base/files/file_path.h"
     11 #include "base/memory/ref_counted.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "content/browser/renderer_host/media/mock_media_observer.h"
     15 #include "content/public/renderer/content_renderer_client.h"
     16 #include "ipc/ipc_listener.h"
     17 #include "media/base/audio_hardware_config.h"
     18 #include "media/base/channel_layout.h"
     19 #include "testing/gtest/include/gtest/gtest.h"
     20 #include "third_party/webrtc/common_types.h"
     21 
     22 namespace IPC {
     23 class Channel;
     24 }
     25 
     26 namespace media {
     27 class AudioManager;
     28 }
     29 
     30 namespace net {
     31 class URLRequestContext;
     32 }
     33 
     34 namespace webrtc {
     35 class VoENetwork;
     36 }
     37 
     38 #if defined(OS_WIN)
     39 namespace base {
     40 namespace win {
     41 class ScopedCOMInitializer;
     42 }
     43 }
     44 #endif
     45 
     46 namespace content {
     47 
     48 class AudioMirroringManager;
     49 class ContentRendererClient;
     50 class MediaStreamManager;
     51 class RenderThreadImpl;
     52 class ResourceContext;
     53 class TestAudioInputRendererHost;
     54 class TestAudioRendererHost;
     55 class TestBrowserThread;
     56 class WebRtcAudioRenderer;
     57 class WebRTCMockRenderProcess;
     58 
     59 // Scoped class for WebRTC interfaces.  Fetches the wrapped interface
     60 // in the constructor via WebRTC's GetInterface mechanism and then releases
     61 // the reference in the destructor.
     62 template<typename T>
     63 class ScopedWebRTCPtr {
     64  public:
     65   template<typename Engine>
     66   explicit ScopedWebRTCPtr(Engine* e)
     67       : ptr_(T::GetInterface(e)) {}
     68   explicit ScopedWebRTCPtr(T* p) : ptr_(p) {}
     69   ~ScopedWebRTCPtr() { reset(); }
     70   T* operator->() const { return ptr_; }
     71   T* get() const { return ptr_; }
     72 
     73   // Releases the current pointer.
     74   void reset() {
     75     if (ptr_) {
     76       ptr_->Release();
     77       ptr_ = NULL;
     78     }
     79   }
     80 
     81   bool valid() const { return ptr_ != NULL; }
     82 
     83  private:
     84   T* ptr_;
     85 };
     86 
     87 // Wrapper to automatically calling T::Delete in the destructor.
     88 // This is useful for some WebRTC objects that have their own Create/Delete
     89 // methods and we can't use our our scoped_* classes.
     90 template <typename T>
     91 class WebRTCAutoDelete {
     92  public:
     93   WebRTCAutoDelete() : ptr_(NULL) {}
     94   explicit WebRTCAutoDelete(T* ptr) : ptr_(ptr) {}
     95   ~WebRTCAutoDelete() { reset(); }
     96 
     97   void reset() {
     98     if (ptr_) {
     99       T::Delete(ptr_);
    100       ptr_ = NULL;
    101     }
    102   }
    103 
    104   T* operator->() { return ptr_; }
    105   T* get() const { return ptr_; }
    106 
    107   bool valid() const { return ptr_ != NULL; }
    108 
    109  protected:
    110   T* ptr_;
    111 };
    112 
    113 // Implemented and defined in the cc file.
    114 class ReplaceContentClientRenderer;
    115 
    116 // Temporarily disabled in LeakSanitizer builds due to memory leaks.
    117 // http://crbug.com/148865
    118 // Disabling all tests for now since they are flaky.
    119 // http://crbug.com/167298
    120 #define MAYBE_WebRTCAudioDeviceTest DISABLED_WebRTCAudioDeviceTest
    121 
    122 class MAYBE_WebRTCAudioDeviceTest : public ::testing::Test,
    123                                     public IPC::Listener {
    124  public:
    125   MAYBE_WebRTCAudioDeviceTest();
    126   virtual ~MAYBE_WebRTCAudioDeviceTest();
    127 
    128   virtual void SetUp() OVERRIDE;
    129   virtual void TearDown() OVERRIDE;
    130 
    131   // Sends an IPC message to the IO thread channel.
    132   bool Send(IPC::Message* message);
    133 
    134   void SetAudioHardwareConfig(media::AudioHardwareConfig* hardware_config);
    135 
    136   scoped_refptr<WebRtcAudioRenderer> CreateDefaultWebRtcAudioRenderer(
    137       int render_view_id);
    138 
    139  protected:
    140   void InitializeIOThread(const char* thread_name);
    141   void UninitializeIOThread();
    142   void CreateChannel(const char* name);
    143   void DestroyChannel();
    144 
    145   void OnGetAudioHardwareConfig(media::AudioParameters* input_params,
    146                                 media::AudioParameters* output_params);
    147 
    148   // IPC::Listener implementation.
    149   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
    150 
    151   // Posts a final task to the IO message loop and waits for completion.
    152   void WaitForIOThreadCompletion();
    153   void WaitForAudioManagerCompletion();
    154   void WaitForMessageLoopCompletion(base::MessageLoopProxy* loop);
    155 
    156   std::string GetTestDataPath(const base::FilePath::StringType& file_name);
    157 
    158   scoped_ptr<ReplaceContentClientRenderer> saved_content_renderer_;
    159   base::MessageLoopForUI message_loop_;
    160   ContentRendererClient content_renderer_client_;
    161   RenderThreadImpl* render_thread_;  // Owned by mock_process_.
    162   scoped_ptr<WebRTCMockRenderProcess> mock_process_;
    163   scoped_ptr<MediaStreamManager> media_stream_manager_;
    164   scoped_ptr<media::AudioManager> audio_manager_;
    165   scoped_ptr<AudioMirroringManager> mirroring_manager_;
    166   scoped_ptr<net::URLRequestContext> test_request_context_;
    167   scoped_ptr<ResourceContext> resource_context_;
    168   scoped_ptr<IPC::Channel> channel_;
    169   scoped_refptr<TestAudioRendererHost> audio_render_host_;
    170   scoped_refptr<TestAudioInputRendererHost> audio_input_renderer_host_;
    171 
    172   media::AudioHardwareConfig* audio_hardware_config_;  // Weak reference.
    173 
    174   // Initialized on the main test thread that we mark as the UI thread.
    175   scoped_ptr<TestBrowserThread> ui_thread_;
    176   // Initialized on our IO thread to satisfy BrowserThread::IO checks.
    177   scoped_ptr<TestBrowserThread> io_thread_;
    178 
    179 #if defined(OS_WIN)
    180   // COM initialization on the IO thread.
    181   scoped_ptr<base::win::ScopedCOMInitializer> initialize_com_;
    182 #endif
    183 
    184   // These are initialized when we set up our IO thread.
    185   bool has_input_devices_;
    186   bool has_output_devices_;
    187 
    188   // The previous state for whether sandbox support was enabled in
    189   // RenderViewWebKitPlatformSupportImpl.
    190   bool sandbox_was_enabled_;
    191 };
    192 
    193 // A very basic implementation of webrtc::Transport that acts as a transport
    194 // but just forwards all calls to a local webrtc::VoENetwork implementation.
    195 // Ownership of the VoENetwork object lies outside the class.
    196 class WebRTCTransportImpl : public webrtc::Transport {
    197  public:
    198   explicit WebRTCTransportImpl(webrtc::VoENetwork* network);
    199   virtual ~WebRTCTransportImpl();
    200 
    201   virtual int SendPacket(int channel, const void* data, int len) OVERRIDE;
    202   virtual int SendRTCPPacket(int channel, const void* data, int len) OVERRIDE;
    203 
    204  private:
    205   webrtc::VoENetwork* network_;
    206 };
    207 
    208 }  // namespace content
    209 
    210 #endif  // CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
    211