Removed GetOutputVolume() and SetOutputVolume().

webrtc/pc/channelmanager.cc

 /*
  *  Copyright 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 14 matching lines @@
 #ifdef HAVE_SCTP
 #include "webrtc/media/sctp/sctpdataengine.h"
 #endif
 #include "webrtc/pc/srtpfilter.h"
 
 namespace cricket {
 
 
 using rtc::Bind;
 
-static const int kNotSetOutputVolume = -1;
-
 static DataEngineInterface* ConstructDataEngine() {
 #ifdef HAVE_SCTP
   return new HybridDataEngine(new RtpDataEngine(), new SctpDataEngine());
 #else
   return new RtpDataEngine();
 #endif
 }
 
 ChannelManager::ChannelManager(MediaEngineInterface* me,
                                DataEngineInterface* dme,
@@ skipping 10 matching lines @@
 void ChannelManager::Construct(MediaEngineInterface* me,
                                DataEngineInterface* dme,
                                rtc::Thread* worker_thread,
                                rtc::Thread* network_thread) {
   media_engine_.reset(me);
   data_media_engine_.reset(dme);
   initialized_ = false;
   main_thread_ = rtc::Thread::Current();
   worker_thread_ = worker_thread;
   network_thread_ = network_thread;
-  audio_output_volume_ = kNotSetOutputVolume;
   capturing_ = false;
   enable_rtx_ = false;
 }
 
 ChannelManager::~ChannelManager() {
   if (initialized_) {
     Terminate();
     // If srtp is initialized (done by the Channel) then we must call
     // srtp_shutdown to free all crypto kernel lists. But we need to make sure
     // shutdown always called at the end, after channels are destroyed.
@@ skipping 72 matching lines @@
   if (!network_thread_->IsCurrent()) {
     // Do not allow invoking calls to other threads on the network thread.
     network_thread_->Invoke<bool>(
         RTC_FROM_HERE,
         rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, network_thread_, false));
   }
 
   initialized_ = worker_thread_->Invoke<bool>(
       RTC_FROM_HERE, Bind(&ChannelManager::InitMediaEngine_w, this));
   ASSERT(initialized_);
-  if (!initialized_) {
-    return false;
-  }
-
-  // If audio_output_volume_ has been set via SetOutputVolume(), set the
-  // audio output volume of the engine.
-  if (kNotSetOutputVolume != audio_output_volume_ &&
-      !SetOutputVolume(audio_output_volume_)) {
-    LOG(LS_WARNING) << "Failed to SetOutputVolume to "
-                    << audio_output_volume_;
-  }
-
   return initialized_;
 }
 
 bool ChannelManager::InitMediaEngine_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   return media_engine_->Init();
 }
 
 void ChannelManager::Terminate() {
   ASSERT(initialized_);
@@ skipping 203 matching lines @@
   DataChannels::iterator it = std::find(data_channels_.begin(),
       data_channels_.end(), data_channel);
   ASSERT(it != data_channels_.end());
   if (it == data_channels_.end())
     return;
 
   data_channels_.erase(it);
   delete data_channel;
 }
 
-bool ChannelManager::GetOutputVolume(int* level) {
-  if (!initialized_) {
-    return false;
-  }
-  return worker_thread_->Invoke<bool>(
-      RTC_FROM_HERE,
-      Bind(&MediaEngineInterface::GetOutputVolume, media_engine_.get(), level));
-}
-
-bool ChannelManager::SetOutputVolume(int level) {
-  bool ret = level >= 0 && level <= 255;
-  if (initialized_) {
-    ret &= worker_thread_->Invoke<bool>(

[tommi, 2016/06/14 14:38:07]

I'm especially happy to see one of these go away :)

-        RTC_FROM_HERE, Bind(&MediaEngineInterface::SetOutputVolume,
-                            media_engine_.get(), level));
-  }
-
-  if (ret) {
-    audio_output_volume_ = level;
-  }
-
-  return ret;
-}
-
-
 bool ChannelManager::StartAecDump(rtc::PlatformFile file,
                                   int64_t max_size_bytes) {
   return worker_thread_->Invoke<bool>(
       RTC_FROM_HERE, Bind(&MediaEngineInterface::StartAecDump,
                           media_engine_.get(), file, max_size_bytes));
 }
 
 void ChannelManager::StopAecDump() {
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&MediaEngineInterface::StopAecDump, media_engine_.get()));
 }
 
 bool ChannelManager::StartRtcEventLog(rtc::PlatformFile file,
                                       int64_t max_size_bytes) {
   return worker_thread_->Invoke<bool>(
       RTC_FROM_HERE, Bind(&MediaEngineInterface::StartRtcEventLog,
                           media_engine_.get(), file, max_size_bytes));
 }
 
 void ChannelManager::StopRtcEventLog() {
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&MediaEngineInterface::StopRtcEventLog, media_engine_.get()));
 }
 
 }  // namespace cricket