Removing public access to AudioManager device info interface.

media/audio/audio_output_proxy_unittest.cc

 // Copyright (c) 2012 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.
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
@@ skipping 85 matching lines @@
 };
 
 class MockAudioManager : public AudioManagerBase {
  public:
   MockAudioManager()
       : AudioManagerBase(base::ThreadTaskRunnerHandle::Get(),
                          base::ThreadTaskRunnerHandle::Get(),
                          &fake_audio_log_factory_) {}
   ~MockAudioManager() override { Shutdown(); }
 
-  MOCK_METHOD0(HasAudioOutputDevices, bool());
-  MOCK_METHOD0(HasAudioInputDevices, bool());
-  MOCK_METHOD0(GetAudioInputDeviceModel, base::string16());
   MOCK_METHOD3(MakeAudioOutputStream,
                AudioOutputStream*(const AudioParameters& params,
                                   const std::string& device_id,
                                   const LogCallback& log_callback));
   MOCK_METHOD2(MakeAudioOutputStreamProxy, AudioOutputStream*(
       const AudioParameters& params,
       const std::string& device_id));
   MOCK_METHOD3(MakeAudioInputStream,
                AudioInputStream*(const AudioParameters& params,
                                  const std::string& device_id,
                                  const LogCallback& log_callback));
-  MOCK_METHOD0(ShowAudioInputSettings, void());
   MOCK_METHOD0(GetTaskRunner, scoped_refptr<base::SingleThreadTaskRunner>());
   MOCK_METHOD0(GetWorkerTaskRunner,
                scoped_refptr<base::SingleThreadTaskRunner>());
-  MOCK_METHOD1(GetAudioInputDeviceNames, void(
-      media::AudioDeviceNames* device_name));
   MOCK_METHOD0(GetName, const char*());
 
   MOCK_METHOD2(MakeLinearOutputStream,
                AudioOutputStream*(const AudioParameters& params,
                                   const LogCallback& log_callback));
   MOCK_METHOD3(MakeLowLatencyOutputStream,
                AudioOutputStream*(const AudioParameters& params,
                                   const std::string& device_id,
                                   const LogCallback& log_callback));
   MOCK_METHOD3(MakeLinearInputStream,
                AudioInputStream*(const AudioParameters& params,
                                  const std::string& device_id,
                                  const LogCallback& log_callback));
   MOCK_METHOD3(MakeLowLatencyInputStream,
                AudioInputStream*(const AudioParameters& params,
                                  const std::string& device_id,
                                  const LogCallback& log_callback));
+
+ protected:
+  MOCK_METHOD0(HasAudioOutputDevices, bool());
+  MOCK_METHOD0(HasAudioInputDevices, bool());
+  MOCK_METHOD0(GetAudioInputDeviceModel, base::string16());
+  MOCK_METHOD0(ShowAudioInputSettings, void());
+  MOCK_METHOD1(GetAudioInputDeviceNames,
+               void(media::AudioDeviceNames* device_name));
   MOCK_METHOD2(GetPreferredOutputStreamParameters, AudioParameters(
       const std::string& device_id, const AudioParameters& params));
 
  private:
   media::FakeAudioLogFactory fake_audio_log_factory_;
 };
 
 class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
   int OnMoreData(base::TimeDelta /* delay */,
@@ skipping 687 matching lines @@
       .WillOnce(Return(&real_stream));
 
   // Stream1 should be able to successfully open and start.
   EXPECT_CALL(real_stream, Open()).WillOnce(Return(true));
   proxy = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &real_stream);
 }
 
 }  // namespace media