Change SetOutputScaling to set a single level, not left/right levels.

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 225 matching lines @@
           flags(flags) {}
     uint32_t ssrc;
     int event_code;
     int duration;
     int flags;
   };
   explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine,
                                  const AudioOptions& options)
       : engine_(engine),
         time_since_last_typing_(-1) {
-    output_scalings_[0] = OutputScaling();  // For default channel.
+    output_scalings_[0] = 1.0;  // 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_; }
@@ skipping 27 matching lines @@
       return false;
     }
     if (enable && options) {
       return SetOptions(*options);
     }
     return true;
   }
   virtual bool AddRecvStream(const StreamParams& sp) {
     if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
       return false;
-    output_scalings_[sp.first_ssrc()] = OutputScaling();
+    output_scalings_[sp.first_ssrc()] = 1.0;
     return true;
   }
   virtual bool RemoveRecvStream(uint32_t ssrc) {
     if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
       return false;
     output_scalings_.erase(ssrc);
     return true;
   }
   virtual bool SetRemoteRenderer(uint32_t ssrc, AudioRenderer* renderer) {
     std::map<uint32_t, AudioRenderer*>::iterator it =
@@ skipping 35 matching lines @@
     return false;
   }
   virtual bool InsertDtmf(uint32_t ssrc,
                           int event_code,
                           int duration,
                           int flags) {
     dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration, flags));
     return true;
   }
 
-  virtual bool SetOutputScaling(uint32_t ssrc, double left, double right) {
+  virtual bool SetOutputVolume(uint32_t ssrc, double volume) {
     if (0 == ssrc) {
-      std::map<uint32_t, OutputScaling>::iterator it;
+      std::map<uint32_t, double>::iterator it;
       for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) {
-        it->second.left = left;
-        it->second.right = right;
+        it->second = volume;
       }
       return true;
     } else if (output_scalings_.find(ssrc) != output_scalings_.end()) {
-      output_scalings_[ssrc].left = left;
-      output_scalings_[ssrc].right = right;
+      output_scalings_[ssrc] = volume;
       return true;
     }
     return false;
   }
-  bool GetOutputScaling(uint32_t ssrc, double* left, double* right) {
+  bool GetOutputVolume(uint32_t ssrc, double* volume) {
     if (output_scalings_.find(ssrc) == output_scalings_.end())
       return false;
-    *left = output_scalings_[ssrc].left;
-    *right = output_scalings_[ssrc].right;
+    *volume = output_scalings_[ssrc];
     return true;
   }
 
   virtual bool GetStats(VoiceMediaInfo* info) { return false; }
 
  private:
-  struct OutputScaling {
-    OutputScaling() : left(1.0), right(1.0) {}
-    double left, right;
-  };
-
   class VoiceChannelAudioSink : public AudioRenderer::Sink {
    public:
     explicit VoiceChannelAudioSink(AudioRenderer* renderer)
         : renderer_(renderer) {
       renderer_->AddChannel(0);
       renderer_->SetSink(this);
     }
     virtual ~VoiceChannelAudioSink() {
       if (renderer_) {
         renderer_->RemoveChannel(0);
@@ skipping 48 matching lines @@
         delete it->second;
         local_renderers_.erase(it);
       }
     }
     return true;
   }
 
   FakeVoiceEngine* engine_;
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
-  std::map<uint32_t, OutputScaling> output_scalings_;
+  std::map<uint32_t, double> output_scalings_;
   std::vector<DtmfInfo> dtmf_info_queue_;
   int time_since_last_typing_;
   AudioOptions options_;
   std::map<uint32_t, VoiceChannelAudioSink*> local_renderers_;
   std::map<uint32_t, AudioRenderer*> remote_renderers_;
 };
 
 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
                             uint32_t ssrc,
@@ skipping 550 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_