Revert of Add groupid for media devices. Group audio devices. (patchset #5...

Revert of Add groupid for media devices. Group audio devices. (patchset #5 id:80001 of https://codereview.chromium.org/2273653002/ )

Reason for revert:
Breaks webrtc FYI bots on mac https://build.chromium.org/p/chromium.webrtc/builders/Mac%20Tester/builds/59143. I'll have to figure out what's up with that ¯\_(ツ)_/¯

Original issue's description:
> Add groupid for media devices. Group audio devices.
>
> At present, the renderer tries to use matched_output_device
> to assign groupids to audio devices. matched_output_device isn't set
> before devices are sent to the renderer, and we wouldn't be able to
> handle all the cases with it anyways.
>
> BUG=636300, 627793
>
> Committed: https://crrev.com/f07d1047986130ef0277a87b5b0b6175c4362c98
> Cr-Commit-Position: refs/heads/master@{#416140}

TBR=guidou@chromium.org,tommi@chromium.org,nasko@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=636300, 627793

Review-Url: https://codereview.chromium.org/2296393004
Cr-Commit-Position: refs/heads/master@{#416217}

content/browser/renderer_host/media/audio_input_device_manager.cc

@@ -180,10 +180,6 @@ void AudioInputDeviceManager::EnumerateOnDeviceThread(
     devices->push_back(StreamDeviceInfo(
         stream_type, it->device_name, it->unique_id));
   }
-  for (StreamDeviceInfo& device_info : *devices) {
-    device_info.device.group_id =
-        audio_manager_->GetGroupIDInput(device_info.device.id);
-  }
 
   // Return the device list through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.

content/browser/renderer_host/media/media_stream_manager.cc

@@ -767,8 +767,6 @@ void MediaStreamManager::AudioOutputDevicesEnumerated(
     for (const auto& entry : device_enumeration.devices) {
       StreamDeviceInfo device_info(MEDIA_DEVICE_AUDIO_OUTPUT, entry.device_name,
                                    entry.unique_id);
-      device_info.device.group_id =
-          audio_manager_->GetGroupIDOutput(device_info.device.id);
       device_infos.push_back(device_info);
     }
   }
@@ -1042,9 +1040,6 @@ void MediaStreamManager::TranslateDeviceIdToSourceId(
       request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
     device->id = GetHMACForMediaDeviceID(request->salt,
                                          request->security_origin, device->id);
-    if (!device->group_id.empty())
-      device->group_id = GetHMACForMediaDeviceID(
-          request->salt, request->security_origin, device->group_id);
   }
 }
 

content/common/media/media_stream_messages.h

@@ -43,7 +43,6 @@ IPC_STRUCT_TRAITS_BEGIN(content::StreamDeviceInfo)
   IPC_STRUCT_TRAITS_MEMBER(device.type)
   IPC_STRUCT_TRAITS_MEMBER(device.name)
   IPC_STRUCT_TRAITS_MEMBER(device.id)
-  IPC_STRUCT_TRAITS_MEMBER(device.group_id)
   IPC_STRUCT_TRAITS_MEMBER(device.video_facing)
   IPC_STRUCT_TRAITS_MEMBER(device.matched_output_device_id)
   IPC_STRUCT_TRAITS_MEMBER(device.input.sample_rate)

content/public/common/media_stream_request.h

@@ -129,11 +129,6 @@ struct CONTENT_EXPORT MediaStreamDevice {
   // The device's "friendly" name. Not guaranteed to be unique.
   std::string name;
 
-  // A unique identifier for the physical device this device is part of.
-  // Will be hashed before being sent to renderer.
-  // TODO(maxmorin): Add support for video devices as well.
-  std::string group_id;
-
   // Contains properties that match directly with those with the same name
   // in media::AudioParameters.
   // TODO(ajm): Remove this type and use media::AudioParameters directly.

content/renderer/media/mock_media_stream_dispatcher.cc

@@ -116,10 +116,6 @@ void MockMediaStreamDispatcher::AddAudioInputDeviceToArray(
   if (matched_output) {
     audio.device.matched_output_device_id =
         kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
-    audio.device.group_id =
-        kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
-  } else {
-    audio.device.group_id = audio.device.id + "groupid";
   }
   audio.session_id = session_id_;
   audio.device.input.sample_rate = media::AudioParameters::kAudioCDSampleRate;
@@ -131,8 +127,6 @@ void MockMediaStreamDispatcher::AddAudioInputDeviceToArray(
 void MockMediaStreamDispatcher::AddAudioOutputDeviceToArray() {
   StreamDeviceInfo audio;
   audio.device.id = kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
-  audio.device.group_id =
-      kAudioOutputDeviceIdPrefix + base::IntToString(session_id_);
   audio.device.name = "speaker";
   audio.device.type = MEDIA_DEVICE_AUDIO_OUTPUT;
   audio.device.video_facing = MEDIA_VIDEO_FACING_NONE;

content/renderer/media/user_media_client_impl.cc

@@ -467,6 +467,10 @@ void UserMediaClientImpl::OnStreamGeneratedForCancelledRequest(
 
 void UserMediaClientImpl::FinalizeEnumerateDevices(
     MediaDevicesRequestInfo* request) {
+  // All devices are ready for copying. We use a hashed audio output device id
+  // as the group id for input and output audio devices. If an input device
+  // doesn't have an associated output device, we use the input device's own id.
+  // We don't support group id for video devices, that's left empty.
   blink::WebVector<blink::WebMediaDeviceInfo>
       devices(request->audio_input_devices.size() +
               request->video_input_devices.size() +
@@ -475,10 +479,19 @@ void UserMediaClientImpl::FinalizeEnumerateDevices(
     const MediaStreamDevice& device = request->audio_input_devices[i].device;
     DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE);
 
-    devices[i].initialize(blink::WebString::fromUTF8(device.id),
-                          blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
-                          blink::WebString::fromUTF8(device.name),
-                          blink::WebString::fromUTF8(device.group_id));
+    // We add an arbitrary character to the device ID in order to avoid the same
+    // group ID for the input and output devices that share the same ID but are
+    // not in the same physical device. This may happen with the default and
+    // communication devices.
+    std::string group_id = base::UintToString(base::Hash(
+        device.matched_output_device_id.empty() ?
+            device.id + "i" :
+            device.matched_output_device_id));
+    devices[i].initialize(
+        blink::WebString::fromUTF8(device.id),
+        blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
+        blink::WebString::fromUTF8(device.name),
+        blink::WebString::fromUTF8(group_id));
   }
   size_t offset = request->audio_input_devices.size();
   for (size_t i = 0; i  < request->video_input_devices.size(); ++i) {
@@ -498,7 +511,7 @@ void UserMediaClientImpl::FinalizeEnumerateDevices(
         blink::WebString::fromUTF8(device.id),
         blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
         blink::WebString::fromUTF8(device.name),
-        blink::WebString::fromUTF8(device.group_id));
+        blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id))));
   }
 
   EnumerateDevicesSucceded(&request->media_devices_request, devices);

media/audio/audio_manager.h

@@ -241,12 +241,6 @@ class MEDIA_EXPORT AudioManager {
   virtual std::string GetAssociatedOutputDeviceID(
       const std::string& input_device_id) = 0;
 
-  // These functions assign group ids to devices based on their device ids.
-  // The default implementation is an attempt to do this based on
-  // GetAssociatedOutputDeviceID.
-  virtual std::string GetGroupIDOutput(const std::string& output_device_id) = 0;
-  virtual std::string GetGroupIDInput(const std::string& input_device_id) = 0;
-
   // Create a new AudioLog object for tracking the behavior for one or more
   // instances of the given component.  See AudioLogFactory for more details.
   virtual std::unique_ptr<AudioLog> CreateAudioLog(

media/audio/audio_manager_base.cc

@@ -345,28 +345,6 @@ std::string AudioManagerBase::GetAssociatedOutputDeviceID(
   return "";
 }
 
-std::string AudioManagerBase::GetGroupIDOutput(
-    const std::string& output_device_id) {
-  if (output_device_id == AudioDeviceDescription::kDefaultDeviceId) {
-    std::string real_device_id = GetDefaultOutputDeviceID();
-    if (!real_device_id.empty()) {
-      return real_device_id;
-    }
-  }
-  return output_device_id;
-}
-
-std::string AudioManagerBase::GetGroupIDInput(
-    const std::string& input_device_id) {
-  std::string output_device_id = GetAssociatedOutputDeviceID(input_device_id);
-  if (output_device_id.empty()) {
-    // Some characters are added to avoid accidentally
-    // giving the input the same group id as an output.
-    return input_device_id + "input";
-  }
-  return GetGroupIDOutput(output_device_id);
-}
-
 std::string AudioManagerBase::GetDefaultOutputDeviceID() {
   return "";
 }

media/audio/audio_manager_base.h

@@ -93,9 +93,6 @@ class MEDIA_EXPORT AudioManagerBase : public AudioManager {
       const std::string& device_id,
       const LogCallback& log_callback) = 0;
 
-  std::string GetGroupIDOutput(const std::string& output_device_id) override;
-  std::string GetGroupIDInput(const std::string& input_device_id) override;
-
   // Get number of input or output streams.
   int input_stream_count() const { return num_input_streams_; }
   int output_stream_count() const { return num_output_streams_; }

media/audio/audio_manager_unittest.cc

@@ -5,7 +5,6 @@
 #include "media/audio/audio_manager.h"
 
 #include <memory>
-#include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
@@ -17,6 +16,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/audio/audio_device_description.h"
+#include "media/audio/audio_manager.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_unittest_util.h"
 #include "media/audio/fake_audio_log_factory.h"
@@ -640,67 +640,4 @@ TEST_F(AudioManagerTest, GetAssociatedOutputDeviceID) {
 }
 #endif  // defined(USE_CRAS)
 
-class TestAudioManager : public FakeAudioManager {
-  // For testing the default implementation of GetGroupId(Input|Output)
-  // input$i is associated to output$i, if both exist.
-  // Default input is input1.
-  // Default output is output2.
- public:
-  TestAudioManager(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
-      AudioLogFactory* audio_log_factory)
-      : FakeAudioManager(task_runner, worker_task_runner, audio_log_factory) {}
-
-  void GetAudioInputDeviceNames(AudioDeviceNames* device_names) override {
-    device_names->emplace_back("Input 1", "input1");
-    device_names->emplace_back("Input 2", "input2");
-    device_names->emplace_back("Input 3", "input3");
-    device_names->push_front(AudioDeviceName::CreateDefault());
-  }
-
-  void GetAudioOutputDeviceNames(AudioDeviceNames* device_names) override {
-    device_names->emplace_back("Output 1", "output1");
-    device_names->emplace_back("Output 2", "output2");
-    device_names->emplace_back("Output 4", "output4");
-    device_names->push_front(AudioDeviceName::CreateDefault());
-  }
-
-  std::string GetDefaultOutputDeviceID() override { return "output4"; }
-
-  std::string GetAssociatedOutputDeviceID(
-      const std::string& input_id) override {
-    if (input_id == "input1")
-      return "output1";
-    if (input_id == "input2")
-      return "output2";
-    if (input_id == "default")
-      return "output1";
-    return "";
-  }
-};
-
-TEST_F(AudioManagerTest, GetGroupId) {
-  CreateAudioManagerForTesting<TestAudioManager>();
-  // Groups:
-  // 0: input1, output1, default input
-  // 1: input2, output2
-  // 2: input3,
-  // 3: output4, default output
-  std::vector<std::string> group;
-  group.push_back(audio_manager_->GetGroupIDInput("input1"));
-  group.push_back(audio_manager_->GetGroupIDInput("input2"));
-  group.push_back(audio_manager_->GetGroupIDInput("input3"));
-  group.push_back(audio_manager_->GetGroupIDOutput("output4"));
-  for (size_t i = 0; i < group.size(); ++i) {
-    for (size_t j = i + 1; j < group.size(); ++j) {
-      EXPECT_NE(group[i], group[j]);
-    }
-  }
-  EXPECT_EQ(group[0], audio_manager_->GetGroupIDOutput("output1"));
-  EXPECT_EQ(group[0], audio_manager_->GetGroupIDInput("default"));
-  EXPECT_EQ(group[1], audio_manager_->GetGroupIDOutput("output2"));
-  EXPECT_EQ(group[3], audio_manager_->GetGroupIDOutput("default"));
-}
-
 }  // namespace media

media/audio/mock_audio_manager.cc

@@ -92,14 +92,6 @@ std::string MockAudioManager::GetAssociatedOutputDeviceID(
   return std::string();
 }
 
-std::string MockAudioManager::GetGroupIDOutput(const std::string& output_id) {
-  return "";
-}
-
-std::string MockAudioManager::GetGroupIDInput(const std::string& input_id) {
-  return "";
-}
-
 std::unique_ptr<AudioLog> MockAudioManager::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return nullptr;

media/audio/mock_audio_manager.h

@@ -56,8 +56,6 @@ class MockAudioManager : public media::AudioManager {
       const std::string& device_id) override;
   std::string GetAssociatedOutputDeviceID(
       const std::string& input_device_id) override;
-  std::string GetGroupIDOutput(const std::string& output_id) override;
-  std::string GetGroupIDInput(const std::string& input_id) override;
 
   std::unique_ptr<AudioLog> CreateAudioLog(
       AudioLogFactory::AudioComponent component) override;