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