First unit tests for WebRTCAudioDevice.

content/test/webrtc_audio_device_test.h

Index: content/test/webrtc_audio_device_test.h
===================================================================
--- content/test/webrtc_audio_device_test.h	(revision 0)
+++ content/test/webrtc_audio_device_test.h	(working copy)
@@ -0,0 +1,192 @@
+// Copyright (c) 2011 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.
+
+#ifndef CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
+#define CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
+#pragma once
+
+#include "base/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/browser/renderer_host/media/mock_media_observer.h"
+#include "content/renderer/media/audio_renderer_impl.h"
+#include "content/renderer/mock_content_renderer_client.h"
+#include "ipc/ipc_channel.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/webrtc/common_types.h"
+
+class AudioInputRendererHost;
+class AudioRendererHost;
+class RenderThreadImpl;
+class WebRTCMockRenderProcess;
+
+namespace content {
+class ContentRendererClient;
+class ResourceContext;
+class TestBrowserThread;
+}
+
+namespace net {
+class URLRequestContext;
+}
+
+namespace webrtc {
+class VoENetwork;
+}
+
+// Scoped class for WebRTC interfaces.  Fetches the wrapped interface
+// in the constructor via WebRTC's GetInterface mechanism and then releases
+// the reference in the destructor.
+template<typename T>
+class ScopedWebRTCPtr {
+ public:
+  template<typename Engine>
+  explicit ScopedWebRTCPtr(Engine* e)
+      : ptr_(T::GetInterface(e)) {}
+  explicit ScopedWebRTCPtr(T* p) : ptr_(p) {}
+  ~ScopedWebRTCPtr() { reset(); }
+  T* operator->() const { return ptr_; }
+  T* get() const { return ptr_; }
+
+  // Releases the current pointer.
+  void reset() {
+    if (ptr_) {
+      ptr_->Release();
+      ptr_ = NULL;
+    }
+  }
+
+  bool valid() const { return ptr_ != NULL; }
+
+ private:
+  T* ptr_;
+};
+
+// Wrapper to automatically calling T::Delete in the destructor.
+// This is useful for some WebRTC objects that have their own Create/Delete
+// methods and we can't use our our scoped_* classes.
+template <typename T>
+class WebRTCAutoDelete {
+ public:
+  WebRTCAutoDelete() : ptr_(NULL) {}
+  explicit WebRTCAutoDelete(T* ptr) : ptr_(ptr) {}
+  ~WebRTCAutoDelete() { reset(); }
+
+  void reset() {
+    if (ptr_) {
+      T::Delete(ptr_);
+      ptr_ = NULL;
+    }
+  }
+
+  T* operator->() { return ptr_; }
+  T* get() const { return ptr_; }
+
+  bool valid() const { return ptr_ != NULL; }
+
+ protected:
+  T* ptr_;
+};
+
+// Individual tests can provide an implementation (or mock) of this interface
+// when the audio code queries for hardware capabilities on the IO thread.
+class AudioUtilInterface {
+ public:
+  virtual double GetAudioHardwareSampleRate() = 0;
+  virtual double GetAudioInputHardwareSampleRate() = 0;
+};
+
+class WebRTCAudioDeviceTest
+    : public ::testing::Test,
+      public IPC::Channel::Listener {
+ public:
+  class SetupTask : public base::RefCountedThreadSafe<SetupTask> {
+   public:
+    explicit SetupTask(WebRTCAudioDeviceTest* test) : test_(test) {}

[Paweł Hajdan Jr., 2011/11/02 18:00:24]

nit: Ah, it's probably useful to DCHECK here (if test is NULL, things will crash
later anyway, just more mysteriously).

This is an exception from avoiding DCHECK in test code, but in this case it'd
crash anyway.

[tommi (sloooow) - chröme, 2011/11/04 08:59:00]

Done.

+    void InitializeIOThread(const char* thread_name) {
+      test_->InitializeIOThread(thread_name);
+    }
+    void UninitializeIOThread() { test_->UninitializeIOThread(); }
+   protected:
+    WebRTCAudioDeviceTest* test_;
+  };
+
+  WebRTCAudioDeviceTest();
+  virtual ~WebRTCAudioDeviceTest();
+
+  virtual void SetUp();
+  virtual void TearDown();
+
+  // Sends an IPC message to the IO thread channel.
+  bool Send(IPC::Message* message);
+
+  void set_audio_util_callback(AudioUtilInterface* callback) {
+    audio_util_callback_ = callback;
+  }
+
+ protected:
+  void InitializeIOThread(const char* thread_name);
+  void UninitializeIOThread();
+  void CreateChannel(const char* name,
+                     content::ResourceContext* resource_context);
+  void DestroyChannel();
+
+  void OnGetHardwareSampleRate(double* sample_rate);
+  void OnGetHardwareInputSampleRate(double* sample_rate);
+
+  // IPC::Channel::Listener implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message);
+
+  // Posts a final task to the IO message loop and waits for completion.
+  void WaitForIOThreadCompletion();
+
+  // Convenience getter for gmock.
+  MockMediaObserver& media_observer() const {
+    return *media_observer_.get();
+  }
+
+  std::string GetTestDataPath(const FilePath::StringType& file_name);
+
+  // Actual implementation of the short and long PlayFile tests.
+  // If the |duration| parameter is 0, then the function determines the length
+  // of the audio file and plays the entire file.  Otherwise, |duration|
+  // specifies the number of milliseconds to allow the file to play.
+  void PlayLocalFile(int duration);
+
+  content::ContentRendererClient* saved_content_renderer_;
+  MessageLoopForUI message_loop_;
+  content::MockContentRendererClient mock_content_renderer_client_;
+  RenderThreadImpl* render_thread_;  // owned by mock_process_
+  scoped_ptr<WebRTCMockRenderProcess> mock_process_;
+  //media::MockFilterHost host_;
+  base::WaitableEvent event_;
+  scoped_ptr<MockMediaObserver> media_observer_;
+  scoped_ptr<content::ResourceContext> resource_context_;
+  scoped_refptr<net::URLRequestContext> test_request_context_;
+  scoped_ptr<IPC::Channel> channel_;
+  scoped_refptr<AudioRendererHost> audio_render_host_;
+  AudioUtilInterface* audio_util_callback_;  // Weak reference.
+
+  // Initialized on the main test thread that we mark as the UI thread.
+  scoped_ptr<content::TestBrowserThread> ui_thread_;
+  // Initialized on our IO thread to satisfy BrowserThread::IO checks.
+  scoped_ptr<content::TestBrowserThread> io_thread_;
+};
+
+// A very basic implementation of webrtc::Transport that acts as a transport
+// but just forwards all calls to a local webrtc::VoENetwork implementation.
+// Ownership of the VoENetwork object lies outside the class.
+class WebRTCTransportImpl : public webrtc::Transport {
+ public:
+  explicit WebRTCTransportImpl(webrtc::VoENetwork* network);
+  virtual ~WebRTCTransportImpl();
+
+  virtual int SendPacket(int channel, const void* data, int len);
+  virtual int SendRTCPPacket(int channel, const void* data, int len);
+
+ private:
+  webrtc::VoENetwork* network_;
+};
+
+#endif  // CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
Property changes on: content/test/webrtc_audio_device_test.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+LF