Implementing uploading of a WebRTC diagnostic log.

content/browser/renderer_host/webrtc_logging_handler_host.cc

 // Copyright (c) 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 "content/browser/renderer_host/webrtc_logging_handler_host.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/shared_memory.h"
+#include "content/browser/webrtc_log_manager.h"
 #include "content/common/webrtc_logging_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 
 namespace content {
 
 const size_t kWebRtcLogSize = 6 * 1024 * 1024;  // 6 MB
 
-WebRtcLoggingHandlerHost::WebRtcLoggingHandlerHost() {
+WebRtcLoggingHandlerHost::WebRtcLoggingHandlerHost()
+    : shared_memory_(NULL),
+      log_file_compressed_(base::kInvalidPlatformFileValue) {
 }
 
 WebRtcLoggingHandlerHost::~WebRtcLoggingHandlerHost() {
+  // |shared_memory_| should have been handed to upload manager (and NULL here).
+  // Delete it in case it wasn't.
+  delete shared_memory_;
 }
 
 void WebRtcLoggingHandlerHost::OnChannelClosing() {
+  UploadLog();
   BrowserMessageFilter::OnChannelClosing();
 }
 
 void WebRtcLoggingHandlerHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 bool WebRtcLoggingHandlerHost::OnMessageReceived(const IPC::Message& message,
                                                  bool* message_was_ok) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(WebRtcLoggingHandlerHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(WebRtcLoggingMsg_OpenLog, OnOpenLog)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   return handled;
 }
 
 void WebRtcLoggingHandlerHost::OnOpenLog() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!base::SharedMemory::IsHandleValid(shared_memory_.handle()));
+  DCHECK(!shared_memory_);
+  DCHECK(log_file_compressed_ == base::kInvalidPlatformFileValue);
 
-  if (!shared_memory_.CreateAndMapAnonymous(kWebRtcLogSize)) {
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::CreateWebRtcLogFile, this));
+}
+
+void WebRtcLoggingHandlerHost::CreateWebRtcLogFile() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  // TODO(grunell): Maybe go through the log manager and have that keep track
+  // of maximum number of logs?
+  log_file_compressed_ = GetContentClient()->browser()->CreateWebRtcLogFile();
+  if (log_file_compressed_ == base::kInvalidPlatformFileValue)
+    return;
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::FinishOpenLog, this));
+}
+
+void WebRtcLoggingHandlerHost::FinishOpenLog() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  shared_memory_ = new base::SharedMemory();
+
+  if (!shared_memory_->CreateAndMapAnonymous(kWebRtcLogSize)) {
     DLOG(ERROR) << "Failed to create shared memory.";
     Send(new WebRtcLoggingMsg_OpenLogFailed());
     return;
   }
 
   base::SharedMemoryHandle foreign_memory_handle;
-  if (!shared_memory_.ShareToProcess(peer_handle(),
+  if (!shared_memory_->ShareToProcess(peer_handle(),
                                      &foreign_memory_handle)) {
     Send(new WebRtcLoggingMsg_OpenLogFailed());
     return;
   }
 
   Send(new WebRtcLoggingMsg_LogOpened(foreign_memory_handle, kWebRtcLogSize));
 }
 
+bool WebRtcLoggingHandlerHost::IsUploadingEnabled() {
+  // TODO(grunell): Move to chrome.

[Jói, 2013/05/02 16:47:31]

Do you really want to move this fully to the embedder? That would mean that in
some cases, //content is creating a compressed log file which then doesn't get
uploaded, which is unnecessary work.

[Henrik Grunell, 2013/05/03 07:59:36]

I've done some more changes/refactoring and cleaning in patch 4, including
moving this. It uses base/prefs/pref_service.h, chrome/common/pref_names.h and
chrome/common/chrome_switches.h that cannot be accessed from content, hence the
move. The idea is that the host will ask the embedder (upload manager for chrome
case) for a file to put the (compressed as of now) log, if it gets one logging
will be enabled. Otherwise not.

Side note: However due to threading requirements I actually let the host first
ask if it's allowed to log, then if yes ask for a file. Doing the check in the
upload manager when asking for a file would require a callback through
content/public since we have to switch between threads (check prefs on UI,
create file on FILE). My idea was to avoid that; let me know if that's
preferable over the current solution.

+  /*
+  // If the user permits metrics reporting / crash uploading with the checkbox
+  // in the prefs, we allow uploading automatically. We disable uploading
+  // completely for non-official builds. This can be forced with a flag.
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kEnableMetricsReportingForTesting))
+    return true;
+
+  bool enabled = false;
+
+#if defined(GOOGLE_CHROME_BUILD)
+#if defined(OS_CHROMEOS)
+  chromeos::CrosSettings::Get()->GetBoolean(chromeos::kStatsReportingPref,
+                                            &enabled);
+#else
+  // TODO(grunell): Fails, has to be on UI thread.
+  enabled = g_browser_process->local_state()->GetBoolean(
+      prefs::kMetricsReportingEnabled);
+#endif  // #if defined(OS_CHROMEOS)
+#endif  // defined(GOOGLE_CHROME_BUILD)
+
+  return enabled;
+  */
+  return true;
+}
+
+void WebRtcLoggingHandlerHost::UploadLog() {
+  // Check if logging has been enabled.
+  if (!shared_memory_)
+    return;
+
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
+      &WebRtcLogManager::UploadLog,
+      base::Unretained(WebRtcLogManager::GetInstance()),
+      shared_memory_,
+      kWebRtcLogSize,
+      log_file_compressed_));
+
+  shared_memory_ = NULL;
+}
+
 }  // namespace content