Remove unused SignalMediaError and infrastructure.

talk/media/base/fakemediaengine.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 222 matching lines @@
         : ssrc(ssrc), event_code(event_code), duration(duration), flags(flags) {
     }
     uint32 ssrc;
     int event_code;
     int duration;
     int flags;
   };
   explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine,
                                  const AudioOptions& options)
       : engine_(engine),
-        fail_set_send_(false),
         time_since_last_typing_(-1) {
     output_scalings_[0] = OutputScaling();  // For default channel.
     SetOptions(options);
   }
   ~FakeVoiceMediaChannel();
   const std::vector<AudioCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<AudioCodec>& codecs() const { return send_codecs(); }
   const std::vector<DtmfInfo>& dtmf_info_queue() const {
     return dtmf_info_queue_;
   }
   const AudioOptions& options() const { return options_; }
 
   virtual bool SetSendParameters(const AudioSendParameters& params) {
     return (SetSendCodecs(params.codecs) &&
             SetSendRtpHeaderExtensions(params.extensions) &&
             SetMaxSendBandwidth(params.max_bandwidth_bps) &&
             SetOptions(params.options));
   }
 
   virtual bool SetRecvParameters(const AudioRecvParameters& params) {
     return (SetRecvCodecs(params.codecs) &&
             SetRecvRtpHeaderExtensions(params.extensions));
   }
   virtual bool SetPlayout(bool playout) {
     set_playout(playout);
     return true;
   }
   virtual bool SetSend(SendFlags flag) {
-    if (fail_set_send_) {
-      return false;
-    }
     return set_sending(flag != SEND_NOTHING);
   }
   virtual bool SetAudioSend(uint32 ssrc, bool enable,
                             const AudioOptions* options,
                             AudioRenderer* renderer) {
     if (!SetLocalRenderer(ssrc, renderer)) {
       return false;
     }
     if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, !enable)) {
       return false;
@@ skipping 77 matching lines @@
   }
   bool GetOutputScaling(uint32 ssrc, double* left, double* right) {
     if (output_scalings_.find(ssrc) == output_scalings_.end())
       return false;
     *left = output_scalings_[ssrc].left;
     *right = output_scalings_[ssrc].right;
     return true;
   }
 
   virtual bool GetStats(VoiceMediaInfo* info) { return false; }
-  virtual void GetLastMediaError(uint32* ssrc,
-                                 VoiceMediaChannel::Error* error) {
-    *ssrc = 0;
-    *error = fail_set_send_ ? VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED
-                            : VoiceMediaChannel::ERROR_NONE;
-  }
-
-  void set_fail_set_send(bool fail) { fail_set_send_ = fail; }
-  void TriggerError(uint32 ssrc, VoiceMediaChannel::Error error) {
-    VoiceMediaChannel::SignalMediaError(ssrc, error);
-  }
 
  private:
   struct OutputScaling {
     OutputScaling() : left(1.0), right(1.0) {}
     double left, right;
   };
 
   class VoiceChannelAudioSink : public AudioRenderer::Sink {
    public:
     explicit VoiceChannelAudioSink(AudioRenderer* renderer)
@@ skipping 57 matching lines @@
       }
     }
     return true;
   }
 
   FakeVoiceEngine* engine_;
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
   std::map<uint32, OutputScaling> output_scalings_;
   std::vector<DtmfInfo> dtmf_info_queue_;
-  bool fail_set_send_;
   int time_since_last_typing_;
   AudioOptions options_;
   std::map<uint32, VoiceChannelAudioSink*> local_renderers_;
   std::map<uint32, AudioRenderer*> remote_renderers_;
 };
 
 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
                             uint32 ssrc, int event_code, int duration,
                             int flags) {
@@ skipping 547 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_