Write a log list for uploaded WebRTC logs.

chrome/browser/media/webrtc_log_uploader.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 "chrome/browser/media/webrtc_log_uploader.h"
 
+#include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/path_service.h"
 #include "base/shared_memory.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
+#include "base/time.h"
+#include "chrome/browser/media/webrtc_log_upload_list.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/partial_circular_buffer.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/mime_util.h"
 #include "net/base/network_delegate.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/zlib/zlib.h"
 
 namespace {
 
 const int kLogCountLimit = 5;
 const uint32 kIntermediateCompressionBufferBytes = 256 * 1024;  // 256 KB
+const int kLogListLimitLines = 50;
 
 const char kUploadURL[] = "https://clients2.google.com/cr/report";
 const char kUploadContentType[] = "multipart/form-data";
 const char kMultipartBoundary[] =
     "----**--yradnuoBgoLtrapitluMklaTelgooG--**----";
 
 }  // namespace
 
 WebRtcLogUploader::WebRtcLogUploader()
     : log_count_(0) {
 }
 
 WebRtcLogUploader::~WebRtcLogUploader() {
 }
 
 void WebRtcLogUploader::OnURLFetchComplete(
     const net::URLFetcher* source) {
+  // Append this uploaded log to a log list file, limited to
+  // |kLogListLimitLines| entries. This list is used for viewing the uploaded
+  // logs under chrome://webrtc-logs, see WebRtcLogUploadList.
+
+  int response_code = source->GetResponseCode();
+  std::string response_string;
+  if (response_code != 200 ||
+      !source->GetResponseAsString(&response_string)) {
+    return;
+  }
+
+  base::FilePath log_dir_path;
+  PathService::Get(chrome::DIR_USER_DATA, &log_dir_path);
+  base::FilePath upload_log_path =
+      log_dir_path.AppendASCII(WebRtcLogUploadList::kWebRtcLogListFilename);
+
+  int flags = base::PLATFORM_FILE_OPEN_ALWAYS |
+              base::PLATFORM_FILE_READ |
+              base::PLATFORM_FILE_WRITE;
+  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::PlatformFile logs_uploaded_file =
+      base::CreatePlatformFile(upload_log_path, flags, NULL, &error);
+  if (error != base::PLATFORM_FILE_OK) {
+    LOG(WARNING) << "Could not open WebRTC log list file.";
+    return;
+  }
+
+  // Read the log list file. Each line is ~35 chars (bytes). Use a buffer size
+  // of 3 times the estimated max size to have a margin.
+  std::string contents(3 * kLogListLimitLines * 35, '\0');
+  size_t read = base::ReadPlatformFileAtCurrentPos(logs_uploaded_file,
+                                                   &contents[0],
+                                                   contents.size());
+  DCHECK_LT(read, contents.size());
+  contents.resize(read);
+
+  // Limit the number of log entries to |kLogListLimitLines|.
+  std::vector<std::string> log_entries;
+  base::SplitStringAlongWhitespace(contents, &log_entries);
+  if (log_entries.size() >= kLogListLimitLines) {
+    std::string& new_first_entry =
+        log_entries[log_entries.size() - kLogListLimitLines + 1];
+    size_t new_first_entry_pos = contents.find(new_first_entry);

[tommi (sloooow) - chröme, 2013/06/27 08:45:40]

Is this guaranteed to be correct?

What if kLogListLimitLines is 3 and contents is:
"abc def foo abc bar"?

Actually, skimming over this again I see that the only purpose of the
log_entries vector is to count the number of words in |contents| and then
potentially trim |contents| based on that number.  (please correct me if that's
not the case)

What about this approach instead:
Go backwards through |contents|, counting the spaces along the way.  Once we
reach either the beginning of the string or the maximum number of words, we
stop.  If we're not at the beginning of the string, we delete the front of the
string up until the current pos.

This way, we don't have to allocate the array and each word potentially multiple
times.

[Henrik Grunell, 2013/06/27 11:56:22]

The lines will not contain other whitespaces than '\n'. It doesn't matter though
due to next paragraph.

I also considered searching backwards but for some reason I thought this was
better. (Probably I though the code was easier to read before the last change I
made.) Now however I also think searching backwards is better for all reasons.
Changed.

+    contents.erase(0, new_first_entry_pos);
+  }
+
+  // Write the Unix time and report ID to the log list file. The response in
+  // |response_string| contains the report ID.
+  base::Time time_now = base::Time::Now();
+  contents += base::DoubleToString(time_now.ToDoubleT()) +
+              "," + response_string + '\n';
+
+  base::SeekPlatformFile(logs_uploaded_file, base::PLATFORM_FILE_FROM_BEGIN, 0);
+  size_t written = base::WritePlatformFileAtCurrentPos(logs_uploaded_file,
+                                                       contents.c_str(),
+                                                       contents.size());
+  DCHECK_EQ(written, contents.size());
+  bool ret = base::TruncatePlatformFile(logs_uploaded_file, written);
+  DCHECK(ret);

[tommi (sloooow) - chröme, 2013/06/27 08:45:40]

FYI - there is also DPCHECK which will print out any error values related to
system calls (GetLastError() on Windows, errno on linux)

[Henrik Grunell, 2013/06/27 11:56:22]

OK, good to know. Changed.

+
+  ret = base::ClosePlatformFile(logs_uploaded_file);
+  DCHECK(ret);

[tommi (sloooow) - chröme, 2013/06/27 08:45:40]

you could use that here too

[Henrik Grunell, 2013/06/27 11:56:22]

Done.

 }
 
 void WebRtcLogUploader::OnURLFetchUploadProgress(
     const net::URLFetcher* source, int64 current, int64 total) {
 }
 
 bool WebRtcLogUploader::ApplyForStartLogging() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (log_count_ < kLogCountLimit) {
     ++log_count_;
@@ skipping 135 matching lines @@
   size_t old_size = post_data->size() - stream->avail_out;
   post_data->resize(old_size + kIntermediateCompressionBufferBytes);
   stream->next_out = reinterpret_cast<uint8*>(&(*post_data)[old_size]);
   stream->avail_out = kIntermediateCompressionBufferBytes;
 }
 
 void WebRtcLogUploader::DecreaseLogCount() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   --log_count_;
 }