Home | History | Annotate | Download | only in media 
      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 <string>
      6 
      7 #include "base/files/file.h"
      8 #include "base/files/file_path.h"
      9 #include "base/files/file_util.h"
     10 #include "base/files/scoped_temp_dir.h"
     11 #include "base/logging.h"
     12 #include "base/strings/string_number_conversions.h"
     13 #include "base/strings/string_split.h"
     14 #include "base/time/time.h"
     15 #include "chrome/browser/media/webrtc_log_uploader.h"
     16 #include "testing/gtest/include/gtest/gtest.h"
     17 
     18 const char kTestTime[] = "time";
     19 const char kTestReportId[] = "report-id";
     20 const char kTestLocalId[] = "local-id";
     21 
     22 class WebRtcLogUploaderTest : public testing::Test {
     23  public:
     24   WebRtcLogUploaderTest() {}
     25 
     26   bool VerifyNumberOfLines(int expected_lines) {
     27     std::vector<std::string> lines = GetLinesFromListFile();
     28     EXPECT_EQ(expected_lines, static_cast<int>(lines.size()));
     29     return expected_lines == static_cast<int>(lines.size());
     30   }
     31 
     32   bool VerifyLastLineHasAllInfo() {
     33     std::string last_line = GetLastLineFromListFile();
     34     if (last_line.empty())
     35       return false;
     36     std::vector<std::string> line_parts;
     37     base::SplitString(last_line, ',', &line_parts);
     38     EXPECT_EQ(3u, line_parts.size());
     39     if (3u != line_parts.size())
     40       return false;
     41     // The time (line_parts[0]) is the time when the info was written to the
     42     // file which we don't know, so just verify that it's not empty.
     43     EXPECT_FALSE(line_parts[0].empty());
     44     EXPECT_STREQ(kTestReportId, line_parts[1].c_str());
     45     EXPECT_STREQ(kTestLocalId, line_parts[2].c_str());
     46     return true;
     47   }
     48 
     49   bool VerifyLastLineHasLocalIdOnly() {
     50     std::string last_line = GetLastLineFromListFile();
     51     if (last_line.empty())
     52       return false;
     53     std::vector<std::string> line_parts;
     54     base::SplitString(last_line, ',', &line_parts);
     55     EXPECT_EQ(3u, line_parts.size());
     56     if (3u != line_parts.size())
     57       return false;
     58     EXPECT_TRUE(line_parts[0].empty());
     59     EXPECT_TRUE(line_parts[1].empty());
     60     EXPECT_STREQ(kTestLocalId, line_parts[2].c_str());
     61     return true;
     62   }
     63 
     64   bool VerifyLastLineHasUploadTimeAndIdOnly() {
     65     std::string last_line = GetLastLineFromListFile();
     66     if (last_line.empty())
     67       return false;
     68     std::vector<std::string> line_parts;
     69     base::SplitString(last_line, ',', &line_parts);
     70     EXPECT_EQ(3u, line_parts.size());
     71     if (3u != line_parts.size())
     72       return false;
     73     EXPECT_FALSE(line_parts[0].empty());
     74     EXPECT_STREQ(kTestReportId, line_parts[1].c_str());
     75     EXPECT_TRUE(line_parts[2].empty());
     76     return true;
     77   }
     78 
     79   bool AddLinesToTestFile(int number_of_lines) {
     80     base::File test_list_file(test_list_path_,
     81                               base::File::FLAG_OPEN | base::File::FLAG_APPEND);
     82     EXPECT_TRUE(test_list_file.IsValid());
     83     if (!test_list_file.IsValid())
     84       return false;
     85 
     86     for (int i = 0; i < number_of_lines; ++i) {
     87       EXPECT_EQ(static_cast<int>(sizeof(kTestTime)) - 1,
     88                 test_list_file.WriteAtCurrentPos(kTestTime,
     89                                                  sizeof(kTestTime) - 1));
     90       EXPECT_EQ(1, test_list_file.WriteAtCurrentPos(",", 1));
     91       EXPECT_EQ(static_cast<int>(sizeof(kTestReportId)) - 1,
     92                 test_list_file.WriteAtCurrentPos(kTestReportId,
     93                                                  sizeof(kTestReportId) - 1));
     94       EXPECT_EQ(1, test_list_file.WriteAtCurrentPos(",", 1));
     95       EXPECT_EQ(static_cast<int>(sizeof(kTestLocalId)) - 1,
     96                 test_list_file.WriteAtCurrentPos(kTestLocalId,
     97                                                  sizeof(kTestLocalId) - 1));
     98       EXPECT_EQ(1, test_list_file.WriteAtCurrentPos("\n", 1));
     99     }
    100     return true;
    101   }
    102 
    103   std::vector<std::string> GetLinesFromListFile() {
    104     std::string contents;
    105     int read = base::ReadFileToString(test_list_path_, &contents);
    106     EXPECT_GT(read, 0);
    107     if (read == 0)
    108       return std::vector<std::string>();
    109     // Since every line should end with '\n', the last line should be empty. So
    110     // we expect at least two lines including the final empty. Remove the empty
    111     // line before returning.
    112     std::vector<std::string> lines;
    113     base::SplitString(contents, '\n', &lines);
    114     EXPECT_GT(lines.size(), 1u);
    115     if (lines.size() < 2)
    116       return std::vector<std::string>();
    117     EXPECT_TRUE(lines[lines.size() - 1].empty());
    118     if (!lines[lines.size() - 1].empty())
    119       return std::vector<std::string>();
    120     lines.pop_back();
    121     return lines;
    122   }
    123 
    124   std::string GetLastLineFromListFile() {
    125     std::vector<std::string> lines = GetLinesFromListFile();
    126     EXPECT_GT(lines.size(), 0u);
    127     if (lines.empty())
    128       return std::string();
    129     return lines[lines.size() - 1];
    130   }
    131 
    132   void VerifyRtpDumpInMultipart(const std::string& post_data,
    133                                 const std::string& dump_name,
    134                                 const std::string& dump_content) {
    135     std::vector<std::string> lines;
    136     base::SplitStringUsingSubstr(post_data, "\r\n", &lines);
    137 
    138     std::string name_line = "Content-Disposition: form-data; name=\"";
    139     name_line.append(dump_name);
    140     name_line.append("\"");
    141     name_line.append("; filename=\"");
    142     name_line.append(dump_name);
    143     name_line.append(".gz\"");
    144 
    145     size_t i = 0;
    146     for (; i < lines.size(); ++i) {
    147       if (lines[i] == name_line)
    148         break;
    149     }
    150 
    151     // The RTP dump takes 4 lines: content-disposition, content-type, empty
    152     // line, dump content.
    153     EXPECT_LT(i, lines.size() - 3);
    154 
    155     EXPECT_EQ("Content-Type: application/gzip", lines[i + 1]);
    156     EXPECT_EQ("", lines[i + 2]);
    157     EXPECT_EQ(dump_content, lines[i + 3]);
    158   }
    159 
    160   base::FilePath test_list_path_;
    161 };
    162 
    163 TEST_F(WebRtcLogUploaderTest, AddLocallyStoredLogInfoToUploadListFile) {
    164   // Get a temporary filename. We don't want the file to exist to begin with
    165   // since that's the normal use case, hence the delete.
    166   ASSERT_TRUE(base::CreateTemporaryFile(&test_list_path_));
    167   EXPECT_TRUE(base::DeleteFile(test_list_path_, false));
    168   scoped_ptr<WebRtcLogUploader> webrtc_log_uploader(new WebRtcLogUploader());
    169 
    170   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
    171                                                                kTestLocalId);
    172   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
    173                                                                kTestLocalId);
    174   ASSERT_TRUE(VerifyNumberOfLines(2));
    175   ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
    176 
    177   const int expected_line_limit = 50;
    178   ASSERT_TRUE(AddLinesToTestFile(expected_line_limit - 2));
    179   ASSERT_TRUE(VerifyNumberOfLines(expected_line_limit));
    180   ASSERT_TRUE(VerifyLastLineHasAllInfo());
    181 
    182   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
    183                                                                kTestLocalId);
    184   ASSERT_TRUE(VerifyNumberOfLines(expected_line_limit));
    185   ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
    186 
    187   ASSERT_TRUE(AddLinesToTestFile(10));
    188   ASSERT_TRUE(VerifyNumberOfLines(60));
    189   ASSERT_TRUE(VerifyLastLineHasAllInfo());
    190 
    191   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
    192                                                                kTestLocalId);
    193   ASSERT_TRUE(VerifyNumberOfLines(expected_line_limit));
    194   ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
    195 
    196   webrtc_log_uploader->StartShutdown();
    197 }
    198 
    199 TEST_F(WebRtcLogUploaderTest, AddUploadedLogInfoToUploadListFile) {
    200   // Get a temporary filename. We don't want the file to exist to begin with
    201   // since that's the normal use case, hence the delete.
    202   ASSERT_TRUE(base::CreateTemporaryFile(&test_list_path_));
    203   EXPECT_TRUE(base::DeleteFile(test_list_path_, false));
    204   scoped_ptr<WebRtcLogUploader> webrtc_log_uploader(new WebRtcLogUploader());
    205 
    206   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
    207                                                                kTestLocalId);
    208   ASSERT_TRUE(VerifyNumberOfLines(1));
    209   ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
    210 
    211   webrtc_log_uploader->AddUploadedLogInfoToUploadListFile(
    212       test_list_path_, kTestLocalId, kTestReportId);
    213   ASSERT_TRUE(VerifyNumberOfLines(1));
    214   ASSERT_TRUE(VerifyLastLineHasAllInfo());
    215 
    216   // Use a local ID that should not be found in the list.
    217   webrtc_log_uploader->AddUploadedLogInfoToUploadListFile(
    218       test_list_path_, "dummy id", kTestReportId);
    219   ASSERT_TRUE(VerifyNumberOfLines(2));
    220   ASSERT_TRUE(VerifyLastLineHasUploadTimeAndIdOnly());
    221 
    222   webrtc_log_uploader->StartShutdown();
    223 }
    224 
    225 TEST_F(WebRtcLogUploaderTest, AddRtpDumpsToPostedData) {
    226   base::ScopedTempDir temp_dir;
    227   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    228 
    229   scoped_ptr<WebRtcLogUploader> webrtc_log_uploader(new WebRtcLogUploader());
    230 
    231   std::string post_data;
    232   webrtc_log_uploader->OverrideUploadWithBufferForTesting(&post_data);
    233 
    234   // Create the fake dump files.
    235   const base::FilePath incoming_dump = temp_dir.path().AppendASCII("recv");
    236   const base::FilePath outgoing_dump = temp_dir.path().AppendASCII("send");
    237   const std::string incoming_dump_content = "dummy incoming";
    238   const std::string outgoing_dump_content = "dummy outgoing";
    239 
    240   base::WriteFile(incoming_dump,
    241                   &incoming_dump_content[0],
    242                   incoming_dump_content.size());
    243   base::WriteFile(outgoing_dump,
    244                   &outgoing_dump_content[0],
    245                   outgoing_dump_content.size());
    246 
    247   WebRtcLogUploadDoneData upload_done_data;
    248   upload_done_data.log_path = temp_dir.path().AppendASCII("log");
    249 
    250   upload_done_data.incoming_rtp_dump = incoming_dump;
    251   upload_done_data.outgoing_rtp_dump = outgoing_dump;
    252 
    253   const size_t log_length = 100;
    254   scoped_ptr<unsigned char[]> log(new unsigned char[log_length]);
    255   memset(log.get(), 0, log_length);
    256 
    257   webrtc_log_uploader->LoggingStoppedDoUpload(
    258       log.Pass(),
    259       log_length,
    260       std::map<std::string, std::string>(),
    261       upload_done_data);
    262 
    263   VerifyRtpDumpInMultipart(post_data, "rtpdump_recv", incoming_dump_content);
    264   VerifyRtpDumpInMultipart(post_data, "rtpdump_send", outgoing_dump_content);
    265 
    266   webrtc_log_uploader->StartShutdown();
    267 }
    268