Listen for OutputNodeVolumeChanged signal

chromeos/dbus/cras_audio_client_unittest.cc

 // Copyright 2016 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 "chromeos/dbus/cras_audio_client.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 51 matching lines @@
 // A mock CrasAudioClient Observer.
 class MockObserver : public CrasAudioClient::Observer {
  public:
   MockObserver() {}
   ~MockObserver() override {}
   MOCK_METHOD1(OutputMuteChanged, void(bool mute_on));
   MOCK_METHOD1(InputMuteChanged, void(bool mute_on));
   MOCK_METHOD0(NodesChanged, void());
   MOCK_METHOD1(ActiveOutputNodeChanged, void(uint64_t node_id));
   MOCK_METHOD1(ActiveInputNodeChanged, void(uint64_t node_id));
+  MOCK_METHOD2(OutputNodeVolumeChanged, void(uint64_t node_id, int volume));
 };
 
 // Expect the reader to be empty.
 void ExpectNoArgument(dbus::MessageReader* reader) {
   EXPECT_FALSE(reader->HasMoreData());
 }
 
 // Expect the reader to have an int32_t and an array of doubles.
 void ExpectInt32AndArrayOfDoublesArguments(
     int32_t expected_value,
@@ skipping 192 matching lines @@
     // Set an expectation so mock_cras_proxy's monitoring
     // ActiveInputNodeChanged ConnectToSignal will use
     // OnConnectToActiveInputNodeChanged() to run the callback.
     EXPECT_CALL(
         *mock_cras_proxy_.get(),
         ConnectToSignal(interface_name_, cras::kActiveInputNodeChanged, _, _))
         .WillRepeatedly(
             Invoke(this,
                    &CrasAudioClientTest::OnConnectToActiveInputNodeChanged));
 
+    // Set an expectation so mock_cras_proxy's monitoring
+    // OutputNodeVolumeChanged ConnectToSignal will use
+    // OnConnectToOutputNodeVolumeChanged() to run the callback.
+    EXPECT_CALL(
+        *mock_cras_proxy_.get(),
+        ConnectToSignal(interface_name_, cras::kOutputNodeVolumeChanged, _, _))
+        .WillRepeatedly(
+            Invoke(this,
+                   &CrasAudioClientTest::OnConnectToOutputNodeVolumeChanged));
+
     // Set an expectation so mock_bus's GetObjectProxy() for the given
     // service name and the object path will return mock_cras_proxy_.
     EXPECT_CALL(*mock_bus_.get(),
                 GetObjectProxy(cras::kCrasServiceName,
                                dbus::ObjectPath(cras::kCrasServicePath)))
         .WillOnce(Return(mock_cras_proxy_.get()));
 
     // ShutdownAndBlock() will be called in TearDown().
     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
 
@@ skipping 43 matching lines @@
     ASSERT_FALSE(active_output_node_changed_handler_.is_null());
     active_output_node_changed_handler_.Run(signal);
   }
 
   // Send active input node changed signal to the tested client.
   void SendActiveInputNodeChangedSignal(dbus::Signal* signal) {
     ASSERT_FALSE(active_input_node_changed_handler_.is_null());
     active_input_node_changed_handler_.Run(signal);
   }
 
+  // Send output node volume changed signal to the tested client.
+  void SendOutputNodeVolumeChangedSignal(dbus::Signal *signal) {
+    ASSERT_FALSE(output_node_volume_changed_handler_.is_null());
+    output_node_volume_changed_handler_.Run(signal);
+  }
+
   // The interface name.
   const std::string interface_name_;
   // The client to be tested.
   std::unique_ptr<CrasAudioClient> client_;
   // A message loop to emulate asynchronous behavior.
   base::MessageLoop message_loop_;
   // The mock bus.
   scoped_refptr<dbus::MockBus> mock_bus_;
   // The mock object proxy.
   scoped_refptr<dbus::MockObjectProxy> mock_cras_proxy_;
   // The OutputMuteChanged signal handler given by the tested client.
   dbus::ObjectProxy::SignalCallback output_mute_changed_handler_;
   // The InputMuteChanged signal handler given by the tested client.
   dbus::ObjectProxy::SignalCallback input_mute_changed_handler_;
   // The NodesChanged signal handler given by the tested client.
   dbus::ObjectProxy::SignalCallback nodes_changed_handler_;
   // The ActiveOutputNodeChanged signal handler given by the tested client.
   dbus::ObjectProxy::SignalCallback active_output_node_changed_handler_;
   // The ActiveInputNodeChanged signal handler given by the tested client.
   dbus::ObjectProxy::SignalCallback active_input_node_changed_handler_;
+  // The OutputNodeVolumeChanged signal handler given by the tested client.
+  dbus::ObjectProxy::SignalCallback output_node_volume_changed_handler_;
   // The name of the method which is expected to be called.
   std::string expected_method_name_;
   // The response which the mock cras proxy returns.
   dbus::Response* response_;
   // A callback to intercept and check the method call arguments.
   ArgumentCheckCallback argument_checker_;
 
  private:
   // Checks the requested interface name and signal name.
   // Used to implement the mock cras proxy.
@@ skipping 68 matching lines @@
       const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
     active_input_node_changed_handler_ = signal_callback;
     const bool success = true;
     message_loop_.task_runner()->PostTask(FROM_HERE,
                                           base::Bind(on_connected_callback,
                                                      interface_name,
                                                      signal_name,
                                                      success));
   }
 
+  // Checks the requested interface name and signal name.
+  // Used to implement the mock cras proxy.
+  void OnConnectToOutputNodeVolumeChanged(
+      const std::string& interface_name,
+      const std::string& signal_name,
+      const dbus::ObjectProxy::SignalCallback& signal_callback,
+      const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
+    output_node_volume_changed_handler_ = signal_callback;
+    const bool success = true;
+    message_loop_.task_runner()->PostTask(FROM_HERE,
+                                          base::Bind(on_connected_callback,
+                                                     interface_name,
+                                                     signal_name,
+                                                     success));
+  }
+
   // Checks the content of the method call and returns the response.
   // Used to implement the mock cras proxy.
   void OnCallMethod(dbus::MethodCall* method_call,
                     int timeout_ms,
                     const dbus::ObjectProxy::ResponseCallback& response) {
     EXPECT_EQ(interface_name_, method_call->GetInterface());
     EXPECT_EQ(expected_method_name_, method_call->GetMember());
     dbus::MessageReader reader(method_call);
     argument_checker_.Run(&reader);
     message_loop_.task_runner()->PostTask(
@@ skipping 145 matching lines @@
   // Remove the observer.
   client_->RemoveObserver(&observer);
   EXPECT_CALL(observer, ActiveInputNodeChanged(_)).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendActiveInputNodeChangedSignal(&signal);
 
   message_loop_.RunUntilIdle();
 }
 
+TEST_F(CrasAudioClientTest, OutputNodeVolumeChanged) {
+  const uint64_t kNodeId = 20003;
+  const int32_t volume = 82;
+  // Create a signal
+  dbus::Signal signal(cras::kCrasControlInterface,
+                      cras::kOutputNodeVolumeChanged);
+  dbus::MessageWriter writer(&signal);
+  writer.AppendUint64(kNodeId);
+  writer.AppendInt32(volume);
+
+  // Set expectations
+  MockObserver observer;
+  EXPECT_CALL(observer, OutputNodeVolumeChanged(kNodeId, volume)).Times(1);
+
+  // Add the observer.
+  client_->AddObserver(&observer);
+
+  // Run the signal callback.
+  SendOutputNodeVolumeChangedSignal(&signal);
+
+  // Remove the observer.
+  client_->RemoveObserver(&observer);
+  EXPECT_CALL(observer, OutputNodeVolumeChanged(_, _)).Times(0);
+
+  // Run the signal callback again and make sure the observer isn't called.
+  SendOutputNodeVolumeChangedSignal(&signal);
+
+  message_loop_.RunUntilIdle();
+}
+
 TEST_F(CrasAudioClientTest, GetNodes) {
   // Create the expected value.
   AudioNodeList expected_node_list;
   expected_node_list.push_back(kInternalSpeaker);
   expected_node_list.push_back(kInternalMic);
 
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
   WriteNodesToResponse(writer, expected_node_list);
@@ skipping 199 matching lines @@
                                   kMixer),
                        response.get());
 
   // Call method.
   client_->SetGlobalOutputChannelRemix(kChannels, kMixer);
   // Run the message loop.
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace chromeos