Remove SetAudioDelayOffset() and friends.

talk/session/media/channelmanager.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 27 matching lines @@
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/sigslotrepeater.h"
 #include "webrtc/base/thread.h"
 
 namespace webrtc {
 class MediaControllerInterface;
 }
 namespace cricket {
 
-const int kDefaultAudioDelayOffset = 0;
-
 class VoiceChannel;
 
 // ChannelManager allows the MediaEngine to run on a separate thread, and takes
 // care of marshalling calls between threads. It also creates and keeps track of
 // voice and video channels; by doing so, it can temporarily pause all the
 // channels when a new audio or video device is chosen. The voice and video
 // channels are stored in separate vectors, to easily allow operations on just
 // voice or just video channels.
 // ChannelManager also allows the application to discover what devices it has
 // using device manager.
@@ skipping 111 matching lines @@
   // The operations below occur on the main thread.
 
   // Starts AEC dump using existing file.
   bool StartAecDump(rtc::PlatformFile file);
 
   sigslot::signal2<VideoCapturer*, CaptureState> SignalVideoCaptureStateChange;
 
  protected:
   // Adds non-transient parameters which can only be changed through the
   // options store.
-  bool SetAudioOptions(const AudioOptions& options, int delay_offset);
-  int audio_delay_offset() const { return audio_delay_offset_; }
+  bool SetAudioOptions(const AudioOptions& options);
 
  private:
   typedef std::vector<VoiceChannel*> VoiceChannels;
   typedef std::vector<VideoChannel*> VideoChannels;
   typedef std::vector<DataChannel*> DataChannels;
 
   void Construct(MediaEngineInterface* me,
                  DataEngineInterface* dme,
                  CaptureManager* cm,
                  rtc::Thread* worker_thread);
@@ skipping 12 matching lines @@
       TransportController* transport_controller,
       const std::string& content_name,
       bool rtcp,
       const VideoOptions& options);
   void DestroyVideoChannel_w(VideoChannel* video_channel);
   DataChannel* CreateDataChannel_w(TransportController* transport_controller,
                                    const std::string& content_name,
                                    bool rtcp,
                                    DataChannelType data_channel_type);
   void DestroyDataChannel_w(DataChannel* data_channel);
-  bool SetAudioOptions_w(const AudioOptions& options, int delay_offset,
+  bool SetAudioOptions_w(const AudioOptions& options,
                          const Device* in_dev, const Device* out_dev);
   void OnVideoCaptureStateChange(VideoCapturer* capturer,
                                  CaptureState result);
   void GetSupportedFormats_w(
       VideoCapturer* capturer,
       std::vector<cricket::VideoFormat>* out_formats) const;
   bool IsScreencastRunning_w() const;
   virtual void OnMessage(rtc::Message *message);
 
   rtc::scoped_ptr<MediaEngineInterface> media_engine_;
   rtc::scoped_ptr<DataEngineInterface> data_media_engine_;
   rtc::scoped_ptr<CaptureManager> capture_manager_;
   bool initialized_;
   rtc::Thread* main_thread_;
   rtc::Thread* worker_thread_;
 
   VoiceChannels voice_channels_;
   VideoChannels video_channels_;
   DataChannels data_channels_;
 
   AudioOptions audio_options_;
-  int audio_delay_offset_;
   int audio_output_volume_;
   VideoEncoderConfig default_video_encoder_config_;
   VideoRenderer* local_renderer_;
   bool enable_rtx_;
 
   bool capturing_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_CHANNELMANAGER_H_