Adding support for storing webrtc logs locally with an extension supplied unique id, for later uplo…

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/files/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/chrome_version_info.h"
 #include "chrome/common/media/webrtc_logging_messages.h"
-#include "chrome/common/partial_circular_buffer.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
-
 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 31 matching lines @@
     const MetaDataMap& meta_data,
     std::string* message) {
   for (MetaDataMap::const_iterator it = meta_data.begin();
        it != meta_data.end(); ++it) {
     *message += it->first + ": " + it->second + '\n';
   }
   // Remove last '\n'.
   message->resize(message->size() - 1);
 }
 
+void FireGenericDoneCallback(
+    const WebRtcLoggingHandlerHost::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));
+}
+
+void FireAndResetGenericDoneCallback(
+    WebRtcLoggingHandlerHost::GenericDoneCallback* callback,
+    bool success,
+    const std::string& error_message) {
+  FireGenericDoneCallback(*callback, success, error_message);
+  callback->Reset();
+}
+
 }  // namespace
 
+WebRtcLogBuffer::WebRtcLogBuffer()
+    : buffer_(),
+      circular_(&buffer_[0], sizeof(buffer_), sizeof(buffer_) / 2, false),
+      read_only_(false) {
+}
+
+WebRtcLogBuffer::~WebRtcLogBuffer() {
+  DCHECK(read_only_ || thread_checker_.CalledOnValidThread());
+}
+
+void WebRtcLogBuffer::Log(const std::string& message) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!read_only_);
+  circular_.Write(message.c_str(), message.length());
+  const char eol = '\n';
+  circular_.Write(&eol, 1);
+}
+
+PartialCircularBuffer WebRtcLogBuffer::Read() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(read_only_);
+  return PartialCircularBuffer(&buffer_[0], sizeof(buffer_));
+}
+
+void WebRtcLogBuffer::SetComplete() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!read_only_) << "Already set? (programmer error)";
+  read_only_ = true;
+  // Detach from the current thread so that we can check reads on a different
+  // thread.  This is to make sure that Read()s still happen on one thread only.
+  thread_checker_.DetachFromThread();
+}
+
 WebRtcLoggingHandlerHost::WebRtcLoggingHandlerHost(Profile* profile)
     : BrowserMessageFilter(WebRtcLoggingMsgStart),
       profile_(profile),
       logging_state_(CLOSED),
       upload_log_on_render_close_(false) {
   DCHECK(profile_);
 }
 
 WebRtcLoggingHandlerHost::~WebRtcLoggingHandlerHost() {}
 
 void WebRtcLoggingHandlerHost::SetMetaData(
-    const MetaDataMap& meta_data,
+    scoped_ptr<MetaDataMap> meta_data,
     const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   std::string error_message;
   if (logging_state_ == CLOSED) {
-    meta_data_ = meta_data;
+    if (!meta_data_.get())
+      meta_data_ = meta_data.Pass();
   } else if (logging_state_ == STARTED) {
-    meta_data_ = meta_data;
     std::string meta_data_message;
-    FormatMetaDataAsLogMessage(meta_data_, &meta_data_message);
+    FormatMetaDataAsLogMessage(*meta_data.get(), &meta_data_message);
     LogToCircularBuffer(meta_data_message);
   } else {
     error_message = "Meta data must be set before stop or upload.";
   }
-  bool success = error_message.empty();
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(callback, success,
-                                              error_message));
+
+  if (error_message.empty() && meta_data.get()) {
+    // Keep the meta data around for uploading separately from the log.
+    for (const auto& it : *meta_data.get())
+      (*meta_data_.get())[it.first] = it.second;
+  }
+
+  FireGenericDoneCallback(callback, error_message.empty(), error_message);
 }
 
 void WebRtcLoggingHandlerHost::StartLogging(
     const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  start_callback_ = callback;
   if (logging_state_ != CLOSED) {
-    FireGenericDoneCallback(&start_callback_, false, "A log is already open");
+    FireGenericDoneCallback(callback, false, "A log is already open");
     return;
   }
+
   logging_state_ = STARTING;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::StartLoggingIfAllowed, this));
+      &WebRtcLoggingHandlerHost::StartLoggingIfAllowed, this, callback));
 }
 
 void WebRtcLoggingHandlerHost::StopLogging(
     const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  stop_callback_ = callback;
   if (logging_state_ != STARTED) {
-    FireGenericDoneCallback(&stop_callback_, false, "Logging not started");
+    FireGenericDoneCallback(callback, false, "Logging not started");
     return;
   }
+
+  stop_callback_ = callback;
   logging_state_ = STOPPING;
   Send(new WebRtcLoggingMsg_StopLogging());
 }
 
 void WebRtcLoggingHandlerHost::UploadLog(const UploadDoneCallback& callback) {
   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::TriggerUpload, this, callback));
+}
+
+void WebRtcLoggingHandlerHost::UploadStoredLog(
+    const std::string& log_id,
+    const UploadDoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
+  content::BrowserThread::PostTask(content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::UploadStoredLogOnFileThread,
+                 this, log_id, callback));
+}
+
+void WebRtcLoggingHandlerHost::UploadStoredLogOnFileThread(
+    const std::string& log_id,
+    const UploadDoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  WebRtcLogUploadDoneData upload_data;
+  upload_data.log_path = GetLogDirectoryAndEnsureExists();
+  upload_data.callback = callback;
+  upload_data.host = this;
+  upload_data.local_log_id = log_id;
+
+  g_browser_process->webrtc_log_uploader()->UploadStoredLog(upload_data);
 }
 
 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);
+    FireGenericDoneCallback(callback, false, kLogNotStoppedOrNoLogOpen);
     return;
   }
   g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
-  circular_buffer_.reset();
   log_buffer_.reset();
+  meta_data_.reset();
   logging_state_ = CLOSED;
   rtp_dump_handler_.reset();
   stop_rtp_dump_callback_.Reset();
-  FireGenericDoneCallback(&discard_callback, true, "");
+  FireGenericDoneCallback(callback, true, "");
+}
+
+// Stores the log locally using a hash of log_id + security origin.
+void WebRtcLoggingHandlerHost::StoreLog(
+    const std::string& log_id,
+    const GenericDoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
+  if (logging_state_ != STOPPED) {
+    FireGenericDoneCallback(callback, false, kLogNotStoppedOrNoLogOpen);
+    return;
+  }
+
+  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::StoreLogContinue,
+                   this, log_id, callback));
+    return;
+  }
+
+  StoreLogContinue(log_id, callback);
+}
+
+void WebRtcLoggingHandlerHost::StoreLogContinue(
+    const std::string& log_id,
+    const GenericDoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
+  scoped_ptr<WebRtcLogPaths> log_paths(new WebRtcLogPaths());
+  ReleaseRtpDumps(log_paths.get());
+
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcLoggingHandlerHost::StoreLogInDirectory, this, log_id,
+                 Passed(&log_paths), callback));
 }
 
 void WebRtcLoggingHandlerHost::LogMessage(const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &WebRtcLoggingHandlerHost::AddLogMessageFromBrowser,
           this,
           WebRtcLoggingMessageData(base::Time::Now(), message)));
@@ skipping 16 matching lines @@
         FROM_HERE,
         base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                    this),
         base::Bind(&WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart,
                    this,
                    type,
                    callback));
     return;
   }
 
-  GenericDoneCallback start_callback = callback;
-  DoStartRtpDump(type, &start_callback);
+  DoStartRtpDump(type, callback);
 }
 
 void WebRtcLoggingHandlerHost::StopRtpDump(
     RtpDumpType type,
     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.");
+    FireGenericDoneCallback(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));
@@ skipping 31 matching lines @@
   if (rtp_dump_handler_) {
     rtp_dump_handler_->OnRtpPacket(
         packet_header.get(), header_length, packet_length, incoming);
   }
 }
 
 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::TriggerUpload, this,
+                     UploadDoneCallback()));
     } else {
       g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
     }
   }
   content::BrowserMessageFilter::OnChannelClosing();
 }
 
 void WebRtcLoggingHandlerHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
@@ skipping 33 matching lines @@
   if (logging_state_ != STOPPING) {
     // If an out-of-order response is received, stop_callback_ may be invalid,
     // and must not be invoked.
     DLOG(ERROR) << "OnLoggingStoppedInRenderer invoked in state "
                 << logging_state_;
     BadMessageReceived();
     return;
   }
   logging_started_time_ = base::Time();
   logging_state_ = STOPPED;
-  FireGenericDoneCallback(&stop_callback_, true, "");
+  FireAndResetGenericDoneCallback(&stop_callback_, true, "");
 }
 
-void WebRtcLoggingHandlerHost::StartLoggingIfAllowed() {
+void WebRtcLoggingHandlerHost::StartLoggingIfAllowed(
+    const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!g_browser_process->webrtc_log_uploader()->ApplyForStartLogging()) {
-    logging_state_ = CLOSED;
-      FireGenericDoneCallback(
-          &start_callback_, false, "Cannot start, maybe the maximum number of "
-          "simultaneuos logs has been reached.");
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::DoStartLogging, this,
+      g_browser_process->webrtc_log_uploader()->ApplyForStartLogging(),
+      callback));
+}
+
+void WebRtcLoggingHandlerHost::DoStartLogging(
+    bool permissions_granted,
+    const GenericDoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (logging_state_ != STARTING) {
+    FireGenericDoneCallback(callback, false, "Logging cancelled.");
     return;
   }
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::DoStartLogging, this));
+
+  if (!permissions_granted) {
+    logging_state_ = CLOSED;
+    FireGenericDoneCallback(callback, false,
+        "Cannot start, maybe the maximum number of "
+        "simultaneuos logs has been reached.");
+    return;
+  }
+
+  DCHECK(!log_buffer_.get());
+  log_buffer_.reset(new WebRtcLogBuffer());
+  if (!meta_data_.get())
+    meta_data_.reset(new MetaDataMap());
+
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
+      &WebRtcLoggingHandlerHost::LogInitialInfoOnFileThread, this, callback));
 }
 
-void WebRtcLoggingHandlerHost::DoStartLogging() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  log_buffer_.reset(new unsigned char[kWebRtcLogSize]);
-  circular_buffer_.reset(
-    new PartialCircularBuffer(log_buffer_.get(),
-                              kWebRtcLogSize,
-                              kWebRtcLogSize / 2,
-                              false));
-
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::LogInitialInfoOnFileThread, this));
-}
-
-void WebRtcLoggingHandlerHost::LogInitialInfoOnFileThread() {
+void WebRtcLoggingHandlerHost::LogInitialInfoOnFileThread(
+    const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   net::NetworkInterfaceList network_list;
   net::GetNetworkList(&network_list,
                       net::EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES);
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &WebRtcLoggingHandlerHost::LogInitialInfoOnIOThread, this, network_list));
+      &WebRtcLoggingHandlerHost::LogInitialInfoOnIOThread, this, network_list,
+      callback));
 }
 
 void WebRtcLoggingHandlerHost::LogInitialInfoOnIOThread(
-    const net::NetworkInterfaceList& network_list) {
+    const net::NetworkInterfaceList& network_list,
+    const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (logging_state_ != STARTING) {
+    FireGenericDoneCallback(callback, false, "Logging cancelled.");
+    return;
+  }
 
   // Log start time (current time). We don't use base/i18n/time_formatting.h
   // here because we don't want the format of the current locale.
   base::Time::Exploded now = {0};
   base::Time::Now().LocalExplode(&now);
   LogToCircularBuffer(base::StringPrintf(
       "Start %d-%02d-%02d %02d:%02d:%02d", now.year, now.month,
       now.day_of_month, now.hour, now.minute, now.second));
 
   // Write metadata if received before logging started.
-  if (!meta_data_.empty()) {
+  if (meta_data_.get() && !meta_data_->empty()) {
     std::string info;
-    FormatMetaDataAsLogMessage(meta_data_, &info);
+    FormatMetaDataAsLogMessage(*meta_data_.get(), &info);
     LogToCircularBuffer(info);
   }
 
   // Chrome version
   chrome::VersionInfo version_info;
   LogToCircularBuffer("Chrome version: " + version_info.Version() + " " +
                       chrome::VersionInfo::GetVersionStringModifier());
 
   // OS
   LogToCircularBuffer(base::SysInfo::OperatingSystemName() + " " +
@@ skipping 46 matching lines @@
   LogToCircularBuffer("Discovered " + IntToString(network_list.size()) +
                       " network interfaces:");
   for (net::NetworkInterfaceList::const_iterator it = network_list.begin();
        it != network_list.end(); ++it) {
     LogToCircularBuffer(
         "Name: " + it->friendly_name + ", Address: " +
         IPAddressToSensitiveString(it->address) + ", Type: " +
         net::NetworkChangeNotifier::ConnectionTypeToString(it->type));
   }
 
-  NotifyLoggingStarted();
+  NotifyLoggingStarted(callback);
 }
 
-void WebRtcLoggingHandlerHost::NotifyLoggingStarted() {
+void WebRtcLoggingHandlerHost::NotifyLoggingStarted(
+    const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_EQ(logging_state_, STARTING);
   Send(new WebRtcLoggingMsg_StartLogging());
   logging_started_time_ = base::Time::Now();
   logging_state_ = STARTED;
-  FireGenericDoneCallback(&start_callback_, true, "");
+  FireGenericDoneCallback(callback, true, "");
 }
 
 void WebRtcLoggingHandlerHost::LogToCircularBuffer(const std::string& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(circular_buffer_.get());
-  circular_buffer_->Write(message.c_str(), message.length());
-  const char eol = '\n';
-  circular_buffer_->Write(&eol, 1);
+  DCHECK_NE(logging_state_, CLOSED);
+  log_buffer_->Log(message);
 }
 
 base::FilePath WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   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(
+    const UploadDoneCallback& callback,
     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));
+                   log_directory,
+                   callback));
     return;
   }
 
-  DoUploadLogAndRtpDumps(log_directory);
+  DoUploadLogAndRtpDumps(log_directory, callback);
+}
+
+void WebRtcLoggingHandlerHost::StoreLogInDirectory(
+    const std::string& log_id,
+    scoped_ptr<WebRtcLogPaths> log_paths,
+    const GenericDoneCallback& done_callback,
+    const base::FilePath& directory) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  log_paths->log_path = directory;
+
+  log_buffer_->SetComplete();
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WebRtcLogUploader::LoggingStoppedDoStore,
+          base::Unretained(g_browser_process->webrtc_log_uploader()),
+          *log_paths.get(), log_id, Passed(&log_buffer_), Passed(&meta_data_),
+          done_callback));
+
+  logging_state_ = CLOSED;
 }
 
 void WebRtcLoggingHandlerHost::DoUploadLogAndRtpDumps(
-    const base::FilePath& log_directory) {
+    const base::FilePath& log_directory,
+    const UploadDoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   WebRtcLogUploadDoneData upload_done_data;
   upload_done_data.log_path = log_directory;
+  upload_done_data.callback = callback;
+  upload_done_data.host = this;
+  ReleaseRtpDumps(&upload_done_data);
 
-  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();
-
+  log_buffer_->SetComplete();
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
       &WebRtcLogUploader::LoggingStoppedDoUpload,
       base::Unretained(g_browser_process->webrtc_log_uploader()),
       Passed(&log_buffer_),
-      kWebRtcLogSize,
-      meta_data_,
+      Passed(&meta_data_),
       upload_done_data));
 
-  meta_data_.clear();
-  circular_buffer_.reset();
-}
-
-void WebRtcLoggingHandlerHost::FireGenericDoneCallback(
-    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));
-  (*callback).Reset();
+  logging_state_ = CLOSED;
 }
 
 void WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart(
     RtpDumpType type,
-    GenericDoneCallback callback,
+    const 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);
+  DoStartRtpDump(type, callback);
 }
 
-void WebRtcLoggingHandlerHost::DoStartRtpDump(RtpDumpType type,
-                                              GenericDoneCallback* callback) {
+void WebRtcLoggingHandlerHost::DoStartRtpDump(
+    RtpDumpType type, const 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);
 }
+
+bool WebRtcLoggingHandlerHost::ReleaseRtpDumps(WebRtcLogPaths* log_paths) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(log_paths);
+
+  if (!rtp_dump_handler_)
+    return false;
+
+  WebRtcRtpDumpHandler::ReleasedDumps rtp_dumps(
+      rtp_dump_handler_->ReleaseDumps());
+  log_paths->incoming_rtp_dump = rtp_dumps.incoming_dump_path;
+  log_paths->outgoing_rtp_dump = rtp_dumps.outgoing_dump_path;
+
+  rtp_dump_handler_.reset();
+  stop_rtp_dump_callback_.Reset();
+
+  return true;
+}