Let Contraints Controll Mute/Unmute Audio Local Playback For Desktop Sharing

content/public/browser/web_contents_media_capture_id.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 "content/public/browser/web_contents_media_capture_id.h"
 
 #include <tuple>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 
 namespace content {
 const char kWebContentsCaptureScheme[] = "web-contents-media-stream://";
-static char kEnableThrottlingFlag[] = "?throttling=auto";
+static char kEnableThrottlingFlag[] = "throttling=auto";
+static char kMuteSourceFlag[] = "mute_source=true";
+static char kOptionStart[] = "?";
+static char kOptionSeparator[] = "&";
 
 bool WebContentsMediaCaptureId::operator<(
     const WebContentsMediaCaptureId& other) const {
   return std::tie(render_process_id, main_render_frame_id,
-                  enable_auto_throttling) <
+                  enable_auto_throttling, mute_source) <
          std::tie(other.render_process_id, other.main_render_frame_id,
-                  other.enable_auto_throttling);
+                  other.enable_auto_throttling, other.mute_source);
 }
 
 bool WebContentsMediaCaptureId::operator==(
     const WebContentsMediaCaptureId& other) const {
   return std::tie(render_process_id, main_render_frame_id,
-                  enable_auto_throttling) ==
+                  enable_auto_throttling, mute_source) ==
          std::tie(other.render_process_id, other.main_render_frame_id,
-                  other.enable_auto_throttling);
+                  other.enable_auto_throttling, other.mute_source);
 }
 
 bool WebContentsMediaCaptureId::is_null() const {
   return (render_process_id < 0) || (main_render_frame_id < 0);
 }
 
 std::string WebContentsMediaCaptureId::ToString() const {
   std::string s = kWebContentsCaptureScheme;
   s.append(base::Int64ToString(render_process_id));
   s.append(":");
   s.append(base::Int64ToString(main_render_frame_id));
 
-  if (enable_auto_throttling)
+  char* connector = kOptionStart;
+  if (enable_auto_throttling) {
+    s.append(connector);
     s.append(kEnableThrottlingFlag);
+    connector = kOptionSeparator;
+  }
+
+  if (mute_source) {
+    s.append(connector);
+    s.append(kMuteSourceFlag);
+    connector = kOptionSeparator;
+  }
 
   return s;
 }
 
 // static
 WebContentsMediaCaptureId WebContentsMediaCaptureId::Parse(
     const std::string& str) {
   int render_process_id;
   int main_render_frame_id;
   if (!ExtractTabCaptureTarget(str, &render_process_id, &main_render_frame_id))
     return WebContentsMediaCaptureId();
 
+  bool auto_throttling, mute_source;
+  ExtractOptions(str, &auto_throttling, &mute_source);
   return WebContentsMediaCaptureId(render_process_id, main_render_frame_id,
-                                   IsAutoThrottlingOptionSet(str));
+                                   auto_throttling, mute_source);
 }
 
 // static
 bool WebContentsMediaCaptureId::IsWebContentsDeviceId(
     const std::string& device_id) {
   int ignored;
   return ExtractTabCaptureTarget(device_id, &ignored, &ignored);
 }
 
 // static
@@ skipping 17 matching lines @@
   if (end_pos == std::string::npos)
     end_pos = device_id.length();
   const base::StringPiece component2(device_id.data() + sep_pos + 1,
                                      end_pos - sep_pos - 1);
 
   return (base::StringToInt(component1, render_process_id) &&
           base::StringToInt(component2, main_render_frame_id));
 }
 
 // static
-bool WebContentsMediaCaptureId::IsAutoThrottlingOptionSet(
-    const std::string& device_id) {
+bool WebContentsMediaCaptureId::ExtractOptions(const std::string& device_id,
+                                               bool* auto_throttling,
+                                               bool* mute_source) {
   if (!IsWebContentsDeviceId(device_id))
     return false;
 
   // Find the option part of the string and just do a naive string compare since
   // there are no other options in the |device_id| to account for (at the time
   // of this writing).
-  const size_t option_pos = device_id.find('?');
-  if (option_pos == std::string::npos)
-    return false;
-  const base::StringPiece component(device_id.data() + option_pos,
-                                    device_id.length() - option_pos);
-  return component.compare(kEnableThrottlingFlag) == 0;
+  size_t option_pos = device_id.find(kOptionStart);
+  if (option_pos == std::string::npos) {
+    if (auto_throttling)
+      *auto_throttling = false;
+    if (mute_source)
+      *mute_source = false;
+    return true;
+  }
+
+  size_t option_pos_end;
+  while (option_pos < device_id.length()) {
+    option_pos_end = device_id.find(kOptionSeparator, option_pos + 1);
+    if (option_pos_end == std::string::npos)
+      option_pos_end = device_id.length();
+    const base::StringPiece component(device_id.data() + option_pos + 1,
+                                      option_pos_end - option_pos - 1);
+
+    if (auto_throttling && component.compare(kEnableThrottlingFlag) == 0)
+      *auto_throttling = true;
+    if (mute_source && component.compare(kMuteSourceFlag) == 0)
+      *mute_source = true;
+
+    option_pos = option_pos_end;
+  }
+  return true;
 }
 
 }  // namespace content