Introduce PushPullFIFO class and remove other FIFOs

third_party/WebKit/Source/platform/audio/PushPullFIFOTest.cpp

+// Copyright 2017 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 "platform/audio/PushPullFIFO.h"
+
+#include "platform/audio/AudioUtilities.h"
+#include "platform/testing/TestingPlatformSupport.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
+#include <vector>
+
+namespace blink {
+
+namespace {
+
+// Fills each AudioChannel in an AudioBus with a series of linearly increasing
+// values starting from |startingValue|. Then return value will be

[Raymond Toy, 2017/01/30 20:59:28]

nit: "from |startingValue|" -> "from |startingValue| and incrementing by 1"

[hongchan, 2017/02/01 18:07:28]

Done.

+// |startingValue| + |bus_length|.
+size_t fillBusWithLinearRamp(AudioBus* targetBus, size_t startingValue) {
+  for (unsigned c = 0; c < targetBus->numberOfChannels(); ++c) {
+    float* busChannel = targetBus->channel(c)->mutableData();
+    for (size_t i = 0; i < targetBus->channel(c)->length(); ++i) {
+      busChannel[i] = static_cast<float>(startingValue + i);
+    }
+  }
+  return startingValue + targetBus->length();
+}
+
+// Inspect the content of AudioBus with a given set of index and value across
+// channels.
+bool verifyBusValueAtIndex(AudioBus* targetBus,
+                           int index,
+                           float expectedValue) {
+  for (unsigned c = 0; c < targetBus->numberOfChannels(); ++c) {
+    float* busChannel = targetBus->channel(c)->mutableData();
+    if (busChannel[index] != expectedValue) {
+      LOG(ERROR) << ">> [FAIL] expected " << expectedValue << " at index "
+                 << index << " but got " << busChannel[index] << ".";
+      return false;
+    }
+  }
+  return true;
+}
+
+struct FIFOAction {
+  // The type of action; "PUSH" or "PULL".
+  const char* type;

[Raymond Toy, 2017/01/30 20:59:29]

"type" is too generic.  Maybe "action"?

[hongchan, 2017/02/01 18:07:28]

Done.

+  // Number of frames for the operation.
+  const size_t numberOfFrames;
+};
+
+struct AudioBusSample {
+  // The frame index of a sample in the bus.
+  const size_t index;
+  // The value at the |index| above.
+  const float value;
+};
+
+struct FIFOTestSetup {
+  // Length of FIFO to be created for test case.
+  const size_t fifoLength;
+  // Channel count of FIFO to be created for test case.
+  const unsigned numberOfChannels;
+  // A list of |FIFOAction| entries to be performed in test case.
+  const std::vector<FIFOAction> fifoActions;
+};
+
+struct FIFOTestExpectedState {
+  // Expected read index in FIFO.
+  const size_t indexRead;
+  // Expected write index in FIFO.
+  const size_t indexWrite;
+  // Expected overflow count in FIFO.
+  const unsigned overflowCount;
+  // Expected underflow count in FIFO.
+  const unsigned underflowCount;
+  // A list of expected |AudioBusSample| entries for the FIFO bus.
+  const std::vector<AudioBusSample> fifoSamples;
+  // A list of expected |AudioBusSample| entries for the output bus.
+  const std::vector<AudioBusSample> outputSamples;
+};
+
+// The data structure for the parameterized test cases.
+struct FIFOTestParam {
+  FIFOTestSetup setup;
+  FIFOTestExpectedState expectedState;
+};
+
+std::ostream& operator<<(std::ostream& out, const FIFOTestParam& param) {
+  out << "fifoLength=" << param.setup.fifoLength
+      << "numberOfChannels=" << param.setup.numberOfChannels;
+  return out;
+}
+
+FIFOTestParam basicFIFOTestParams[] = {
+
+    // 1. Push 1024 frames first then pull 1024 frames.

[Raymond Toy, 2017/01/30 20:59:29]

How does this work?  Or does this really mean you push 128 frames 8 times before
pulling 1024 frames out?

+    {{8192, 2, {{"PUSH", 1024}, {"PULL", 1024}}},
+     {1024, 1024, 0, 0, {{1024, 0}}, {{0, 0}, {1023, 1023}}}},
+
+    // 2. Push 3 x 768 frames, then pull 1024 frames. 1 overflow should be
+    //    recorded and the wrap-around should happen correctly. Use odd channel

[Raymond Toy, 2017/01/30 20:59:29]

"odd" mean not even? Or "odd" meaning unusual?  I think you mean unusual here.

[hongchan, 2017/02/01 18:07:28]

Done.

+    //    count.
+    {{2048, 3, {{"PUSH", 768}, {"PUSH", 768}, {"PUSH", 768}, {"PULL", 1024}}},
+     {1280, 256, 1, 0, {{255, 2303}, {256, 256}}, {{0, 256}, {1023, 1279}}}},
+
+    // 3. Push 512 frames and then pull 1024. Check if underflow occurs
+    //    correctly. Inspect the output bus content; the underflow will fill the
+    //    second half of the output bus silence. Use odd FIFO size.

[Raymond Toy, 2017/01/30 20:59:28]

If you're inspecting the output, you need a test case with more than one
channel.

[hongchan, 2017/02/01 18:07:28]

All the verification in this test is done through out the channels. For example,
if you inspect the frame #10, you are inspecting values in #10 frames in all the
channels.

Do you think we have to test if copying AudioBus is working correctly?

+    {{4096, 1, {{"PUSH", 512}, {"PULL", 1024}}},
+     {512, 512, 0, 1, {{512, 0}}, {{0, 0}, {511, 511}, {512, 0}, {1023, 0}}}},
+
+    // 4. Push 11, 324 frames. Then pull 11, 324 frames. The most recent output

[Raymond Toy, 2017/01/30 20:59:28]

Your contract said you can only push 128 frames.  So what is this really
testing?

[hongchan, 2017/02/01 18:07:28]

This is to accommodate o1ka@'s suggestion. Now we have the contract, I will fix
the test accordingly.

+    //    must start from 11 and end with 323. Use odd FIFO size and channel
+    //    count.
+    {{1234, 5, {{"PUSH", 11}, {"PUSH", 324}, {"PULL", 11}, {"PULL", 324}}},
+     {335, 335, 0, 0, {}, {{0, 11}, {323, 334}}}}};
+
+class PushPullFIFOTest : public ::testing::TestWithParam<FIFOTestParam> {};
+
+TEST_P(PushPullFIFOTest, BasicTests) {
+  const FIFOTestSetup setup = GetParam().setup;
+  const FIFOTestExpectedState expectedState = GetParam().expectedState;
+
+  // Create a FIFO with a specified configuration.
+  std::unique_ptr<PushPullFIFO> fifo = WTF::wrapUnique(
+      new PushPullFIFO(setup.numberOfChannels, setup.fifoLength));
+
+  RefPtr<AudioBus> outputBus;
+
+  // Iterate all the scheduled push/pull actions.
+  size_t frameCounter = 0;
+  for (const auto& action : setup.fifoActions) {
+    if (strcmp(action.type, "PUSH") == 0) {
+      RefPtr<AudioBus> inputBus =
+          AudioBus::create(setup.numberOfChannels, action.numberOfFrames);
+      frameCounter = fillBusWithLinearRamp(inputBus.get(), frameCounter);
+      fifo->push(inputBus.get());
+      LOG(INFO) << "PUSH " << action.numberOfFrames
+                << " frames (frameCounter=" << frameCounter << ")";
+    } else {
+      outputBus =
+          AudioBus::create(setup.numberOfChannels, action.numberOfFrames);
+      fifo->pull(outputBus.get(), action.numberOfFrames);
+      LOG(INFO) << "PULL " << action.numberOfFrames << " frames";
+    }
+  }
+
+  // Get FIFO config data.
+  const PushPullFIFOStateForTest actualState = fifo->getStateForTest();
+
+  // Verify the read/write indexes.
+  EXPECT_EQ(actualState.indexRead, expectedState.indexRead);
+  EXPECT_EQ(actualState.indexWrite, expectedState.indexWrite);
+  EXPECT_EQ(actualState.overflowCount, expectedState.overflowCount);
+  EXPECT_EQ(actualState.underflowCount, expectedState.underflowCount);
+
+  // Verify in-FIFO samples.
+  for (const auto& sample : expectedState.fifoSamples) {
+    EXPECT_TRUE(verifyBusValueAtIndex(fifo->bus(), sample.index, sample.value));
+  }
+
+  // Verify samples from the most recent output bus.
+  for (const auto& sample : expectedState.outputSamples) {
+    EXPECT_TRUE(
+        verifyBusValueAtIndex(outputBus.get(), sample.index, sample.value));
+  }
+}
+
+INSTANTIATE_TEST_CASE_P(PushPullFIFOTest,
+                        PushPullFIFOTest,
+                        ::testing::ValuesIn(basicFIFOTestParams));
+
+// TODO(hongchan): Do death tests for SECURITY_CHECK().
+
+}  // namespace
+
+}  // namespace blink