media/base/serial_runner_unittest.cc

   1 // Copyright 2013 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 #include "base/bind.h"
   6 #include "base/debug/stack_trace.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "media/base/pipeline_status.h"
   9 #include "media/base/serial_runner.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace media {
  13
  14 class SerialRunnerTest : public ::testing::Test {
  15  public:
  16   SerialRunnerTest()
  17       : inside_start_(false), done_called_(false), done_status_(PIPELINE_OK) {}
  18   virtual ~SerialRunnerTest() {}
  19
  20   void RunSerialRunner() {
  21     message_loop_.PostTask(FROM_HERE, base::Bind(
  22         &SerialRunnerTest::StartRunnerInternal, base::Unretained(this),
  23         bound_fns_));
  24     message_loop_.RunUntilIdle();
  25   }
  26
  27   // Pushes a bound function to the queue that will run its callback with
  28   // |status|. called(i) returns whether the i'th bound function pushed to the
  29   // queue was called while running the SerialRunner.
  30   void PushBoundFunction(PipelineStatus status) {
  31     bound_fns_.Push(base::Bind(&SerialRunnerTest::RunBoundFunction,
  32                                base::Unretained(this),
  33                                status,
  34                                called_.size()));
  35     called_.push_back(false);
  36   }
  37
  38   void PushBoundClosure() {
  39     bound_fns_.Push(base::Bind(&SerialRunnerTest::RunBoundClosure,
  40                                base::Unretained(this),
  41                                called_.size()));
  42     called_.push_back(false);
  43   }
  44
  45   void PushClosure() {
  46     bound_fns_.Push(base::Bind(&SerialRunnerTest::RunClosure,
  47                                base::Unretained(this),
  48                                called_.size()));
  49     called_.push_back(false);
  50   }
  51
  52   // Push a bound function to the queue that will delete the SerialRunner,
  53   // which should cancel all remaining queued work.
  54   void PushCancellation() {
  55     bound_fns_.Push(base::Bind(&SerialRunnerTest::CancelSerialRunner,
  56                                base::Unretained(this)));
  57   }
  58
  59   // Queries final status of pushed functions and done callback. Valid only
  60   // after calling RunSerialRunner().
  61   bool called(size_t index) { return called_[index]; }
  62   bool done_called() { return done_called_; }
  63   PipelineStatus done_status() { return done_status_; }
  64
  65  private:
  66   void RunBoundFunction(PipelineStatus status,
  67                         size_t index,
  68                         const PipelineStatusCB& status_cb) {
  69     EXPECT_EQ(index == 0u, inside_start_)
  70         << "First bound function should run on same stack as "
  71         << "SerialRunner::Run() while all others should not\n"
  72         << base::debug::StackTrace().ToString();
  73
  74     called_[index] = true;
  75     status_cb.Run(status);
  76   }
  77
  78   void RunBoundClosure(size_t index,
  79                        const base::Closure& done_cb) {
  80     EXPECT_EQ(index == 0u, inside_start_)
  81         << "First bound function should run on same stack as "
  82         << "SerialRunner::Run() while all others should not\n"
  83         << base::debug::StackTrace().ToString();
  84
  85     called_[index] = true;
  86     done_cb.Run();
  87   }
  88
  89   void RunClosure(size_t index) {
  90     EXPECT_EQ(index == 0u, inside_start_)
  91         << "First bound function should run on same stack as "
  92         << "SerialRunner::Run() while all others should not\n"
  93         << base::debug::StackTrace().ToString();
  94
  95     called_[index] = true;
  96   }
  97
  98   void StartRunnerInternal(const SerialRunner::Queue& bound_fns) {
  99     inside_start_ = true;
 100     runner_ = SerialRunner::Run(bound_fns_, base::Bind(
 101         &SerialRunnerTest::DoneCallback, base::Unretained(this)));
 102     inside_start_ = false;
 103   }
 104
 105   void DoneCallback(PipelineStatus status) {
 106     EXPECT_FALSE(inside_start_)
 107         << "Done callback should not run on same stack as SerialRunner::Run()\n"
 108         << base::debug::StackTrace().ToString();
 109
 110     done_called_ = true;
 111     done_status_ = status;
 112     message_loop_.QuitWhenIdle();
 113   }
 114
 115   void CancelSerialRunner(const PipelineStatusCB& status_cb) {
 116     // Tasks run by |runner_| shouldn't reset it, hence we post a task to do so.
 117     message_loop_.PostTask(FROM_HERE, base::Bind(
 118         &SerialRunnerTest::ResetSerialRunner, base::Unretained(this)));
 119     status_cb.Run(PIPELINE_OK);
 120   }
 121
 122   void ResetSerialRunner() {
 123     runner_.reset();
 124   }
 125
 126   base::MessageLoop message_loop_;
 127   SerialRunner::Queue bound_fns_;
 128   scoped_ptr<SerialRunner> runner_;
 129
 130   // Used to enforce calling stack guarantees of the API.
 131   bool inside_start_;
 132
 133   // Tracks whether the i'th bound function was called.
 134   std::vector<bool> called_;
 135
 136   // Tracks whether the final done callback was called + resulting status.
 137   bool done_called_;
 138   PipelineStatus done_status_;
 139
 140   DISALLOW_COPY_AND_ASSIGN(SerialRunnerTest);
 141 };
 142
 143 TEST_F(SerialRunnerTest, Empty) {
 144   RunSerialRunner();
 145
 146   EXPECT_TRUE(done_called());
 147   EXPECT_EQ(PIPELINE_OK, done_status());
 148 }
 149
 150 TEST_F(SerialRunnerTest, Single) {
 151   PushBoundFunction(PIPELINE_OK);
 152   RunSerialRunner();
 153
 154   EXPECT_TRUE(called(0));
 155   EXPECT_TRUE(done_called());
 156   EXPECT_EQ(PIPELINE_OK, done_status());
 157 }
 158
 159 TEST_F(SerialRunnerTest, Single_Error) {
 160   PushBoundFunction(PIPELINE_ERROR_ABORT);
 161   RunSerialRunner();
 162
 163   EXPECT_TRUE(called(0));
 164   EXPECT_TRUE(done_called());
 165   EXPECT_EQ(PIPELINE_ERROR_ABORT, done_status());
 166 }
 167
 168 TEST_F(SerialRunnerTest, Single_Cancel) {
 169   PushBoundFunction(PIPELINE_OK);
 170   PushCancellation();
 171   RunSerialRunner();
 172
 173   EXPECT_TRUE(called(0));
 174   EXPECT_FALSE(done_called());
 175 }
 176
 177 TEST_F(SerialRunnerTest, Multiple) {
 178   PushBoundFunction(PIPELINE_OK);
 179   PushBoundFunction(PIPELINE_OK);
 180   RunSerialRunner();
 181
 182   EXPECT_TRUE(called(0));
 183   EXPECT_TRUE(called(1));
 184   EXPECT_TRUE(done_called());
 185   EXPECT_EQ(PIPELINE_OK, done_status());
 186 }
 187
 188 TEST_F(SerialRunnerTest, Multiple_Error) {
 189   PushBoundFunction(PIPELINE_ERROR_ABORT);
 190   PushBoundFunction(PIPELINE_OK);
 191   RunSerialRunner();
 192
 193   EXPECT_TRUE(called(0));
 194   EXPECT_FALSE(called(1));  // A bad status cancels remaining work.
 195   EXPECT_TRUE(done_called());
 196   EXPECT_EQ(PIPELINE_ERROR_ABORT, done_status());
 197 }
 198
 199 TEST_F(SerialRunnerTest, Multiple_Cancel) {
 200   PushBoundFunction(PIPELINE_OK);
 201   PushCancellation();
 202   PushBoundFunction(PIPELINE_OK);
 203   RunSerialRunner();
 204
 205   EXPECT_TRUE(called(0));
 206   EXPECT_FALSE(called(1));
 207   EXPECT_FALSE(done_called());
 208 }
 209
 210 TEST_F(SerialRunnerTest, BoundClosure) {
 211   PushBoundClosure();
 212   RunSerialRunner();
 213
 214   EXPECT_TRUE(called(0));
 215   EXPECT_TRUE(done_called());
 216   EXPECT_EQ(PIPELINE_OK, done_status());
 217 }
 218
 219 TEST_F(SerialRunnerTest, Closure) {
 220   PushClosure();
 221   RunSerialRunner();
 222
 223   EXPECT_TRUE(called(0));
 224   EXPECT_TRUE(done_called());
 225   EXPECT_EQ(PIPELINE_OK, done_status());
 226 }
 227
 228 }  // namespace media