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 {
+const char kWebContentsCaptureScheme[] = "web-contents-media-stream://";
+static char kEnableThrottlingFlag[] = "throttling=auto";

[miu, 2016/09/12 23:13:12]

C++11 update: Please make these new strings constexpr's instead:

  constexpr char kEnableThrottlingFlag[] = "throttling=auto";
  constexpr char kDisableLocalEchoFlag[] = "local_echo=false";
  ...

(Note: kWebContenstCaptureScheme cannot be a constexpr because storage must be
allocated for external use. The rest are internally used within this .cc file.)

[qiangchen, 2016/09/13 21:46:57]

Done.

I think we can constexpr for kWebContentsCaptureScheme, because no other files
access it.

+static char kMuteSourceFlag[] = "mute_source=true";
+static char kOptionStart[] = "?";

[miu, 2016/09/12 23:13:12]

For the separators, use a char instead of a char[]. This reduces space and
run-time overhead:

  constexpr char kOptionStart = '?';
  constexpr char kOptionSeparator = '&';

[qiangchen, 2016/09/13 21:46:57]

Done.

+static char kOptionSeparator[] = "&";
+
+bool ExtractTabCaptureTarget(const std::string& device_id_param,
+                             int* render_process_id,
+                             int* main_render_frame_id) {
+  const std::string device_scheme = kWebContentsCaptureScheme;
+  if (!base::StartsWith(device_id_param, device_scheme,
+                        base::CompareCase::SENSITIVE))
+    return false;
+
+  const std::string device_id = device_id_param.substr(device_scheme.size());
+
+  const size_t sep_pos = device_id.find(':');
+  if (sep_pos == std::string::npos)
+    return false;
+
+  const base::StringPiece component1(device_id.data(), sep_pos);
+  size_t end_pos = device_id.find('?');
+  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));
+}
+
+bool ExtractOptions(const std::string& device_id,
+                    bool* auto_throttling,
+                    bool* mute_source) {
+  // 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).
+  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
+
 namespace content {
-const char kWebContentsCaptureScheme[] = "web-contents-media-stream://";
-static char kEnableThrottlingFlag[] = "?throttling=auto";
 
 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;

[miu, 2016/09/12 23:13:12]

Just char (see prior comment).

[qiangchen, 2016/09/13 21:46:57]

Done.

+  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) {
+bool WebContentsMediaCaptureId::TryParse(const std::string& str,
+                                         WebContentsMediaCaptureId* output_id) {
   int render_process_id;
   int main_render_frame_id;
   if (!ExtractTabCaptureTarget(str, &render_process_id, &main_render_frame_id))
-    return WebContentsMediaCaptureId();
+    return false;
 
-  return WebContentsMediaCaptureId(render_process_id, main_render_frame_id,
-                                   IsAutoThrottlingOptionSet(str));
+  bool auto_throttling, mute_source;
+  if (!ExtractOptions(str, &auto_throttling, &mute_source))
+    return false;
+
+  if (output_id) {
+    output_id->render_process_id = render_process_id;
+    output_id->main_render_frame_id = main_render_frame_id;
+    output_id->enable_auto_throttling = auto_throttling;
+    output_id->mute_source = mute_source;
+  }
+
+  return true;
 }
 
-// static
-bool WebContentsMediaCaptureId::IsWebContentsDeviceId(
-    const std::string& device_id) {
-  int ignored;
-  return ExtractTabCaptureTarget(device_id, &ignored, &ignored);
-}
-
-// static
-bool WebContentsMediaCaptureId::ExtractTabCaptureTarget(
-    const std::string& device_id_param,
-    int* render_process_id,
-    int* main_render_frame_id) {
-  const std::string device_scheme = kWebContentsCaptureScheme;
-  if (!base::StartsWith(device_id_param, device_scheme,
-                        base::CompareCase::SENSITIVE))
-    return false;
-
-  const std::string device_id = device_id_param.substr(device_scheme.size());
-
-  const size_t sep_pos = device_id.find(':');
-  if (sep_pos == std::string::npos)
-    return false;
-
-  const base::StringPiece component1(device_id.data(), sep_pos);
-  size_t end_pos = device_id.find('?');
-  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) {
-  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;
-}
 
 }  // namespace content