Revert 273745 "Implements RTP header dumping." due to memory leak

trunk/src/chrome/browser/media/webrtc_logging_handler_host.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_logging_handler_host.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/media/webrtc_log_list.h"
 #include "chrome/browser/media/webrtc_log_uploader.h"
-#include "chrome/browser/media/webrtc_rtp_dump_handler.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/media/webrtc_logging_messages.h"
 #include "chrome/common/partial_circular_buffer.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_process_host.h"
 #include "gpu/config/gpu_info.h"
 #include "net/base/address_family.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/system/statistics_provider.h"
 #endif
 
 using base::IntToString;
 using content::BrowserThread;
 
-namespace {
 
 #if defined(OS_ANDROID)
 const size_t kWebRtcLogSize = 1 * 1024 * 1024;  // 1 MB
 #else
 const size_t kWebRtcLogSize = 6 * 1024 * 1024;  // 6 MB
 #endif
 
+namespace {
+
 const char kLogNotStoppedOrNoLogOpen[] =
     "Logging not stopped or no log open.";
 
 // For privacy reasons when logging IP addresses. The returned "sensitive
 // string" is for release builds a string with the end stripped away. Last
 // octet for IPv4 and last 80 bits (5 groups) for IPv6. String will be
 // "1.2.3.x" and "1.2.3::" respectively. For debug builds, the string is
 // not stripped.
 std::string IPAddressToSensitiveString(const net::IPAddressNumber& address) {
 #if defined(NDEBUG)
@@ skipping 106 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   if (logging_state_ != STOPPED) {
     if (!callback.is_null()) {
       content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
           base::Bind(callback, false, "", kLogNotStoppedOrNoLogOpen));
     }
     return;
   }
-
   upload_callback_ = callback;
   logging_state_ = UPLOADING;
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                  this),
-      base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
+      base::Bind(&WebRtcLoggingHandlerHost::TriggerUploadLog, this));
 }
 
 void WebRtcLoggingHandlerHost::UploadLogDone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   logging_state_ = CLOSED;
 }
 
 void WebRtcLoggingHandlerHost::DiscardLog(const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   GenericDoneCallback discard_callback = callback;
   if (logging_state_ != STOPPED) {
     FireGenericDoneCallback(&discard_callback, false,
                             kLogNotStoppedOrNoLogOpen);
     return;
   }
   g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
   circular_buffer_.reset();
   log_buffer_.reset();
   logging_state_ = CLOSED;
-  rtp_dump_handler_.reset();
-  stop_rtp_dump_callback_.Reset();
   FireGenericDoneCallback(&discard_callback, true, "");
 }
 
 void WebRtcLoggingHandlerHost::LogMessage(const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &WebRtcLoggingHandlerHost::AddLogMessageFromBrowser,
           this,
           WebRtcLoggingMessageData(base::Time::Now(), message)));
 }
 
 void WebRtcLoggingHandlerHost::StartRtpDump(
-    RtpDumpType type,
-    const GenericDoneCallback& callback,
-    const content::RenderProcessHost::WebRtcStopRtpDumpCallback&
-        stop_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(stop_rtp_dump_callback_.is_null() ||
-         stop_rtp_dump_callback_.Equals(stop_callback));
-
-  stop_rtp_dump_callback_ = stop_callback;
-
-  if (!rtp_dump_handler_) {
-    content::BrowserThread::PostTaskAndReplyWithResult(
-        content::BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
-                   this),
-        base::Bind(&WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart,
-                   this,
-                   type,
-                   callback));
-    return;
-  }
-
-  GenericDoneCallback start_callback = callback;
-  DoStartRtpDump(type, &start_callback);
+    bool incoming,
+    bool outgoing,
+    const GenericDoneCallback& callback) {
+  NOTIMPLEMENTED();
 }
 
 void WebRtcLoggingHandlerHost::StopRtpDump(
-    RtpDumpType type,
+    bool incoming,
+    bool outgoing,
     const GenericDoneCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!callback.is_null());
-
-  if (!rtp_dump_handler_) {
-    GenericDoneCallback stop_callback = callback;
-    FireGenericDoneCallback(
-        &stop_callback, false, "RTP dump has not been started.");
-    return;
-  }
-
-  if (!stop_rtp_dump_callback_.is_null()) {
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(stop_rtp_dump_callback_,
-                   type == RTP_DUMP_INCOMING || type == RTP_DUMP_BOTH,
-                   type == RTP_DUMP_OUTGOING || type == RTP_DUMP_BOTH));
-  }
-
-  rtp_dump_handler_->StopDump(type, callback);
-}
-
-void WebRtcLoggingHandlerHost::OnRtpPacket(const uint8* packet_header,
-                                           size_t header_length,
-                                           size_t packet_length,
-                                           bool incoming) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  scoped_ptr<uint8[]> header_data(new uint8[header_length]);
-  memcpy(header_data.get(), packet_header, header_length);
-
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&WebRtcLoggingHandlerHost::DumpRtpPacketOnIOThread,
-                 this,
-                 base::Passed(&header_data),
-                 header_length,
-                 packet_length,
-                 incoming));
-}
-
-void WebRtcLoggingHandlerHost::DumpRtpPacketOnIOThread(
-    scoped_ptr<uint8[]> packet_header,
-    size_t header_length,
-    size_t packet_length,
-    bool incoming) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // |rtp_dump_handler_| could be NULL if we are waiting for the FILE thread to
-  // create/ensure the log directory.
-  if (rtp_dump_handler_) {
-    rtp_dump_handler_->OnRtpPacket(
-        packet_header.get(), header_length, packet_length, incoming);
-  }
+  NOTIMPLEMENTED();
 }
 
 void WebRtcLoggingHandlerHost::OnChannelClosing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (logging_state_ == STARTED || logging_state_ == STOPPED) {
     if (upload_log_on_render_close_) {
       logging_state_ = UPLOADING;
       logging_started_time_ = base::Time();
-
       content::BrowserThread::PostTaskAndReplyWithResult(
           content::BrowserThread::FILE,
           FROM_HERE,
           base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                      this),
-          base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
+          base::Bind(&WebRtcLoggingHandlerHost::TriggerUploadLog, this));
     } else {
       g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
     }
   }
   content::BrowserMessageFilter::OnChannelClosing();
 }
 
 void WebRtcLoggingHandlerHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
@@ skipping 180 matching lines @@
   base::FilePath log_dir_path =
       WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile_->GetPath());
   base::File::Error error;
   if (!base::CreateDirectoryAndGetError(log_dir_path, &error)) {
     DLOG(ERROR) << "Could not create WebRTC log directory, error: " << error;
     return base::FilePath();
   }
   return log_dir_path;
 }
 
-void WebRtcLoggingHandlerHost::TriggerUpload(
+void WebRtcLoggingHandlerHost::TriggerUploadLog(
     const base::FilePath& log_directory) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(logging_state_, UPLOADING);
 
-  if (rtp_dump_handler_) {
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(stop_rtp_dump_callback_, true, true));
-
-    rtp_dump_handler_->StopOngoingDumps(
-        base::Bind(&WebRtcLoggingHandlerHost::DoUploadLogAndRtpDumps,
-                   this,
-                   log_directory));
-    return;
-  }
-
-  DoUploadLogAndRtpDumps(log_directory);
-}
-
-void WebRtcLoggingHandlerHost::DoUploadLogAndRtpDumps(
-    const base::FilePath& log_directory) {
   WebRtcLogUploadDoneData upload_done_data;
   upload_done_data.log_path = log_directory;
-
-  if (rtp_dump_handler_) {
-    WebRtcRtpDumpHandler::ReleasedDumps rtp_dumps(
-        rtp_dump_handler_->ReleaseDumps());
-    upload_done_data.incoming_rtp_dump = rtp_dumps.incoming_dump_path;
-    upload_done_data.outgoing_rtp_dump = rtp_dumps.outgoing_dump_path;
-
-    rtp_dump_handler_.reset();
-    stop_rtp_dump_callback_.Reset();
-  }
-
   upload_done_data.callback = upload_callback_;
   upload_done_data.host = this;
   upload_callback_.Reset();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
       &WebRtcLogUploader::LoggingStoppedDoUpload,
       base::Unretained(g_browser_process->webrtc_log_uploader()),
       Passed(&log_buffer_),
       kWebRtcLogSize,
       meta_data_,
       upload_done_data));
 
   meta_data_.clear();
   circular_buffer_.reset();
 }
 
 void WebRtcLoggingHandlerHost::FireGenericDoneCallback(
-    GenericDoneCallback* callback,
-    bool success,
+    GenericDoneCallback* callback, bool success,
     const std::string& error_message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!(*callback).is_null());
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(*callback, success, error_message));
+  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                   base::Bind(*callback, success,
+                                              error_message));
   (*callback).Reset();
 }
-
-void WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart(
-    RtpDumpType type,
-    GenericDoneCallback callback,
-    const base::FilePath& dump_dir) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // |rtp_dump_handler_| may be non-NULL if StartRtpDump is called again before
-  // GetLogDirectoryAndEnsureExists returns on the FILE thread for a previous
-  // StartRtpDump.
-  if (!rtp_dump_handler_)
-    rtp_dump_handler_.reset(new WebRtcRtpDumpHandler(dump_dir));
-
-  DoStartRtpDump(type, &callback);
-}
-
-void WebRtcLoggingHandlerHost::DoStartRtpDump(RtpDumpType type,
-                                              GenericDoneCallback* callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(rtp_dump_handler_);
-
-  std::string error;
-
-  bool result = rtp_dump_handler_->StartDump(type, &error);
-  FireGenericDoneCallback(callback, result, error);
-}