Start and stop RTC event logs from private extension API.

chrome/browser/media/webrtc_logging_handler_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
 #define CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <map>
+#include <string>
+#include <vector>
+
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/browser/media/rtp_dump_type.h"
 #include "chrome/browser/media/webrtc_rtp_dump_handler.h"
 #include "chrome/common/media/webrtc_logging_message_data.h"
 #include "chrome/common/partial_circular_buffer.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/render_process_host.h"
 #include "net/base/network_interfaces.h"
@@ skipping 53 matching lines @@
 // - Informs the handler in the render process when to stop logging.
 // - Closes the shared memory (and thereby discarding it) or triggers uploading
 //   of the log.
 // - Detects when channel, i.e. renderer, is going away and possibly triggers
 //   uploading the log.
 class WebRtcLoggingHandlerHost : public content::BrowserMessageFilter {
  public:
   typedef base::Callback<void(bool, const std::string&)> GenericDoneCallback;
   typedef base::Callback<void(bool, const std::string&, const std::string&)>
       UploadDoneCallback;
-  typedef base::Callback<void(const std::string&)>
-      AudioDebugRecordingsErrorCallback;
-  typedef base::Callback<void(const std::string&, bool, bool)>
-      AudioDebugRecordingsCallback;
+
+  // Key used to attach the handler to the RenderProcessHost.
+  static const char kWebRtcLoggingHandlerHostKey[];
 
   WebRtcLoggingHandlerHost(int render_process_id,
                            Profile* profile,
                            WebRtcLogUploader* log_uploader);
 
   // Sets meta data that will be uploaded along with the log and also written
   // in the beginning of the log. Must be called on the IO thread before calling
   // StartLogging.
   void SetMetaData(std::unique_ptr<MetaDataMap> meta_data,
                    const GenericDoneCallback& callback);
@@ skipping 51 matching lines @@
   // done.
   void StopRtpDump(RtpDumpType type, const GenericDoneCallback& callback);
 
   // Called when an RTP packet is sent or received. Must be called on the UI
   // thread.
   void OnRtpPacket(std::unique_ptr<uint8_t[]> packet_header,
                    size_t header_length,
                    size_t packet_length,
                    bool incoming);
 
-  // Starts an audio debug recording. The recording lasts the given |delay|,
-  // unless |delay| is zero, in which case recording will continue until
-  // StopAudioDebugRecordings() is explicitly invoked.
-  // |callback| is invoked once recording stops. If |delay| is zero
-  // |callback| is invoked once recording starts.
-  // If a recording was already in progress, |error_callback| is invoked instead
-  // of |callback|.
-  void StartAudioDebugRecordings(
-      content::RenderProcessHost* host,
-      base::TimeDelta delay,
-      const AudioDebugRecordingsCallback& callback,
-      const AudioDebugRecordingsErrorCallback& error_callback);
-
-  // Stops an audio debug recording. |callback| is invoked once recording
-  // stops. If no recording was in progress, |error_callback| is invoked instead
-  // of |callback|.
-  void StopAudioDebugRecordings(
-      content::RenderProcessHost* host,
-      const AudioDebugRecordingsCallback& callback,
-      const AudioDebugRecordingsErrorCallback& error_callback);
-
  private:
   // States used for protecting from function calls made at non-allowed points
   // in time. For example, StartLogging() is only allowed in CLOSED state.
   // Transitions: SetMetaData(): CLOSED -> CLOSED.
   //              StartLogging(): CLOSED -> STARTING.
   //              Start done: STARTING -> STARTED.
   //              StopLogging(): STARTED -> STOPPING.
   //              Stop done: STOPPING -> STOPPED.
   //              UploadLog(): STOPPED -> UPLOADING.
   //              Upload done: UPLOADING -> CLOSED.
@@ skipping 69 matching lines @@
                                size_t packet_length,
                                bool incoming);
 
   bool ReleaseRtpDumps(WebRtcLogPaths* log_paths);
 
   void FireGenericDoneCallback(
       const WebRtcLoggingHandlerHost::GenericDoneCallback& callback,
       bool success,
       const std::string& error_message);
 
-  // Helper for starting audio debug recordings.
-  void DoStartAudioDebugRecordings(
-      content::RenderProcessHost* host,
-      base::TimeDelta delay,
-      const AudioDebugRecordingsCallback& callback,
-      const AudioDebugRecordingsErrorCallback& error_callback,
-      const base::FilePath& log_directory);
-
-  // Helper for stopping audio debug recordings.
-  void DoStopAudioDebugRecordings(
-      content::RenderProcessHost* host,
-      bool is_manual_stop,
-      uint64_t audio_debug_recordings_id,
-      const AudioDebugRecordingsCallback& callback,
-      const AudioDebugRecordingsErrorCallback& error_callback,
-      const base::FilePath& log_directory);
-
   std::unique_ptr<WebRtcLogBuffer> log_buffer_;
 
   // The profile associated with our renderer process.
   Profile* const profile_;
 
   // These are only accessed on the IO thread, except when in STARTING state. In
   // this state we are protected since entering any function that alters the
   // state is not allowed.
   std::unique_ptr<MetaDataMap> meta_data_;
 
@@ skipping 21 matching lines @@
   // The RTP dump handler responsible for creating the RTP header dump files.
   std::unique_ptr<WebRtcRtpDumpHandler> rtp_dump_handler_;
 
   // The callback to call when StopRtpDump is called.
   content::RenderProcessHost::WebRtcStopRtpDumpCallback stop_rtp_dump_callback_;
 
   // A pointer to the log uploader that's shared for all profiles.
   // Ownership lies with the browser process.
   WebRtcLogUploader* const log_uploader_;
 
-  // Must be accessed on the UI thread.
-  bool is_audio_debug_recordings_in_progress_;
-
-  // This counter allows saving each debug recording in separate files.
-  uint64_t current_audio_debug_recordings_id_;
-
   // The render process ID this object belongs to.
   int render_process_id_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcLoggingHandlerHost);
 };
 
 #endif  // CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_