Fix WebRTC log list errors.

chrome/browser/media/webrtc_log_uploader_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 <string>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 19 matching lines @@
     EXPECT_EQ(expected_lines, static_cast<int>(lines.size()));
     return expected_lines == static_cast<int>(lines.size());
   }
 
   bool VerifyLastLineHasAllInfo() {
     std::string last_line = GetLastLineFromListFile();
     if (last_line.empty())
       return false;
     std::vector<std::string> line_parts = base::SplitString(
         last_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-    EXPECT_EQ(3u, line_parts.size());
-    if (3u != line_parts.size())
+    EXPECT_EQ(4u, line_parts.size());
+    if (4u != line_parts.size())
       return false;
-    // The time (line_parts[0]) is the time when the info was written to the
+    // The times (indices 0 and 3) is the time when the info was written to the
     // file which we don't know, so just verify that it's not empty.
     EXPECT_FALSE(line_parts[0].empty());
     EXPECT_STREQ(kTestReportId, line_parts[1].c_str());
     EXPECT_STREQ(kTestLocalId, line_parts[2].c_str());
+    EXPECT_FALSE(line_parts[3].empty());
     return true;
   }
 
-  bool VerifyLastLineHasLocalIdOnly() {
+  // Verify that the last line contains the correct info for a local storage.
+  bool VerifyLastLineHasLocalStorageInfoOnly() {
     std::string last_line = GetLastLineFromListFile();
     if (last_line.empty())
       return false;
     std::vector<std::string> line_parts = base::SplitString(
         last_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-    EXPECT_EQ(3u, line_parts.size());
-    if (3u != line_parts.size())
+    EXPECT_EQ(4u, line_parts.size());
+    if (4u != line_parts.size())
       return false;
     EXPECT_TRUE(line_parts[0].empty());
     EXPECT_TRUE(line_parts[1].empty());
     EXPECT_STREQ(kTestLocalId, line_parts[2].c_str());
+    EXPECT_FALSE(line_parts[3].empty());
     return true;
   }
 
-  bool VerifyLastLineHasUploadTimeAndIdOnly() {
+  // Verify that the last line contains the correct info for an upload.
+  bool VerifyLastLineHasUploadInfoOnly() {
     std::string last_line = GetLastLineFromListFile();
     if (last_line.empty())
       return false;
     std::vector<std::string> line_parts = base::SplitString(
         last_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-    EXPECT_EQ(3u, line_parts.size());
-    if (3u != line_parts.size())
+    EXPECT_EQ(4u, line_parts.size());
+    if (4u != line_parts.size())
       return false;
     EXPECT_FALSE(line_parts[0].empty());
     EXPECT_STREQ(kTestReportId, line_parts[1].c_str());
     EXPECT_TRUE(line_parts[2].empty());
+    EXPECT_FALSE(line_parts[3].empty());
     return true;
   }
 
   bool AddLinesToTestFile(int number_of_lines) {
     base::File test_list_file(test_list_path_,
                               base::File::FLAG_OPEN | base::File::FLAG_APPEND);
     EXPECT_TRUE(test_list_file.IsValid());
     if (!test_list_file.IsValid())
       return false;
 
     for (int i = 0; i < number_of_lines; ++i) {
       EXPECT_EQ(static_cast<int>(sizeof(kTestTime)) - 1,
                 test_list_file.WriteAtCurrentPos(kTestTime,
                                                  sizeof(kTestTime) - 1));
       EXPECT_EQ(1, test_list_file.WriteAtCurrentPos(",", 1));
       EXPECT_EQ(static_cast<int>(sizeof(kTestReportId)) - 1,
                 test_list_file.WriteAtCurrentPos(kTestReportId,
                                                  sizeof(kTestReportId) - 1));
       EXPECT_EQ(1, test_list_file.WriteAtCurrentPos(",", 1));
       EXPECT_EQ(static_cast<int>(sizeof(kTestLocalId)) - 1,
                 test_list_file.WriteAtCurrentPos(kTestLocalId,
                                                  sizeof(kTestLocalId) - 1));
+      EXPECT_EQ(1, test_list_file.WriteAtCurrentPos(",", 1));
+      EXPECT_EQ(static_cast<int>(sizeof(kTestTime)) - 1,
+                test_list_file.WriteAtCurrentPos(kTestTime,
+                                                 sizeof(kTestTime) - 1));
       EXPECT_EQ(1, test_list_file.WriteAtCurrentPos("\n", 1));
     }
     return true;
   }
 
   std::vector<std::string> GetLinesFromListFile() {
     std::string contents;
     int read = base::ReadFileToString(test_list_path_, &contents);
     EXPECT_GT(read, 0);
     if (read == 0)
@@ skipping 58 matching lines @@
   // since that's the normal use case, hence the delete.
   ASSERT_TRUE(base::CreateTemporaryFile(&test_list_path_));
   EXPECT_TRUE(base::DeleteFile(test_list_path_, false));
   scoped_ptr<WebRtcLogUploader> webrtc_log_uploader(new WebRtcLogUploader());
 
   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
                                                                kTestLocalId);
   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
                                                                kTestLocalId);
   ASSERT_TRUE(VerifyNumberOfLines(2));
-  ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
+  ASSERT_TRUE(VerifyLastLineHasLocalStorageInfoOnly());
 
   const int expected_line_limit = 50;
   ASSERT_TRUE(AddLinesToTestFile(expected_line_limit - 2));
   ASSERT_TRUE(VerifyNumberOfLines(expected_line_limit));
   ASSERT_TRUE(VerifyLastLineHasAllInfo());
 
   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
                                                                kTestLocalId);
   ASSERT_TRUE(VerifyNumberOfLines(expected_line_limit));
-  ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
+  ASSERT_TRUE(VerifyLastLineHasLocalStorageInfoOnly());
 
   ASSERT_TRUE(AddLinesToTestFile(10));
   ASSERT_TRUE(VerifyNumberOfLines(60));
   ASSERT_TRUE(VerifyLastLineHasAllInfo());
 
   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
                                                                kTestLocalId);
   ASSERT_TRUE(VerifyNumberOfLines(expected_line_limit));
-  ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
+  ASSERT_TRUE(VerifyLastLineHasLocalStorageInfoOnly());
 
   webrtc_log_uploader->StartShutdown();
 }
 
 TEST_F(WebRtcLogUploaderTest, AddUploadedLogInfoToUploadListFile) {
   // Get a temporary filename. We don't want the file to exist to begin with
   // since that's the normal use case, hence the delete.
   ASSERT_TRUE(base::CreateTemporaryFile(&test_list_path_));
   EXPECT_TRUE(base::DeleteFile(test_list_path_, false));
   scoped_ptr<WebRtcLogUploader> webrtc_log_uploader(new WebRtcLogUploader());
 
   webrtc_log_uploader->AddLocallyStoredLogInfoToUploadListFile(test_list_path_,
                                                                kTestLocalId);
   ASSERT_TRUE(VerifyNumberOfLines(1));
-  ASSERT_TRUE(VerifyLastLineHasLocalIdOnly());
+  ASSERT_TRUE(VerifyLastLineHasLocalStorageInfoOnly());
 
   webrtc_log_uploader->AddUploadedLogInfoToUploadListFile(
       test_list_path_, kTestLocalId, kTestReportId);
   ASSERT_TRUE(VerifyNumberOfLines(1));
   ASSERT_TRUE(VerifyLastLineHasAllInfo());
 
   // Use a local ID that should not be found in the list.
   webrtc_log_uploader->AddUploadedLogInfoToUploadListFile(
       test_list_path_, "dummy id", kTestReportId);
   ASSERT_TRUE(VerifyNumberOfLines(2));
-  ASSERT_TRUE(VerifyLastLineHasUploadTimeAndIdOnly());
+  ASSERT_TRUE(VerifyLastLineHasUploadInfoOnly());
 
   webrtc_log_uploader->StartShutdown();
 }
 
 TEST_F(WebRtcLogUploaderTest, AddRtpDumpsToPostedData) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   scoped_ptr<WebRtcLogUploader> webrtc_log_uploader(new WebRtcLogUploader());
 
@@ skipping 27 matching lines @@
   scoped_ptr<WebRtcLogBuffer> log(new WebRtcLogBuffer());
   log->SetComplete();
   webrtc_log_uploader->LoggingStoppedDoUpload(
       log.Pass(), make_scoped_ptr(new MetaDataMap()), upload_done_data);
 
   VerifyRtpDumpInMultipart(post_data, "rtpdump_recv", incoming_dump_content);
   VerifyRtpDumpInMultipart(post_data, "rtpdump_send", outgoing_dump_content);
 
   webrtc_log_uploader->StartShutdown();
 }