Filter goog constraints in tabCapture API.

chrome/browser/extensions/api/tab_capture/tab_capture_api.cc

 // Copyright (c) 2012 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.
 
 // Implements the Chrome Extensions Tab Capture API.
 
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_api.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 57 matching lines @@
 const char kEnableAutoThrottlingKey[] = "enableAutoThrottling";
 
 bool OptionsSpecifyAudioOrVideo(const TabCapture::CaptureOptions& options) {
   return (options.audio && *options.audio) || (options.video && *options.video);
 }
 
 bool IsAcceptableOffscreenTabUrl(const GURL& url) {
   return url.is_valid() && (url.SchemeIsHTTPOrHTTPS() || url.SchemeIs("data"));
 }
 
+// Removes all mandatory and optional constraint entries that start with the
+// "goog" prefix.  These are never needed and may cause the renderer-side
+// getUserMedia() call to fail.  http://crbug.com/579729
+//
+// TODO(miu): Remove once tabCapture API is migrated to new constraints spec.
+// http://crbug.com/579729
+void FilterDeprecatedGoogConstraints(TabCapture::CaptureOptions* options) {
+  const auto FilterGoogKeysFromDictionary = [](base::DictionaryValue* dict) {
+    std::vector<std::string> bad_keys;
+    base::DictionaryValue::Iterator it(*dict);
+    for (; !it.IsAtEnd(); it.Advance()) {
+      if (it.key().find("goog") == 0)
+        bad_keys.push_back(it.key());
+    }
+    for (const std::string& k : bad_keys) {
+      scoped_ptr<base::Value> ignored;
+      dict->RemoveWithoutPathExpansion(k, &ignored);
+    }
+  };
+
+  if (options->audio_constraints) {
+    FilterGoogKeysFromDictionary(
+        &options->audio_constraints->mandatory.additional_properties);
+    if (options->audio_constraints->optional) {
+      FilterGoogKeysFromDictionary(
+          &options->audio_constraints->optional->additional_properties);
+    }
+  }
+
+  if (options->video_constraints) {
+    FilterGoogKeysFromDictionary(
+        &options->video_constraints->mandatory.additional_properties);
+    if (options->video_constraints->optional) {
+      FilterGoogKeysFromDictionary(
+          &options->video_constraints->optional->additional_properties);
+    }
+  }
+}
+
 // Add Chrome-specific source identifiers to the MediaStreamConstraints objects
 // in |options| to provide references to the |target_contents| to be captured.
 void AddMediaStreamSourceConstraints(content::WebContents* target_contents,
                                      TabCapture::CaptureOptions* options) {
   DCHECK(options);
   DCHECK(target_contents);
 
   MediaStreamConstraint* constraints_to_modify[2] = { nullptr, nullptr };
 
   if (options->audio && *options->audio) {
@@ skipping 113 matching lines @@
     return false;
   }
 
   TabCaptureRegistry* registry = TabCaptureRegistry::Get(GetProfile());
   if (!registry->AddRequest(target_contents, extension_id, false)) {
     // TODO(miu): Allow multiple consumers of single tab capture.
     // http://crbug.com/535336
     error_ = kCapturingSameTab;
     return false;
   }
+  FilterDeprecatedGoogConstraints(&params->options);
   AddMediaStreamSourceConstraints(target_contents, &params->options);
 
   // At this point, everything is set up in the browser process.  It's now up to
   // the custom JS bindings in the extension's render process to request a
   // MediaStream using navigator.webkitGetUserMedia().  The result dictionary,
   // passed to SetResult() here, contains the extra "hidden options" that will
   // allow the Chrome platform implementation for getUserMedia() to start the
   // virtual audio/video capture devices and set up all the data flows.  The
   // custom JS bindings can be found here:
   // chrome/renderer/resources/extensions/tab_capture_custom_bindings.js
@@ skipping 58 matching lines @@
     return false;
   }
 
   if (!TabCaptureRegistry::Get(browser_context())->AddRequest(
           offscreen_tab->web_contents(), extension()->id(), true)) {
     // TODO(miu): Allow multiple consumers of single tab capture.
     // http://crbug.com/535336
     SetError(kCapturingSameOffscreenTab);
     return false;
   }
+  FilterDeprecatedGoogConstraints(&params->options);
   AddMediaStreamSourceConstraints(offscreen_tab->web_contents(),
                                   &params->options);
 
   // At this point, everything is set up in the browser process.  It's now up to
   // the custom JS bindings in the extension's render process to complete the
   // request.  See the comment at end of TabCaptureCaptureFunction::RunSync()
   // for more details.
   base::DictionaryValue* const result = new base::DictionaryValue();
   result->MergeDictionary(params->options.ToValue().get());
   SetResult(result);
@@ skipping 43 matching lines @@
     }
   }
 
   // No maximum size was provided, so just return the default size bounded by
   // the minimum size.
   return gfx::Size(std::max(kDefaultWidth, min_size.width()),
                    std::max(kDefaultHeight, min_size.height()));
 }
 
 }  // namespace extensions