chrome/browser/media/webrtc_rtp_dump_handler_unittest.cc

   1 // Copyright 2014 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/files/file_util.h"
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/location.h"
   9 #include "base/macros.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/run_loop.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "chrome/browser/media/webrtc_rtp_dump_handler.h"
  15 #include "chrome/browser/media/webrtc_rtp_dump_writer.h"
  16 #include "content/public/test/test_browser_thread_bundle.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 class FakeDumpWriter : public WebRtcRtpDumpWriter {
  21  public:
  22   FakeDumpWriter(size_t max_dump_size,
  23                  const base::Closure& max_size_reached_callback,
  24                  bool end_dump_success)
  25       : WebRtcRtpDumpWriter(base::FilePath(),
  26                             base::FilePath(),
  27                             max_dump_size,
  28                             base::Closure()),
  29         max_dump_size_(max_dump_size),
  30         current_dump_size_(0),
  31         max_size_reached_callback_(max_size_reached_callback),
  32         end_dump_success_(end_dump_success) {}
  33
  34   void WriteRtpPacket(const uint8* packet_header,
  35                       size_t header_length,
  36                       size_t packet_length,
  37                       bool incoming) override {
  38     current_dump_size_ += header_length;
  39     if (current_dump_size_ > max_dump_size_)
  40       max_size_reached_callback_.Run();
  41   }
  42
  43   void EndDump(RtpDumpType type,
  44                const EndDumpCallback& finished_callback) override {
  45     bool incoming_sucess = end_dump_success_;
  46     bool outgoing_success = end_dump_success_;
  47
  48     if (type == RTP_DUMP_INCOMING)
  49       outgoing_success = false;
  50     else if (type == RTP_DUMP_OUTGOING)
  51       incoming_sucess = false;
  52
  53     base::ThreadTaskRunnerHandle::Get()->PostTask(
  54         FROM_HERE,
  55         base::Bind(finished_callback, incoming_sucess, outgoing_success));
  56   }
  57
  58  private:
  59   size_t max_dump_size_;
  60   size_t current_dump_size_;
  61   base::Closure max_size_reached_callback_;
  62   bool end_dump_success_;
  63 };
  64
  65 class WebRtcRtpDumpHandlerTest : public testing::Test {
  66  public:
  67   WebRtcRtpDumpHandlerTest()
  68       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
  69     ResetDumpHandler(base::FilePath(), true);
  70   }
  71
  72   void ResetDumpHandler(const base::FilePath& dir, bool end_dump_success) {
  73     handler_.reset(new WebRtcRtpDumpHandler(
  74         dir.empty() ? base::FilePath(FILE_PATH_LITERAL("dummy")) : dir));
  75
  76     scoped_ptr<WebRtcRtpDumpWriter> writer(new FakeDumpWriter(
  77         10,
  78         base::Bind(&WebRtcRtpDumpHandler::OnMaxDumpSizeReached,
  79                    base::Unretained(handler_.get())),
  80         end_dump_success));
  81
  82     handler_->SetDumpWriterForTesting(writer.Pass());
  83   }
  84
  85   void DeleteDumpHandler() { handler_.reset(); }
  86
  87   void WriteFakeDumpFiles(const base::FilePath& dir,
  88                           base::FilePath* incoming_dump,
  89                           base::FilePath* outgoing_dump) {
  90     *incoming_dump = dir.AppendASCII("recv");
  91     *outgoing_dump = dir.AppendASCII("send");
  92     const char dummy[] = "dummy";
  93     EXPECT_GT(base::WriteFile(*incoming_dump, dummy, arraysize(dummy)), 0);
  94     EXPECT_GT(base::WriteFile(*outgoing_dump, dummy, arraysize(dummy)), 0);
  95   }
  96
  97   MOCK_METHOD2(OnStopDumpFinished,
  98                void(bool success, const std::string& error));
  99
 100   MOCK_METHOD0(OnStopOngoingDumpsFinished, void(void));
 101
 102  protected:
 103   content::TestBrowserThreadBundle thread_bundle_;
 104   scoped_ptr<WebRtcRtpDumpHandler> handler_;
 105 };
 106
 107 TEST_F(WebRtcRtpDumpHandlerTest, StateTransition) {
 108   std::string error;
 109
 110   RtpDumpType types[3];
 111   types[0] = RTP_DUMP_INCOMING;
 112   types[1] = RTP_DUMP_OUTGOING;
 113   types[2] = RTP_DUMP_BOTH;
 114
 115   for (size_t i = 0; i < arraysize(types); ++i) {
 116     DVLOG(2) << "Verifying state transition: type = " << types[i];
 117
 118     // Only StartDump is allowed in STATE_NONE.
 119     EXPECT_CALL(*this, OnStopDumpFinished(false, testing::_));
 120     handler_->StopDump(types[i],
 121                        base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 122                                   base::Unretained(this)));
 123
 124     WebRtcRtpDumpHandler::ReleasedDumps empty_dumps(handler_->ReleaseDumps());
 125     EXPECT_TRUE(empty_dumps.incoming_dump_path.empty());
 126     EXPECT_TRUE(empty_dumps.outgoing_dump_path.empty());
 127     EXPECT_TRUE(handler_->StartDump(types[i], &error));
 128     base::RunLoop().RunUntilIdle();
 129
 130     // Only StopDump is allowed in STATE_STARTED.
 131     EXPECT_FALSE(handler_->StartDump(types[i], &error));
 132     EXPECT_FALSE(handler_->ReadyToRelease());
 133
 134     EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 135     handler_->StopDump(types[i],
 136                        base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 137                                   base::Unretained(this)));
 138     base::RunLoop().RunUntilIdle();
 139
 140     // Only ReleaseDump is allowed in STATE_STOPPED.
 141     EXPECT_FALSE(handler_->StartDump(types[i], &error));
 142
 143     EXPECT_CALL(*this, OnStopDumpFinished(false, testing::_));
 144     handler_->StopDump(types[i],
 145                        base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 146                                   base::Unretained(this)));
 147     EXPECT_TRUE(handler_->ReadyToRelease());
 148
 149     WebRtcRtpDumpHandler::ReleasedDumps dumps(handler_->ReleaseDumps());
 150     if (types[i] == RTP_DUMP_INCOMING || types[i] == RTP_DUMP_BOTH)
 151       EXPECT_FALSE(dumps.incoming_dump_path.empty());
 152
 153     if (types[i] == RTP_DUMP_OUTGOING || types[i] == RTP_DUMP_BOTH)
 154       EXPECT_FALSE(dumps.outgoing_dump_path.empty());
 155
 156     base::RunLoop().RunUntilIdle();
 157     ResetDumpHandler(base::FilePath(), true);
 158   }
 159 }
 160
 161 TEST_F(WebRtcRtpDumpHandlerTest, StoppedWhenMaxSizeReached) {
 162   std::string error;
 163
 164   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_INCOMING, &error));
 165
 166   std::vector<uint8> buffer(100, 0);
 167   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), true);
 168   base::RunLoop().RunUntilIdle();
 169
 170   // Dumping should have been stopped, so ready to release.
 171   WebRtcRtpDumpHandler::ReleasedDumps dumps = handler_->ReleaseDumps();
 172   EXPECT_FALSE(dumps.incoming_dump_path.empty());
 173 }
 174
 175 TEST_F(WebRtcRtpDumpHandlerTest, PacketIgnoredIfDumpingNotStarted) {
 176   std::vector<uint8> buffer(100, 0);
 177   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), true);
 178   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), false);
 179   base::RunLoop().RunUntilIdle();
 180 }
 181
 182 TEST_F(WebRtcRtpDumpHandlerTest, PacketIgnoredIfDumpingStopped) {
 183   std::string error;
 184
 185   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_INCOMING, &error));
 186
 187   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 188   handler_->StopDump(RTP_DUMP_INCOMING,
 189                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 190                                 base::Unretained(this)));
 191
 192   std::vector<uint8> buffer(100, 0);
 193   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), true);
 194   base::RunLoop().RunUntilIdle();
 195 }
 196
 197 TEST_F(WebRtcRtpDumpHandlerTest, CannotStartMoreThanFiveDumps) {
 198   std::string error;
 199
 200   handler_.reset();
 201
 202   scoped_ptr<WebRtcRtpDumpHandler> handlers[6];
 203
 204   for (size_t i = 0; i < arraysize(handlers); ++i) {
 205     handlers[i].reset(new WebRtcRtpDumpHandler(base::FilePath()));
 206
 207     if (i < arraysize(handlers) - 1) {
 208       EXPECT_TRUE(handlers[i]->StartDump(RTP_DUMP_INCOMING, &error));
 209     } else {
 210       EXPECT_FALSE(handlers[i]->StartDump(RTP_DUMP_INCOMING, &error));
 211     }
 212   }
 213 }
 214
 215 TEST_F(WebRtcRtpDumpHandlerTest, StartStopIncomingThenStartStopOutgoing) {
 216   std::string error;
 217
 218   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_)).Times(2);
 219
 220   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_INCOMING, &error));
 221   handler_->StopDump(RTP_DUMP_INCOMING,
 222                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 223                                 base::Unretained(this)));
 224
 225   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_OUTGOING, &error));
 226   handler_->StopDump(RTP_DUMP_OUTGOING,
 227                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 228                                 base::Unretained(this)));
 229
 230   base::RunLoop().RunUntilIdle();
 231 }
 232
 233 TEST_F(WebRtcRtpDumpHandlerTest, StartIncomingStartOutgoingThenStopBoth) {
 234   std::string error;
 235
 236   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 237
 238   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_INCOMING, &error));
 239   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_OUTGOING, &error));
 240
 241   handler_->StopDump(RTP_DUMP_INCOMING,
 242                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 243                                 base::Unretained(this)));
 244
 245   base::RunLoop().RunUntilIdle();
 246 }
 247
 248 TEST_F(WebRtcRtpDumpHandlerTest, StartBothThenStopIncomingStopOutgoing) {
 249   std::string error;
 250
 251   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_)).Times(2);
 252
 253   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 254
 255   handler_->StopDump(RTP_DUMP_INCOMING,
 256                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 257                                 base::Unretained(this)));
 258   handler_->StopDump(RTP_DUMP_OUTGOING,
 259                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 260                                 base::Unretained(this)));
 261
 262   base::RunLoop().RunUntilIdle();
 263 }
 264
 265 TEST_F(WebRtcRtpDumpHandlerTest, DumpsCleanedUpIfNotReleased) {
 266   base::ScopedTempDir temp_dir;
 267   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 268   ResetDumpHandler(temp_dir.path(), true);
 269
 270   base::FilePath incoming_dump, outgoing_dump;
 271   WriteFakeDumpFiles(temp_dir.path(), &incoming_dump, &outgoing_dump);
 272
 273   std::string error;
 274   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 275
 276   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 277   handler_->StopDump(RTP_DUMP_BOTH,
 278                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 279                                 base::Unretained(this)));
 280   base::RunLoop().RunUntilIdle();
 281
 282   handler_.reset();
 283   base::RunLoop().RunUntilIdle();
 284
 285   EXPECT_FALSE(base::PathExists(incoming_dump));
 286   EXPECT_FALSE(base::PathExists(outgoing_dump));
 287 }
 288
 289 TEST_F(WebRtcRtpDumpHandlerTest, DumpDeletedIfEndDumpFailed) {
 290   base::ScopedTempDir temp_dir;
 291   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 292
 293   // Make the writer return failure on EndStream.
 294   ResetDumpHandler(temp_dir.path(), false);
 295
 296   base::FilePath incoming_dump, outgoing_dump;
 297   WriteFakeDumpFiles(temp_dir.path(), &incoming_dump, &outgoing_dump);
 298
 299   std::string error;
 300   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 301   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_)).Times(2);
 302
 303   handler_->StopDump(RTP_DUMP_INCOMING,
 304                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 305                                 base::Unretained(this)));
 306   base::RunLoop().RunUntilIdle();
 307
 308   EXPECT_FALSE(base::PathExists(incoming_dump));
 309   EXPECT_TRUE(base::PathExists(outgoing_dump));
 310
 311   handler_->StopDump(RTP_DUMP_OUTGOING,
 312                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 313                                 base::Unretained(this)));
 314   base::RunLoop().RunUntilIdle();
 315   EXPECT_FALSE(base::PathExists(outgoing_dump));
 316 }
 317
 318 TEST_F(WebRtcRtpDumpHandlerTest, StopOngoingDumpsWhileStoppingDumps) {
 319   std::string error;
 320   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 321
 322   testing::InSequence s;
 323   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 324   EXPECT_CALL(*this, OnStopOngoingDumpsFinished());
 325
 326   handler_->StopDump(RTP_DUMP_BOTH,
 327                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 328                                 base::Unretained(this)));
 329
 330   handler_->StopOngoingDumps(
 331       base::Bind(&WebRtcRtpDumpHandlerTest::OnStopOngoingDumpsFinished,
 332                  base::Unretained(this)));
 333
 334   base::RunLoop().RunUntilIdle();
 335
 336   WebRtcRtpDumpHandler::ReleasedDumps dumps(handler_->ReleaseDumps());
 337   EXPECT_FALSE(dumps.incoming_dump_path.empty());
 338   EXPECT_FALSE(dumps.outgoing_dump_path.empty());
 339 }
 340
 341 TEST_F(WebRtcRtpDumpHandlerTest, StopOngoingDumpsWhileDumping) {
 342   std::string error;
 343   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 344
 345   EXPECT_CALL(*this, OnStopOngoingDumpsFinished());
 346
 347   handler_->StopOngoingDumps(
 348       base::Bind(&WebRtcRtpDumpHandlerTest::OnStopOngoingDumpsFinished,
 349                  base::Unretained(this)));
 350
 351   base::RunLoop().RunUntilIdle();
 352
 353   WebRtcRtpDumpHandler::ReleasedDumps dumps(handler_->ReleaseDumps());
 354   EXPECT_FALSE(dumps.incoming_dump_path.empty());
 355   EXPECT_FALSE(dumps.outgoing_dump_path.empty());
 356 }
 357
 358 TEST_F(WebRtcRtpDumpHandlerTest, StopOngoingDumpsWhenAlreadyStopped) {
 359   std::string error;
 360   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 361
 362   {
 363     EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 364
 365     handler_->StopDump(RTP_DUMP_BOTH,
 366                        base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 367                                   base::Unretained(this)));
 368     base::RunLoop().RunUntilIdle();
 369   }
 370
 371   EXPECT_CALL(*this, OnStopOngoingDumpsFinished());
 372   handler_->StopOngoingDumps(
 373       base::Bind(&WebRtcRtpDumpHandlerTest::OnStopOngoingDumpsFinished,
 374                  base::Unretained(this)));
 375 }
 376
 377 TEST_F(WebRtcRtpDumpHandlerTest, StopOngoingDumpsWhileStoppingOneDump) {
 378   std::string error;
 379   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 380
 381   testing::InSequence s;
 382   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
 383   EXPECT_CALL(*this, OnStopOngoingDumpsFinished());
 384
 385   handler_->StopDump(RTP_DUMP_INCOMING,
 386                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
 387                                 base::Unretained(this)));
 388
 389   handler_->StopOngoingDumps(
 390       base::Bind(&WebRtcRtpDumpHandlerTest::OnStopOngoingDumpsFinished,
 391                  base::Unretained(this)));
 392
 393   base::RunLoop().RunUntilIdle();
 394
 395   WebRtcRtpDumpHandler::ReleasedDumps dumps(handler_->ReleaseDumps());
 396   EXPECT_FALSE(dumps.incoming_dump_path.empty());
 397   EXPECT_FALSE(dumps.outgoing_dump_path.empty());
 398 }
 399
 400 TEST_F(WebRtcRtpDumpHandlerTest, DeleteHandlerBeforeStopCallback) {
 401   std::string error;
 402
 403   EXPECT_CALL(*this, OnStopOngoingDumpsFinished())
 404       .WillOnce(testing::InvokeWithoutArgs(
 405           this, &WebRtcRtpDumpHandlerTest::DeleteDumpHandler));
 406
 407   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 408
 409   handler_->StopOngoingDumps(
 410       base::Bind(&WebRtcRtpDumpHandlerTest::OnStopOngoingDumpsFinished,
 411                  base::Unretained(this)));
 412
 413   base::RunLoop().RunUntilIdle();
 414 }