Handle audio node stable device ID change

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 15 matching lines @@
 namespace chromeos {
 
 namespace {
 
 // Audio nodes for GetNodes unit test.
 const uint64_t kInternalSpeakerId = 10001;
 const uint64_t kInternalMicId = 20001;
 
 const AudioNode kInternalSpeaker(false,
                                  kInternalSpeakerId,
-                                 kInternalSpeakerId,
+                                 false /* has_v2_stable_device_id */,
+                                 kInternalSpeakerId /* stable_device_id_v1 */,
+                                 0 /* stable_device_id_v2 */,
                                  "Fake Speaker",
                                  "INTERNAL_SPEAKER",
                                  "Speaker",
                                  false,
                                  0);
 
 const AudioNode kInternalMic(true,
                              kInternalMicId,
-                             kInternalMicId,
+                             false /* has_v2_stable_device_id */,
+                             kInternalMicId /* stable_device_id_v1*/,
+                             0 /* stable_device_id_v2 */,
                              "Fake Mic",
                              "INTERNAL_MIC",
                              "Internal Mic",
                              false,
                              0);
+
+const AudioNode kInternalSpeakerV2(
+    false,
+    kInternalSpeakerId,
+    true /* has_v2_stable_device_id */,
+    kInternalSpeakerId /* stable_device_id_v1 */,
+    // stable_device_id_v2: XOR to make sure the
+    // ID is different from |stable_device_id_v1|.
+    kInternalSpeakerId ^ 0xFF,
+    "Fake Speaker",
+    "INTERNAL_SPEAKER",
+    "Speaker",
+    false,
+    0);
+
+const AudioNode kInternalMicV2(true,
+                               kInternalMicId,
+                               true /* has_v2_stable_device_id */,
+                               kInternalMicId /* stable_device_id_v1 */,
+                               // XOR to make sure the ID is different from
+                               // |stable_device_id_v1|.
+                               kInternalMicId ^ 0xFF /* stable_device_id_v2 */,
+                               "Fake Mic",
+                               "INTERNAL_MIC",
+                               "Internal Mic",
+                               false,
+                               0);
+
 // A mock ErrorCallback.
 class MockErrorCallback {
  public:
   MockErrorCallback() {}
   ~MockErrorCallback() {}
   MOCK_METHOD2(Run, void(const std::string& error_name,
                          const std::string& error_message));
   CrasAudioClient::ErrorCallback GetCallback() {
     return base::Bind(&MockErrorCallback::Run, base::Unretained(this));
   }
@@ skipping 111 matching lines @@
     sub_writer.OpenDictEntry(&entry_writer);
     entry_writer.AppendString(cras::kPluggedTimeProperty);
     entry_writer.AppendVariantOfUint64(node_list[i].plugged_time);
     sub_writer.CloseContainer(&entry_writer);
     sub_writer.OpenDictEntry(&entry_writer);
     entry_writer.AppendString(cras::kMicPositionsProperty);
     entry_writer.AppendVariantOfString(node_list[i].mic_positions);
     sub_writer.CloseContainer(&entry_writer);
     sub_writer.OpenDictEntry(&entry_writer);
     entry_writer.AppendString(cras::kStableDeviceIdProperty);
-    entry_writer.AppendVariantOfUint64(node_list[i].stable_device_id);
+    entry_writer.AppendVariantOfUint64(node_list[i].stable_device_id_v1);
+    if (node_list[i].has_v2_stable_device_id) {
+      entry_writer.AppendString(cras::kStableDeviceIdNewProperty);
+      entry_writer.AppendVariantOfUint64(node_list[i].stable_device_id_v2);
+    }
     sub_writer.CloseContainer(&entry_writer);
     writer.CloseContainer(&sub_writer);
   }
 }
 
 // Expect the AudioNodeList result.
 void ExpectAudioNodeListResult(const AudioNodeList* expected_node_list,
                                const AudioNodeList& node_list,
                                bool call_status) {
   EXPECT_EQ(true, call_status);
   EXPECT_EQ(expected_node_list->size(), node_list.size());
   for (size_t i = 0; i < node_list.size(); ++i) {
     EXPECT_EQ((*expected_node_list)[i].is_input, node_list[i].is_input);
     EXPECT_EQ((*expected_node_list)[i].id, node_list[i].id);
-    EXPECT_EQ((*expected_node_list)[i].stable_device_id,
-              node_list[i].stable_device_id);
+    EXPECT_EQ((*expected_node_list)[i].stable_device_id_v1,
+              node_list[i].stable_device_id_v1);
+    EXPECT_EQ((*expected_node_list)[i].stable_device_id_v2,
+              node_list[i].stable_device_id_v2);
     EXPECT_EQ((*expected_node_list)[i].device_name, node_list[i].device_name);
     EXPECT_EQ((*expected_node_list)[i].type, node_list[i].type);
     EXPECT_EQ((*expected_node_list)[i].name, node_list[i].name);
     EXPECT_EQ((*expected_node_list)[i].mic_positions,
               node_list[i].mic_positions);
     EXPECT_EQ((*expected_node_list)[i].active, node_list[i].active);
     EXPECT_EQ((*expected_node_list)[i].plugged_time, node_list[i].plugged_time);
+    EXPECT_EQ((*expected_node_list)[i].StableDeviceIdVersion(),
+              node_list[i].StableDeviceIdVersion());
   }
 }
 
 }  // namespace
 
 class CrasAudioClientTest : public testing::Test {
  public:
   CrasAudioClientTest() : interface_name_(cras::kCrasControlInterface),
                           response_(nullptr) {}
 
@@ skipping 485 matching lines @@
   // Call method.
   MockErrorCallback error_callback;
   client_->GetNodes(base::Bind(&ExpectAudioNodeListResult,
                                &expected_node_list),
                     error_callback.GetCallback());
   EXPECT_CALL(error_callback, Run(_, _)).Times(0);
   // Run the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_F(CrasAudioClientTest, GetNodesV2) {
+  // Create the expected value.
+  AudioNodeList expected_node_list;
+  expected_node_list.push_back(kInternalSpeakerV2);
+  expected_node_list.push_back(kInternalMicV2);
+
+  // Create response.
+  std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  WriteNodesToResponse(writer, expected_node_list);
+
+  // Set expectations.
+  PrepareForMethodCall(cras::kGetNodes, base::Bind(&ExpectNoArgument),
+                       response.get());
+  // Call method.
+  MockErrorCallback error_callback;
+  client_->GetNodes(base::Bind(&ExpectAudioNodeListResult, &expected_node_list),
+                    error_callback.GetCallback());
+  EXPECT_CALL(error_callback, Run(_, _)).Times(0);
+  // Run the message loop.
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_F(CrasAudioClientTest, SetOutputNodeVolume) {
   const uint64_t kNodeId = 10003;
   const int32_t kVolume = 80;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetOutputNodeVolume,
                        base::Bind(&ExpectUint64AndInt32Arguments,
                                   kNodeId,
@@ skipping 174 matching lines @@
                                   kMixer),
                        response.get());
 
   // Call method.
   client_->SetGlobalOutputChannelRemix(kChannels, kMixer);
   // Run the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace chromeos