Revert of Restrict use of hardware-secure codecs based on the...

Revert of Restrict use of hardware-secure codecs based on the RendererPreference. (patchset #11 id:210001 of https://codereview.chromium.org/1124863005/)

Reason for revert:
Compile failure in KeySystemConfigSelectorTest::SelectConfig().

../../media/blink/key_system_config_selector_unittest.cc:177:57: error: too few arguments to function call, expected 6, have 5

http://build.chromium.org/p/chromium.linux/builders/Linux%20GN%20Clobber/builds/113

Original issue's description:
> Restrict use of hardware-secure codecs based on the RendererPreference.
>
> This passes the value of |use_video_overlay_for_embedded_encrypted_video| from RendererPreferences to requestMediaKeySystemAccess() so that it can correctly block either non-hardware-secure codecs or hardware-secure codecs.
>
> BUG=467779
>
> Committed: https://crrev.com/491fea8c41977b1557a79cf2f53d4b60ecd159d9
> Cr-Commit-Position: refs/heads/master@{#329296}

TBR=xhwang@chromium.org,ddorwin@chromium.org,nasko@chromium.org,sky@chromium.org,sandersd@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=467779

Review URL: https://codereview.chromium.org/1137993004

Cr-Commit-Position: refs/heads/master@{#329307}

components/html_viewer/html_document.cc

@@ -109,12 +109,6 @@ bool CanNavigateLocally(blink::WebFrame* frame,
   return false;
 }
 
-bool AreSecureCodecsSupported() {
-  // Hardware-secure codecs are not currently supported by HTML Viewer on any
-  // platform.
-  return false;
-}
-
 }  // namespace
 
 HTMLDocument::HTMLDocument(
@@ -334,8 +328,7 @@ void HTMLDocument::didNavigateWithinPage(
 blink::WebEncryptedMediaClient* HTMLDocument::encryptedMediaClient() {
   if (!web_encrypted_media_client_) {
     web_encrypted_media_client_.reset(new media::WebEncryptedMediaClientImpl(
-        base::Bind(&AreSecureCodecsSupported), GetCdmFactory(),
-        GetMediaPermission()));
+        GetCdmFactory(), GetMediaPermission()));
   }
   return web_encrypted_media_client_.get();
 }

content/renderer/render_frame_impl.cc

@@ -3587,11 +3587,6 @@ blink::WebUserMediaClient* RenderFrameImpl::userMediaClient() {
 blink::WebEncryptedMediaClient* RenderFrameImpl::encryptedMediaClient() {
   if (!web_encrypted_media_client_) {
     web_encrypted_media_client_.reset(new media::WebEncryptedMediaClientImpl(
-        // base::Unretained(this) is safe because WebEncryptedMediaClientImpl
-        // is destructed before |this|, and does not give away ownership of the
-        // callback.
-        base::Bind(&RenderFrameImpl::AreSecureCodecsSupported,
-                   base::Unretained(this)),
         GetCdmFactory(), GetMediaPermission()));
   }
   return web_encrypted_media_client_.get();
@@ -4932,16 +4927,6 @@ media::MediaPermission* RenderFrameImpl::GetMediaPermission() {
   return media_permission_dispatcher_;
 }
 
-bool RenderFrameImpl::AreSecureCodecsSupported() {
-#if defined(OS_ANDROID)
-  // Hardware-secure codecs are only supported if secure surfaces are enabled.
-  return render_view_->renderer_preferences_
-      .use_video_overlay_for_embedded_encrypted_video;
-#else
-  return false;
-#endif  // defined(OS_ANDROID)
-}
-
 media::CdmFactory* RenderFrameImpl::GetCdmFactory() {
 #if defined(ENABLE_BROWSER_CDMS)
   if (!cdm_manager_)

content/renderer/render_frame_impl.h

@@ -813,7 +813,6 @@ class CONTENT_EXPORT RenderFrameImpl
   RendererMediaPlayerManager* GetMediaPlayerManager();
 #endif
 
-  bool AreSecureCodecsSupported();
   media::MediaPermission* GetMediaPermission();
   media::CdmFactory* GetCdmFactory();
 

media/base/eme_constants.h

@@ -129,14 +129,15 @@ enum class EmeConfigRule {
   // The configuration option is supported if both a distinctive identifier and
   // persistent state are available.
   IDENTIFIER_AND_PERSISTENCE_REQUIRED,
-  // The configuration option prevents use of hardware-secure codecs.
-  // This rule only has meaning on platforms that distinguish hardware-secure
-  // codecs (ie. Android).
+#if defined(OS_ANDROID)
+  // The configuration option is supported if no hardware-secure codecs are used
+  // (as they would be for video if secure surfaces are enabled).
   SECURE_CODECS_NOT_ALLOWED,
-  // The configuration option is supported if hardware-secure codecs are used.
-  // This rule only has meaning on platforms that distinguish hardware-secure
-  // codecs (ie. Android).
+  // The configuration option is supported if only hardware-secure codecs are
+  // used. This implies that secure surfaces (hole-punching) are required for
+  // video.
   SECURE_CODECS_REQUIRED,
+#endif  // defined(OS_ANDROID)
   // The configuration option is supported without conditions.
   SUPPORTED,
 };

media/base/key_systems.cc

@@ -716,10 +716,8 @@ EmeConfigRule KeySystemsImpl::GetContentTypeConfigRule(
     if ((codec & key_system_codec_mask & container_codec_mask) == 0)
       return EmeConfigRule::NOT_SUPPORTED;
 #if defined(OS_ANDROID)
-    // Check whether the codec supports a hardware-secure mode. The goal is to
-    // prevent mixing of non-hardware-secure codecs with hardware-secure codecs,
-    // since the mode is fixed at CDM creation.
-    //
+    // Check whether the codec supports a hardware-secure mode; if not, indicate
+    // that hardware-secure codecs are not available for all listed codecs.
     // Because the check for regular codec support is early-exit, we don't have
     // to consider codecs that are only supported in hardware-secure mode. We
     // could do so, and make use of SECURE_CODECS_REQUIRED, if it turns out that
@@ -727,6 +725,7 @@ EmeConfigRule KeySystemsImpl::GetContentTypeConfigRule(
     if ((codec & key_system_secure_codec_mask) == 0)
       support = EmeConfigRule::SECURE_CODECS_NOT_ALLOWED;
 #endif  // defined(OS_ANDROID)
+
   }
 
   return support;

media/blink/key_system_config_selector.cc

@@ -131,12 +131,11 @@ struct KeySystemConfigSelector::SelectionRequest {
   blink::WebVector<blink::WebMediaKeySystemConfiguration>
       candidate_configurations;
   blink::WebSecurityOrigin security_origin;
-  base::Callback<void(const blink::WebMediaKeySystemConfiguration&, bool)>
+  base::Callback<void(const blink::WebMediaKeySystemConfiguration&)>
       succeeded_cb;
   base::Callback<void(const blink::WebString&)> not_supported_cb;
   bool was_permission_requested = false;
   bool is_permission_granted = false;
-  bool are_secure_codecs_supported = false;
 };
 
 // Accumulates configuration rules to determine if a feature (additional
@@ -158,10 +157,6 @@ class KeySystemConfigSelector::ConfigState {
 
   bool IsIdentifierRecommended() const { return is_identifier_recommended_; }
 
-  bool AreSecureCodecsRequired() const {
-    return are_secure_codecs_required_;
-  }
-
   // Checks whether a rule is compatible with all previously added rules.
   bool IsRuleSupported(EmeConfigRule rule) const {
     switch (rule) {
@@ -182,10 +177,12 @@ class KeySystemConfigSelector::ConfigState {
       case EmeConfigRule::IDENTIFIER_AND_PERSISTENCE_REQUIRED:
         return (!is_identifier_not_allowed_ && IsPermissionPossible() &&
                 !is_persistence_not_allowed_);
+#if defined(OS_ANDROID)
       case EmeConfigRule::SECURE_CODECS_NOT_ALLOWED:
         return !are_secure_codecs_required_;
       case EmeConfigRule::SECURE_CODECS_REQUIRED:
         return !are_secure_codecs_not_allowed_;
+#endif  // defined(OS_ANDROID)
       case EmeConfigRule::SUPPORTED:
         return true;
     }
@@ -219,12 +216,14 @@ class KeySystemConfigSelector::ConfigState {
         is_identifier_required_ = true;
         is_persistence_required_ = true;
         return;
+#if defined(OS_ANDROID)
       case EmeConfigRule::SECURE_CODECS_NOT_ALLOWED:
         are_secure_codecs_not_allowed_ = true;
         return;
       case EmeConfigRule::SECURE_CODECS_REQUIRED:
         are_secure_codecs_required_ = true;
         return;
+#endif  // defined(OS_ANDROID)
       case EmeConfigRule::SUPPORTED:
         return;
     }
@@ -253,10 +252,11 @@ class KeySystemConfigSelector::ConfigState {
   bool is_persistence_required_ = false;
   bool is_persistence_not_allowed_ = false;
 
-  // Whether a rule has been added that requires or blocks hardware-secure
-  // codecs.
+#if defined(OS_ANDROID)
+  // Whether a rule has been added that requires or blocks secure codecs.
   bool are_secure_codecs_required_ = false;
   bool are_secure_codecs_not_allowed_ = false;
+#endif  // defined(OS_ANDROID)
 };
 
 KeySystemConfigSelector::KeySystemConfigSelector(
@@ -392,6 +392,7 @@ KeySystemConfigSelector::GetSupportedConfiguration(
     const blink::WebMediaKeySystemConfiguration& candidate,
     ConfigState* config_state,
     blink::WebMediaKeySystemConfiguration* accumulated_configuration) {
+  // TODO(sandersd): Set state of SECURE_CODECS from renderer pref.
   // From https://w3c.github.io/encrypted-media/#get-supported-configuration
   // 1. Let accumulated configuration be empty. (Done by caller.)
   // 2. If the initDataTypes member is present in candidate configuration, run
@@ -672,8 +673,7 @@ void KeySystemConfigSelector::SelectConfig(
     const blink::WebVector<blink::WebMediaKeySystemConfiguration>&
         candidate_configurations,
     const blink::WebSecurityOrigin& security_origin,
-    bool are_secure_codecs_supported,
-    base::Callback<void(const blink::WebMediaKeySystemConfiguration&, bool)>
+    base::Callback<void(const blink::WebMediaKeySystemConfiguration&)>
         succeeded_cb,
     base::Callback<void(const blink::WebString&)> not_supported_cb) {
   // Continued from requestMediaKeySystemAccess(), step 7, from
@@ -699,7 +699,6 @@ void KeySystemConfigSelector::SelectConfig(
   request->key_system = key_system_ascii;
   request->candidate_configurations = candidate_configurations;
   request->security_origin = security_origin;
-  request->are_secure_codecs_supported = are_secure_codecs_supported;
   request->succeeded_cb = succeeded_cb;
   request->not_supported_cb = not_supported_cb;
   SelectConfigInternal(request.Pass());
@@ -722,10 +721,6 @@ void KeySystemConfigSelector::SelectConfigInternal(
     //        new MediaKeySystemAccess object.]
     ConfigState config_state(request->was_permission_requested,
                              request->is_permission_granted);
-    DCHECK(config_state.IsRuleSupported(
-        EmeConfigRule::SECURE_CODECS_NOT_ALLOWED));
-    if (!request->are_secure_codecs_supported)
-      config_state.AddRule(EmeConfigRule::SECURE_CODECS_NOT_ALLOWED);
     blink::WebMediaKeySystemConfiguration accumulated_configuration;
     ConfigurationSupport support = GetSupportedConfiguration(
         request->key_system, request->candidate_configurations[i],
@@ -746,8 +741,7 @@ void KeySystemConfigSelector::SelectConfigInternal(
                        weak_factory_.GetWeakPtr(), base::Passed(&request)));
         return;
       case CONFIGURATION_SUPPORTED:
-        request->succeeded_cb.Run(accumulated_configuration,
-                                  config_state.AreSecureCodecsRequired());
+        request->succeeded_cb.Run(accumulated_configuration);
         return;
     }
   }

media/blink/key_system_config_selector.h

@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/eme_constants.h"
@@ -32,9 +31,8 @@ class MediaPermission;
 
 class MEDIA_EXPORT KeySystemConfigSelector {
  public:
-  KeySystemConfigSelector(
-      const KeySystems* key_systems,
-      MediaPermission* media_permission);
+  KeySystemConfigSelector(const KeySystems* key_systems,
+                          MediaPermission* media_permission);
 
   ~KeySystemConfigSelector();
 
@@ -43,10 +41,8 @@ class MEDIA_EXPORT KeySystemConfigSelector {
       const blink::WebVector<blink::WebMediaKeySystemConfiguration>&
           candidate_configurations,
       const blink::WebSecurityOrigin& security_origin,
-      bool are_secure_codecs_supported,
-      // The second argument is |are_secure_codecs_required|.
-      base::Callback<void(const blink::WebMediaKeySystemConfiguration&,
-                          bool)> succeeded_cb,
+      base::Callback<void(const blink::WebMediaKeySystemConfiguration&)>
+          succeeded_cb,
       base::Callback<void(const blink::WebString&)> not_supported_cb);
 
  private:

media/blink/webencryptedmediaclient_impl.cc

@@ -78,11 +78,9 @@ class WebEncryptedMediaClientImpl::Reporter {
 };
 
 WebEncryptedMediaClientImpl::WebEncryptedMediaClientImpl(
-    base::Callback<bool(void)> are_secure_codecs_supported_cb,
     CdmFactory* cdm_factory,
     MediaPermission* media_permission)
-    : are_secure_codecs_supported_cb_(are_secure_codecs_supported_cb),
-      cdm_factory_(cdm_factory),
+    : cdm_factory_(cdm_factory),
       key_system_config_selector_(KeySystems::GetInstance(), media_permission),
       weak_factory_(this) {
   DCHECK(cdm_factory_);
@@ -96,7 +94,7 @@ void WebEncryptedMediaClientImpl::requestMediaKeySystemAccess(
   GetReporter(request.keySystem())->ReportRequested();
   key_system_config_selector_.SelectConfig(
       request.keySystem(), request.supportedConfigurations(),
-      request.securityOrigin(), are_secure_codecs_supported_cb_.Run(),
+      request.securityOrigin(),
       base::Bind(&WebEncryptedMediaClientImpl::OnRequestSucceeded,
                  weak_factory_.GetWeakPtr(), request),
       base::Bind(&WebEncryptedMediaClientImpl::OnRequestNotSupported,
@@ -116,11 +114,8 @@ void WebEncryptedMediaClientImpl::CreateCdm(
 
 void WebEncryptedMediaClientImpl::OnRequestSucceeded(
     blink::WebEncryptedMediaRequest request,
-    const blink::WebMediaKeySystemConfiguration& accumulated_configuration,
-    bool are_secure_codecs_required) {
+    const blink::WebMediaKeySystemConfiguration& accumulated_configuration) {
   GetReporter(request.keySystem())->ReportSupported();
-  // TODO(sandersd): Pass |are_secure_codecs_required| along and use it to
-  // configure the CDM security level and use of secure surfaces on Android.
   request.requestSucceeded(WebContentDecryptionModuleAccessImpl::Create(
       request.keySystem(), accumulated_configuration, request.securityOrigin(),
       weak_factory_.GetWeakPtr()));

media/blink/webencryptedmediaclient_impl.h

@@ -7,7 +7,6 @@
 
 #include <string>
 
-#include "base/callback.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ -32,10 +31,8 @@ class MediaPermission;
 class MEDIA_EXPORT WebEncryptedMediaClientImpl
     : public blink::WebEncryptedMediaClient {
  public:
-  WebEncryptedMediaClientImpl(
-      base::Callback<bool(void)> are_secure_codecs_supported_cb,
-      CdmFactory* cdm_factory,
-      MediaPermission* media_permission);
+  WebEncryptedMediaClientImpl(CdmFactory* cdm_factory,
+                              MediaPermission* media_permission);
   virtual ~WebEncryptedMediaClientImpl();
 
   // WebEncryptedMediaClient implementation.
@@ -61,8 +58,7 @@ class MEDIA_EXPORT WebEncryptedMediaClientImpl
   // accumulated configuration.
   void OnRequestSucceeded(
       blink::WebEncryptedMediaRequest request,
-      const blink::WebMediaKeySystemConfiguration& accumulated_configuration,
-      bool are_secure_codecs_required);
+      const blink::WebMediaKeySystemConfiguration& accumulated_configuration);
 
   // Complete a requestMediaKeySystemAccess() request with an error message.
   void OnRequestNotSupported(blink::WebEncryptedMediaRequest request,
@@ -75,7 +71,6 @@ class MEDIA_EXPORT WebEncryptedMediaClientImpl
   // Reporter singletons.
   base::ScopedPtrHashMap<std::string, scoped_ptr<Reporter>> reporters_;
 
-  base::Callback<bool(void)> are_secure_codecs_supported_cb_;
   CdmFactory* cdm_factory_;
   KeySystemConfigSelector key_system_config_selector_;
   base::WeakPtrFactory<WebEncryptedMediaClientImpl> weak_factory_;