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/WebMediaConfiguration.h"
 #include "third_party/WebKit/public/platform/modules/media_capabilities/WebMediaDecodingAbility.h"
+#include "third_party/WebKit/public/platform/modules/media_capabilities/WebVideoConfiguration.h"
 
 namespace media {
 
 WebMediaCapabilitiesClientImpl::WebMediaCapabilitiesClientImpl() = default;
 
 WebMediaCapabilitiesClientImpl::~WebMediaCapabilitiesClientImpl() = default;
 
 void WebMediaCapabilitiesClientImpl::query(
     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::WebMediaDecodingAbility> ability(
       new blink::WebMediaDecodingAbility());
-  ability->supported = true;
-  ability->smooth = true;
-  ability->powerEfficient = true;
+
+  SupportsType audio_support = IsSupported;
+  SupportsType video_support = IsSupported;
+
+  if (configuration.audioConfiguration.has_value()) {
+    const blink::WebAudioConfiguration& audio_config =
+        configuration.audioConfiguration.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_EQ(codec_vector.size(), 1U);

[mlamouri (slow - plz ping), 2017/04/10 12:31:50]

Maybe we should do this check on the Blink side by exposing the method to
platform?

[chcunningham, 2017/04/20 21:48:10]

I think we should do this check in blink, but we can probably just use a simpler
call to WTF::String.split(...).

SplitCodecsToVector is used a few places in media, so it would be harder to move
that entirely to blink. 

Will save this for a follow up. 

+
+    audio_support =
+        IsSupportedMediaFormat(audio_config.mimeType.ascii(), codec_vector);
+  }
+
+  if (configuration.videoConfiguration.has_value()) {
+    const blink::WebVideoConfiguration& video_config =
+        configuration.videoConfiguration.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_EQ(codec_vector.size(), 1U);
+
+    video_support =
+        IsSupportedMediaFormat(video_config.mimeType.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;
+
+  ability->supported = audio_support == video_support == IsSupported;
+
+  if (ability->supported) {
+    // TODO(chcunningham, mlamouri): real implementation for these.
+    ability->smooth = true;
+    ability->powerEfficient = true;
+  } else {
+    ability->smooth = false;
+    ability->powerEfficient = false;
+  }
+
   callbacks->onSuccess(std::move(ability));
 }
 
 }  // namespace media