Audio input debug recording refactoring to reduce thread hops and simplify object ownership

content/browser/renderer_host/media/audio_input_debug_writer_unittest.cc

 // Copyright 2015 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 <stdint.h>
 
 #include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/sys_byteorder.h"
 #include "content/browser/renderer_host/media/audio_input_debug_writer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/base/audio_bus.h"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
@@ skipping 16 matching lines @@
 }  // namespace
 
 // <channel layout, sample rate, frames per buffer, number of buffer writes
 typedef std::tr1::tuple<media::ChannelLayout, int, int, int>
     AudioInputDebugWriterTestData;
 
 class AudioInputDebugWriterTest
     : public testing::TestWithParam<AudioInputDebugWriterTestData> {
  public:
   AudioInputDebugWriterTest()
-      : params_(media::AudioParameters::Format::AUDIO_PCM_LINEAR,
+      : thread_bundle_(content::TestBrowserThreadBundle::REAL_FILE_THREAD),
+        params_(media::AudioParameters::Format::AUDIO_PCM_LINEAR,
                 std::tr1::get<0>(GetParam()),
                 std::tr1::get<1>(GetParam()),
                 kBytesPerSample * 8,
                 std::tr1::get<2>(GetParam())),
         writes_(std::tr1::get<3>(GetParam())),
         source_samples_(params_.frames_per_buffer() * params_.channels() *
                         writes_),
         source_interleaved_(source_samples_ ? new int16_t[source_samples_]
                                             : nullptr) {
     InitSourceInterleaved(source_interleaved_.get(), source_samples_);
@@ skipping 90 matching lines @@
       EXPECT_EQ(static_cast<int>(file.GetLength() - kWavHeaderSize), read);
 
       VerifyDataRecording(source_interleaved_.get(), result_interleaved.get(),
                           source_samples_);
     }
   }
 
   void TestDoneOnFileThread(const base::Closure& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
-    // |writer| must be destroyed on FILE thread.
-    input_debug_writer_.reset(nullptr);
     callback.Run();
   }
 
-  void DoDebugRecording(base::File file) {
-    if (!file.IsValid())
-      return;
-
-    input_debug_writer_.reset(
-        new AudioInputDebugWriter(std::move(file), params_));
+  void DoDebugRecording() {
     // Write tasks are posted to BrowserThread::FILE.
     for (int i = 0; i < writes_; ++i) {
       std::unique_ptr<media::AudioBus> bus = media::AudioBus::Create(
           params_.channels(), params_.frames_per_buffer());
 
       bus->FromInterleaved(
           source_interleaved_.get() +
               i * params_.channels() * params_.frames_per_buffer(),
           params_.frames_per_buffer(), kBytesPerSample);
 
       input_debug_writer_->Write(std::move(bus));
     }
+  }
 
+  void WaitForRecordingCompletion() {
     media::WaitableMessageLoopEvent event;
 
     // Post a task to BrowserThread::FILE indicating that all the writes are
     // done.
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&AudioInputDebugWriterTest::TestDoneOnFileThread,
                    base::Unretained(this), event.GetClosure()));
 
     // Wait for TestDoneOnFileThread() to call event's closure.
     event.RunAndWait();
   }
 
+  void RecordAndVerifyOnce() {
+    base::FilePath file_path;
+    EXPECT_TRUE(base::CreateTemporaryFile(&file_path));
+
+    input_debug_writer_->Start(file_path);
+
+    DoDebugRecording();
+
+    input_debug_writer_->Stop();
+
+    WaitForRecordingCompletion();
+
+    VerifyRecording(file_path);
+
+    if (::testing::Test::HasFailure()) {
+      LOG(ERROR) << "Test failed; keeping recording(s) at ["
+                 << file_path.value().c_str() << "].";
+    } else {
+      EXPECT_TRUE(base::DeleteFile(file_path, false));
+    }
+  }
+
  protected:
   TestBrowserThreadBundle thread_bundle_;
 
   // Writer under test.
   std::unique_ptr<AudioInputDebugWriter> input_debug_writer_;
 
   // AudioBus parameters.
   media::AudioParameters params_;
 
   // Number of times to write AudioBus to the file.
   int writes_;
 
   // Number of samples in the source data.
   int source_samples_;
 
   // Source data.
   std::unique_ptr<int16_t[]> source_interleaved_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioInputDebugWriterTest);
 };
 
+class AudioInputDebugWriterBehavioralTest : public AudioInputDebugWriterTest {};
+
 TEST_P(AudioInputDebugWriterTest, WaveRecordingTest) {
+  input_debug_writer_.reset(new AudioInputDebugWriter(params_));
+
+  RecordAndVerifyOnce();
+}
+
+TEST_P(AudioInputDebugWriterBehavioralTest,
+       DeletedBeforeRecordingFinishedOnFileThread) {
+  input_debug_writer_.reset(new AudioInputDebugWriter(params_));
+
   base::FilePath file_path;
   EXPECT_TRUE(base::CreateTemporaryFile(&file_path));
 
-  base::File file(file_path,
-                  base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
-  EXPECT_TRUE(file.IsValid());
+  base::WaitableEvent* wait_for_deletion =
+      new base::WaitableEvent(base::WaitableEvent::ResetPolicy::MANUAL,
+                              base::WaitableEvent::InitialState::NOT_SIGNALED);
 
-  DoDebugRecording(std::move(file));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&base::WaitableEvent::Wait, base::Owned(wait_for_deletion)));
+
+  input_debug_writer_->Start(file_path);
+
+  DoDebugRecording();
+
+  input_debug_writer_.reset();
+  wait_for_deletion->Signal();
+
+  WaitForRecordingCompletion();
 
   VerifyRecording(file_path);
 
   if (::testing::Test::HasFailure()) {
     LOG(ERROR) << "Test failed; keeping recording(s) at ["
                << file_path.value().c_str() << "].";
   } else {
     EXPECT_TRUE(base::DeleteFile(file_path, false));
   }
 }
 
+TEST_P(AudioInputDebugWriterBehavioralTest, FileCreationError) {
+  input_debug_writer_.reset(new AudioInputDebugWriter(params_));
+  base::FilePath file_path;  // Empty file name.
+  input_debug_writer_->Start(file_path);
+  DoDebugRecording();
+}
+
+TEST_P(AudioInputDebugWriterBehavioralTest, StartStopStartStop) {
+  input_debug_writer_.reset(new AudioInputDebugWriter(params_));
+  RecordAndVerifyOnce();
+  RecordAndVerifyOnce();
+}
+
+TEST_P(AudioInputDebugWriterBehavioralTest, DestroyNotStarted) {
+  input_debug_writer_.reset(new AudioInputDebugWriter(params_));
+  input_debug_writer_.reset();
+}
+
+TEST_P(AudioInputDebugWriterBehavioralTest, DestroyStarted) {
+  input_debug_writer_.reset(new AudioInputDebugWriter(params_));
+  base::FilePath file_path;
+  EXPECT_TRUE(base::CreateTemporaryFile(&file_path));
+  input_debug_writer_->Start(file_path);
+  input_debug_writer_.reset();
+}
+
 INSTANTIATE_TEST_CASE_P(
     AudioInputDebugWriterTest,
     AudioInputDebugWriterTest,
-    // Using 10ms sframes per buffer everywhere.
+    // Using 10ms frames per buffer everywhere.
     testing::Values(
         // No writes.
         std::tr1::make_tuple(media::ChannelLayout::CHANNEL_LAYOUT_MONO,
                              44100,
                              44100 / 100,
                              0),
         // 1 write of mono.
         std::tr1::make_tuple(media::ChannelLayout::CHANNEL_LAYOUT_MONO,
                              44100,
                              44100 / 100,
@@ skipping 12 matching lines @@
         std::tr1::make_tuple(media::ChannelLayout::CHANNEL_LAYOUT_STEREO,
                              44100,
                              44100 / 100,
                              100),
         // 15 seconds of stereo, higher rate.
         std::tr1::make_tuple(media::ChannelLayout::CHANNEL_LAYOUT_STEREO,
                              48000,
                              48000 / 100,
                              1500)));
 
+INSTANTIATE_TEST_CASE_P(
+    AudioInputDebugWriterBehavioralTest,
+    AudioInputDebugWriterBehavioralTest,
+    // Using 10ms frames per buffer everywhere.
+    testing::Values(
+        // No writes.
+        std::tr1::make_tuple(media::ChannelLayout::CHANNEL_LAYOUT_MONO,
+                             44100,
+                             44100 / 100,
+                             100)));
+
 }  // namespace content