Implement HasInputDevices in CrasAudioManager

chromeos/audio/cras_audio_handler.h

 // Copyright (c) 2013 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.
 
 #ifndef CHROMEOS_AUDIO_CRAS_AUDIO_HANDLER_H_
 #define CHROMEOS_AUDIO_CRAS_AUDIO_HANDLER_H_
 
 #include <stdint.h>
 #include <queue>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "chromeos/audio/audio_device.h"
 #include "chromeos/audio/audio_pref_observer.h"
 #include "chromeos/dbus/audio_node.h"
 #include "chromeos/dbus/cras_audio_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/dbus/volume_state.h"
 
 class PrefRegistrySimple;
 class PrefService;
 
+namespace media {
+class AudioManager;
+}
+
 namespace chromeos {
 
 class AudioDevicesPrefHandler;
 
 class CHROMEOS_EXPORT CrasAudioHandler : public CrasAudioClient::Observer,
                                          public AudioPrefObserver,
                                          public SessionManagerClient::Observer {
  public:
   typedef std::priority_queue<AudioDevice,
                               std::vector<AudioDevice>,
@@ skipping 22 matching lines @@
 
     // Called when active audio input node changed.
     virtual void OnActiveInputNodeChanged();
 
    protected:
     AudioObserver();
     virtual ~AudioObserver();
     DISALLOW_COPY_AND_ASSIGN(AudioObserver);
   };
 
+  // The wrapper for audio manager methods to be called from this class.
+  // The detail of AudioManager is hidden from CrasAudioHandler.
+  class AudioManagerWrapper {
+   public:
+    virtual ~AudioManagerWrapper();
+    virtual void SetHasInputDevices(bool has_input_devices) = 0;
+
+   protected:
+    AudioManagerWrapper();
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(AudioManagerWrapper);
+  };
+
   // Sets the global instance. Must be called before any calls to Get().
+  // Optionally pass audio_manager to use implementation other than
+  // AudioManagerWrapperImpl.
   static void Initialize(
-      scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler);
+      scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler,
+      scoped_ptr<AudioManagerWrapper> audio_manager = NULL);

[Daniel Erat, 2015/06/24 13:37:45]

default arguments aren't allowed in cases like this:
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Default_Argu...

how about making the audio_manager argument mandatory and just passing in a
concrete implementation of it in the production code?

[cychiang, 2015/06/25 05:45:24]

Done. Change production code at
chrome/browser/chromeos/chrome_browser_main_chromeos.cc.
Also, move AudioManagerWrapperImpl to public of CrasAudioHandler.

 
   // Sets the global instance for testing.
   static void InitializeForTesting();
 
   // Destroys the global instance.
   static void Shutdown();
 
   // Returns true if the global instance is initialized.
   static bool IsInitialized();
 
@@ skipping 103 matching lines @@
   // Swaps the left and right channel of the internal speaker.
   // Swap the left and right channel if |swap| is true; otherwise, swap the left
   // and right channel back to the normal mode.
   // If the feature is not supported on the device, nothing happens.
   virtual void SwapInternalSpeakerLeftRightChannel(bool swap);
 
   // Enables error logging.
   virtual void LogErrors();
 
  protected:
   explicit CrasAudioHandler(

[Daniel Erat, 2015/06/24 13:37:45]

nit: you don't need 'explicit' here now that this has two arguments

[cychiang, 2015/06/25 05:45:24]

Done.

-      scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler);
+      scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler,
+      scoped_ptr<AudioManagerWrapper> audio_manager);
   ~CrasAudioHandler() override;
 
  private:
   friend class CrasAudioHandlerTest;
 
+  class AudioManagerWrapperImpl : public AudioManagerWrapper {
+   public:
+    AudioManagerWrapperImpl();
+    ~AudioManagerWrapperImpl() override;
+    void SetHasInputDevices(bool has_input_devices) override;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(AudioManagerWrapperImpl);
+  };
+
   // CrasAudioClient::Observer overrides.
   void AudioClientRestarted() override;
   void NodesChanged() override;
   void ActiveOutputNodeChanged(uint64_t node_id) override;
   void ActiveInputNodeChanged(uint64_t node_id) override;
 
   // AudioPrefObserver overrides.
   void OnAudioPolicyPrefChanged() override;
 
   // SessionManagerClient::Observer overrides.
@@ skipping 65 matching lines @@
                        bool is_input,
                        AudioNodeList* new_discovered);
 
   // Handles dbus callback for GetNodes.
   void HandleGetNodes(const chromeos::AudioNodeList& node_list, bool success);
 
   // Handles the dbus error callback.
   void HandleGetNodesError(const std::string& error_name,
                            const std::string& error_msg);
 
+  // Sets HasInputDevice in AudioManager based on the updated device list.
+  void UpdateAudioManagerHasInputDevices();
+
+  // Sets HasInputDevice in AudioManager to true or false.
+  void SetAudioManagerHasInputDevices(bool has_input_devices);
+
   // Adds an active node.
   // If there is no active node, |node_id| will be switched to become the
   // primary active node. Otherwise, it will be added as an additional active
   // node.
   void AddActiveNode(uint64_t node_id, bool notify);
 
   // Adds |node_id| into additional active nodes.
   void AddAdditionalActiveNode(uint64_t node_id, bool notify);
 
   // Removes |node_id| from additional active nodes.
   void RemoveActiveNodeInternal(uint64_t node_id, bool notify);
 
   enum DeviceStatus {
     OLD_DEVICE,
     NEW_DEVICE,
     CHANGED_DEVICE,
   };
 
   // Checks if |device| is a newly discovered, changed, or existing device for
   // the nodes sent from NodesChanged signal.
   DeviceStatus CheckDeviceStatus(const AudioDevice& device);
 
   void NotifyActiveNodeChanged(bool is_input);
 
   scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler_;
   base::ObserverList<AudioObserver> observers_;
 
+  // audio_manager_ will point to an AudioManagerWrapperImpl object or

[Daniel Erat, 2015/06/24 13:37:45]

nit: "will hold" would probably be more accurate than "will point to" now that
this is a scoped_ptr

[cychiang, 2015/06/25 05:45:24]

Done.

+  // a mocked AudioManagerWrapper object for testing.
+  scoped_ptr<CrasAudioHandler::AudioManagerWrapper> audio_manager_;
+
   // Audio data and state.
   AudioDeviceMap audio_devices_;
 
   AudioDevicePriorityQueue input_devices_pq_;
   AudioDevicePriorityQueue output_devices_pq_;
 
   bool output_mute_on_;
   bool input_mute_on_;
   int output_volume_;
   int input_gain_;
   uint64_t active_output_node_id_;
   uint64_t active_input_node_id_;
   bool has_alternative_input_;
   bool has_alternative_output_;
 
   bool output_mute_locked_;
 
   // Failures are not logged at startup, since CRAS may not be running yet.
   bool log_errors_;
 
   base::WeakPtrFactory<CrasAudioHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CrasAudioHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_AUDIO_CRAS_AUDIO_HANDLER_H_