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/command_line.h"
+//#include "base/prefs/pref_service.h"
 #include "base/logging.h"
+//#include "chrome/browser/browser_process.h"
+//#include "chrome/browser/webrtc_log_upload_manager.h"
+//#include "chrome/common/chrome_switches.h"
+//#include "chrome/common/pref_names.h"
 #include "content/common/webrtc_logging_messages.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) {
 }
 
 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_);
 
-  if (!shared_memory_.CreateAndMapAnonymous(kWebRtcLogSize)) {
+  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.
+  /*
+  // 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;
+
+  GetContentClient()->browser()->UploadWebRtcLog(shared_memory_,
+                                                 kWebRtcLogSize);
+  shared_memory_ = NULL;
+}
+
 }  // namespace content