Wire up MediaCapabilities is_supported to MimeUtil

media/blink/webmediacapabilitiesclient_impl.cc

 // Copyright 2017 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 "media/blink/webmediacapabilitiesclient_impl.h"
 
+#include "media/base/mime_util.h"
+#include "third_party/WebKit/public/platform/modules/media_capabilities/WebAudioConfiguration.h"
 #include "third_party/WebKit/public/platform/modules/media_capabilities/WebMediaCapabilitiesInfo.h"
+#include "third_party/WebKit/public/platform/modules/media_capabilities/WebMediaConfiguration.h"
+#include "third_party/WebKit/public/platform/modules/media_capabilities/WebVideoConfiguration.h"
 
 namespace media {
 
 WebMediaCapabilitiesClientImpl::WebMediaCapabilitiesClientImpl() = default;
 
 WebMediaCapabilitiesClientImpl::~WebMediaCapabilitiesClientImpl() = default;
 
 void WebMediaCapabilitiesClientImpl::DecodingInfo(
     const blink::WebMediaConfiguration& configuration,
     std::unique_ptr<blink::WebMediaCapabilitiesQueryCallbacks> callbacks) {
-  // TODO(chcunningham, mlamouri): this is a dummy implementation that returns
-  // true for all the fields.
   std::unique_ptr<blink::WebMediaCapabilitiesInfo> info(
       new blink::WebMediaCapabilitiesInfo());
-  info->supported = true;
-  info->smooth = true;
-  info->power_efficient = true;
+
+  SupportsType audio_support = IsSupported;
+  SupportsType video_support = IsSupported;
+
+  if (configuration.audio_configuration.has_value()) {

[mlamouri (slow - plz ping), 2017/04/25 12:48:43]

nit: up to you but you can drop |has_value()| FWIW

[chcunningham, 2017/04/25 20:53:51]

Done.

+    const blink::WebAudioConfiguration& audio_config =
+        configuration.audio_configuration.value();
+    std::vector<std::string> codec_vector;
+    SplitCodecsToVector(audio_config.codec.Ascii(), &codec_vector, false);
+
+    // TODO(chcunningham): Update to throw exception pending outcome of
+    // https://github.com/WICG/media-capabilities/issues/32
+    DCHECK_LE(codec_vector.size(), 1U);

[mlamouri (slow - plz ping), 2017/04/25 12:48:43]

I think we should implement the parsing on Blink so exceptions wouldn't have to
happen from media/

[chcunningham, 2017/04/25 20:53:51]

ACK. Will follow up. See my earlier comment about move being non-trivial. Will
evaluate full move vs just doing some simple parsing in blink for purpose of
this exception.

+
+    audio_support =
+        IsSupportedMediaFormat(audio_config.mime_type.Ascii(), codec_vector);
+  }
+
+  if (configuration.video_configuration.has_value()) {
+    const blink::WebVideoConfiguration& video_config =
+        configuration.video_configuration.value();
+    std::vector<std::string> codec_vector;
+    SplitCodecsToVector(video_config.codec.Ascii(), &codec_vector, false);
+
+    // TODO(chcunningham): Update to throw exception pending outcome of
+    // https://github.com/WICG/media-capabilities/issues/32
+    DCHECK_LE(codec_vector.size(), 1U);
+
+    video_support =
+        IsSupportedMediaFormat(video_config.mime_type.Ascii(), codec_vector);
+  }
+
+  // TODO(chcunningham): API should never have to mask uncertainty. Log a metric
+  // for any content type that is "maybe" supported.
+  if (video_support == MayBeSupported)
+    video_support = IsSupported;
+  if (audio_support == MayBeSupported)
+    audio_support = IsSupported;
+
+  info->supported =
+      audio_support == IsSupported && video_support == IsSupported;

[mlamouri (slow - plz ping), 2017/04/25 12:48:43]

Should we expect code that will check if we can support them *together*?

[chcunningham, 2017/04/25 20:53:51]

Not for now. For the unencrypted MSE case, all codecs / containers that are
supported separately are also supported together (in separate MSE source
buffers). For non-MSE (src="foo.webm") this is also true, with the big caveat
that the file type's would have to match  (audio/webm and video/webm), because
different file types doesn't make sense if you're asking about a single file. We
could add logic to check that the file types match for type="file", but its not
urgent - there is no way for users to actually construct a frankenstein mixed
mp4/webm with any expectation that we could play it.

When we start to consider encryption, we may then need to check things together.
Even then, I don't currently have any concrete case where things could be played
separately but not together (I think these discussions were always a bit
hypothetical, but I may have forgotten some details). 

+
+  // TODO(chcunningham, mlamouri): real implementation for these.
+  info->smooth = info->power_efficient = info->supported;
+
   callbacks->OnSuccess(std::move(info));
 }
 
 }  // namespace media