Remove completion callbacks from AudioRenderer::Play/Pause().

media/base/serial_runner_unittest.cc

 // Copyright 2013 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/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/serial_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 17 matching lines @@
   // |status|. called(i) returns whether the i'th bound function pushed to the
   // queue was called while running the SerialRunner.
   void PushBoundFunction(PipelineStatus status) {
     bound_fns_.Push(base::Bind(&SerialRunnerTest::RunBoundFunction,
                                base::Unretained(this),
                                status,
                                called_.size()));
     called_.push_back(false);
   }
 
+  void PushBoundClosure() {
+    bound_fns_.Push(base::Bind(&SerialRunnerTest::RunBoundClosure,
+                               base::Unretained(this),
+                               called_.size()));
+    called_.push_back(false);
+  }
+
+  void PushClosure() {
+    bound_fns_.Push(base::Bind(&SerialRunnerTest::RunClosure,
+                               base::Unretained(this),
+                               called_.size()));
+    called_.push_back(false);
+  }
+
   // Push a bound function to the queue that will delete the SerialRunner,
   // which should cancel all remaining queued work.
   void PushCancellation() {
     bound_fns_.Push(base::Bind(&SerialRunnerTest::CancelSerialRunner,
                                base::Unretained(this)));
   }
 
   // Queries final status of pushed functions and done callback. Valid only
   // after calling RunSerialRunner().
   bool called(size_t index) { return called_[index]; }
   bool done_called() { return done_called_; }
   PipelineStatus done_status() { return done_status_; }
 
  private:
   void RunBoundFunction(PipelineStatus status,
                         size_t index,
                         const PipelineStatusCB& status_cb) {
     EXPECT_EQ(index == 0u, inside_start_)
         << "First bound function should run on same stack as "
         << "SerialRunner::Run() while all others should not\n"
         << base::debug::StackTrace().ToString();
 
     called_[index] = true;
     status_cb.Run(status);
   }
 
+  void RunBoundClosure(size_t index,
+                       const base::Closure& done_cb) {
+    EXPECT_EQ(index == 0u, inside_start_)
+        << "First bound function should run on same stack as "
+        << "SerialRunner::Run() while all others should not\n"
+        << base::debug::StackTrace().ToString();
+
+    called_[index] = true;
+    done_cb.Run();
+  }
+
+  void RunClosure(size_t index) {
+    EXPECT_EQ(index == 0u, inside_start_)
+        << "First bound function should run on same stack as "
+        << "SerialRunner::Run() while all others should not\n"
+        << base::debug::StackTrace().ToString();
+
+    called_[index] = true;
+  }
+
   void StartRunnerInternal(const SerialRunner::Queue& bound_fns) {
     inside_start_ = true;
     runner_ = SerialRunner::Run(bound_fns_, base::Bind(
         &SerialRunnerTest::DoneCallback, base::Unretained(this)));
     inside_start_ = false;
   }
 
   void DoneCallback(PipelineStatus status) {
     EXPECT_FALSE(inside_start_)
         << "Done callback should not run on same stack as SerialRunner::Run()\n"
@@ skipping 92 matching lines @@
   PushBoundFunction(PIPELINE_OK);
   PushCancellation();
   PushBoundFunction(PIPELINE_OK);
   RunSerialRunner();
 
   EXPECT_TRUE(called(0));
   EXPECT_FALSE(called(1));
   EXPECT_FALSE(done_called());
 }
 
+TEST_F(SerialRunnerTest, BoundClosure) {
+  PushBoundClosure();
+  RunSerialRunner();
+
+  EXPECT_TRUE(called(0));
+  EXPECT_TRUE(done_called());
+  EXPECT_EQ(PIPELINE_OK, done_status());
+}
+
+TEST_F(SerialRunnerTest, Closure) {
+  PushClosure();
+  RunSerialRunner();
+
+  EXPECT_TRUE(called(0));
+  EXPECT_TRUE(done_called());
+  EXPECT_EQ(PIPELINE_OK, done_status());
+}
+
 }  // namespace media