16 bpp video stream capture, render and createImageBitmap(video) using (CPU) shared memory buffers

content/browser/webrtc/webrtc_getusermedia_browsertest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/test/trace_event_analyzer.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/webrtc/webrtc_content_browsertest_base.h"
 #include "content/browser/webrtc/webrtc_internals.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
+#include "media/base/media_switches.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/perf/perf_test.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using trace_analyzer::TraceAnalyzer;
 using trace_analyzer::Query;
 using trace_analyzer::TraceEventVector;
 
 namespace {
 
 static const char kGetUserMediaAndStop[] = "getUserMediaAndStop";
 static const char kGetUserMediaAndGetStreamUp[] = "getUserMediaAndGetStreamUp";
 static const char kGetUserMediaAndAnalyseAndStop[] =
     "getUserMediaAndAnalyseAndStop";
 static const char kGetUserMediaAndExpectFailure[] =
     "getUserMediaAndExpectFailure";
 static const char kRenderSameTrackMediastreamAndStop[] =
     "renderSameTrackMediastreamAndStop";
 static const char kRenderClonedMediastreamAndStop[] =
     "renderClonedMediastreamAndStop";
 static const char kRenderClonedTrackMediastreamAndStop[] =
     "renderClonedTrackMediastreamAndStop";
 static const char kRenderDuplicatedMediastreamAndStop[] =
     "renderDuplicatedMediastreamAndStop";
+static const char kGetDepthStreamAndCallCreateImageBitmap[] =
+    "getDepthStreamAndCallCreateImageBitmap";
 
 // Results returned by JS.
 static const char kOK[] = "OK";
 
 std::string GenerateGetUserMediaWithMandatorySourceID(
     const std::string& function_name,
     const std::string& audio_source_id,
     const std::string& video_source_id) {
   const std::string audio_constraint =
       "audio: {mandatory: { sourceId:\"" + audio_source_id + "\"}}, ";
@@ skipping 25 matching lines @@
   const std::string video_constraint =
       "video: { mandatory: { chromeMediaSource:'screen' }}";
   return function_name + "({" + audio_constraint + video_constraint + "});";
 }
 
 bool VerifyDisableLocalEcho(bool expect_value,
                             const content::StreamControls& controls) {
   return expect_value == controls.disable_local_echo;
 }
 
+void RemoveSwitchFromCommandLine(base::CommandLine* command_line,
+                                 const std::string& switch_value) {
+  base::CommandLine::StringVector argv = command_line->argv();
+  const base::CommandLine::StringType switch_string =
+#if defined(OS_WIN)
+      base::ASCIIToUTF16(switch_value);
+#else
+      switch_value;
+#endif
+  argv.erase(std::remove_if(
+                 argv.begin(), argv.end(),
+                 [switch_string](const base::CommandLine::StringType& value) {
+                   return value.find(switch_string) != std::string::npos;
+                 }),
+             argv.end());
+  command_line->InitFromArgv(argv);
+}
+
 }  // namespace
 
 namespace content {
 
 class WebRtcGetUserMediaBrowserTest : public WebRtcContentBrowserTestBase {
  public:
   WebRtcGetUserMediaBrowserTest() : trace_log_(NULL) {
     // Automatically grant device permission.
     AppendUseFakeUIForMediaStreamFlag();
   }
   ~WebRtcGetUserMediaBrowserTest() override {}
 
+  void SetUpCommandLine(base::CommandLine* command_line) override {

[aleksandar.stojiljkovic, 2016/10/30 11:08:39]

avi@chromium.org,
This change came after LGTM when rebasing to split fake-video-capture-device CL
.
Initially, I thought it is good idea to set it for all in the file here [1], but
after seeing that it also requires Android test changes here [2] which scope is
wider, decided to control it and limit the affect to test here only.
Is the LGTM still valid?
Thanks.

[1] Abandoned approach for Win/OSX, Linux:
https://codereview.chromium.org/2428263004/patch/160001/170012

[2] Didn't think it is good idea to set
 "--use-fake-device-for-media-stream=device-count=2"
for Android here:
https://cs.chromium.org/chromium/src/testing/android/native_test/java/src/org...




 

+    // Test using two video capture devices - a color and a 16-bit depth device.
+    // By default, command line argument is present with no value.  We need to
+    // remove it and then add the value defining two video capture devices.
+    const std::string fake_device_switch =
+        switches::kUseFakeDeviceForMediaStream;

[phoglund_chromium, 2016/11/02 10:56:57]

Well, your new test does appear to use getUserMedia, so you're in the right
place. I dislike adding this much complexity to this file for just one test
though; all the other tests in this file use normal fake devices. 

Could you extract this new test to a new test class for testing 16-bit devices?
We've been trying to split browser tests into smaller files lately, to keep the
individual tests simple. I think you get most of what you need through the base
class anyway. Similarly, I think it's easy to create a new .html
(getusermedia-16bit.html?) which includes webrtc_test_utilities.js and your new
test utilities.

You can see in
https://cs.chromium.org/chromium/src/content/browser/webrtc/webrtc_ip_permiss...
that we've done this before; if a test requires exotic flags, make a new test
class instead of shoehorning into the main test class.

[aleksandar.stojiljkovic, 2016/11/02 13:46:44]

Done.
Good idea - there are more tests coming and better to split.
Changed the name to depth-capture as there's also 8-bit format in pipeline.

+    ASSERT_TRUE(command_line->HasSwitch(fake_device_switch) &&
+                command_line->GetSwitchValueASCII(fake_device_switch).empty());
+    RemoveSwitchFromCommandLine(command_line, fake_device_switch);
+    command_line->AppendSwitchASCII(fake_device_switch, "device-count=2");
+    WebRtcContentBrowserTestBase::SetUpCommandLine(command_line);
+  }
+
   void StartTracing() {
     CHECK(trace_log_ == NULL) << "Can only can start tracing once";
     trace_log_ = base::trace_event::TraceLog::GetInstance();
     base::trace_event::TraceConfig trace_config(
         "video", base::trace_event::RECORD_UNTIL_FULL);
     trace_log_->SetEnabled(trace_config,
                            base::trace_event::TraceLog::RECORDING_MODE);
     // Check that we are indeed recording.
     EXPECT_EQ(trace_log_->GetNumTracesRecorded(), 1);
   }
@@ skipping 217 matching lines @@
 
   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
   NavigateToURL(shell(), url);
 
   ExecuteJavascriptAndWaitForOk(
       base::StringPrintf("%s({video: true});",
                           kRenderDuplicatedMediastreamAndStop));
 }
 
 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
+                       GetDepthStreamAndCallCreateImageBitmap) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
+  NavigateToURL(shell(), url);
+
+  ExecuteJavascriptAndWaitForOk(base::StringPrintf(
+      "%s({video: true});", kGetDepthStreamAndCallCreateImageBitmap));
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
                        GetAudioAndVideoStreamAndStop) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
   NavigateToURL(shell(), url);
 
   ExecuteJavascriptAndWaitForOk(base::StringPrintf(
       "%s({video: true, audio: true});", kGetUserMediaAndStop));
 }
 
@@ skipping 407 matching lines @@
       base::Bind(&VerifyDisableLocalEcho, true));
   call = GenerateGetUserMediaWithDisableLocalEcho(
       "getUserMediaAndExpectSuccess", "true");
   ExecuteJavascriptAndWaitForOk(call);
 
   manager->SetGenerateStreamCallbackForTesting(
       MediaStreamManager::GenerateStreamTestCallback());
 }
 
 }  // namespace content