Prepare MediaDrmBridge to work with MediaCodecPlayer

media/base/android/media_codec_video_decoder.cc

 // Copyright 2015 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/base/android/media_codec_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/media_codec_bridge.h"
+#include "media/base/android/media_drm_bridge.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 namespace {
 const int kDelayForStandAloneEOS = 2;  // milliseconds
 }
 
 MediaCodecVideoDecoder::MediaCodecVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& request_data_cb,
     const base::Closure& starvation_cb,
     const base::Closure& decoder_drained_cb,
     const base::Closure& stop_done_cb,
+    const base::Closure& key_required_cb,
     const base::Closure& error_cb,
     const SetTimeCallback& update_current_time_cb,
     const VideoSizeChangedCallback& video_size_changed_cb,
     const base::Closure& codec_created_cb)
     : MediaCodecDecoder(media_task_runner,
                         request_data_cb,
                         starvation_cb,
                         decoder_drained_cb,
                         stop_done_cb,
+                        key_required_cb,
                         error_cb,
                         "VideoDecoder"),
       update_current_time_cb_(update_current_time_cb),
       video_size_changed_cb_(video_size_changed_cb),
       codec_created_cb_(codec_created_cb) {
 }
 
 MediaCodecVideoDecoder::~MediaCodecVideoDecoder() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "VideoDecoder::~VideoDecoder()";
@@ skipping 15 matching lines @@
 
   configs_ = configs;
 
   if (video_size_.IsEmpty()) {
     video_size_ = configs_.video_size;
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(video_size_changed_cb_, video_size_));
   }
 }
 
+bool MediaCodecVideoDecoder::IsContentEncrypted() const {
+  return configs_.is_video_encrypted;
+}
+
 void MediaCodecVideoDecoder::ReleaseDecoderResources() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DoEmergencyStop();
 
   ReleaseMediaCodec();
 
   surface_ = gfx::ScopedJavaSurface();
 }
 
 void MediaCodecVideoDecoder::ReleaseMediaCodec() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   MediaCodecDecoder::ReleaseMediaCodec();
   delayed_buffers_.clear();
 }
 
 void MediaCodecVideoDecoder::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
            << (surface.IsEmpty() ? " empty" : " non-empty");
 
+  // Do not set unprotected surface if we know that we need a protected one.
+  // Empty surface means the surface removal and we always allow for it.
+  if (!surface.IsEmpty() && drm_bridge_ &&
+      drm_bridge_->IsProtectedSurfaceRequired() && !surface.is_protected()) {
+    DVLOG(0) << class_name() << "::" << __FUNCTION__
+             << ": surface is not protected, ignoring";
+    return;
+  }
+
   surface_ = surface.Pass();
 
   needs_reconfigure_ = true;
 }
 
 bool MediaCodecVideoDecoder::HasVideoSurface() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return !surface_.IsEmpty();
 }
@@ skipping 26 matching lines @@
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   // If we cannot find a key frame in cache, the browser seek is needed.
   if (!au_queue_.RewindToLastKeyFrame()) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__ << " key frame required";
     return kConfigKeyFrameRequired;
   }
 
   if (configs_.video_codec == kUnknownVideoCodec) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
-             << " configuration parameters are required";
+             << ": configuration parameters are required";
     return kConfigFailure;
   }
 
-  // TODO(timav): implement DRM.
-  // bool is_secure = is_content_encrypted() && drm_bridge() &&
-  //    drm_bridge()->IsProtectedSurfaceRequired();
-
-  bool is_secure = false;  // DRM is not implemented
-
   if (surface_.IsEmpty()) {
-    DVLOG(0) << class_name() << "::" << __FUNCTION__ << " surface required";
+    DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": surface is required";
     return kConfigFailure;
   }
 
+  bool is_secure = IsContentEncrypted() && drm_bridge_ &&
+                   drm_bridge_->IsProtectedSurfaceRequired();
+
   media_codec_bridge_.reset(VideoCodecBridge::CreateDecoder(
       configs_.video_codec,
       is_secure,
       configs_.video_size,
       surface_.j_surface().obj(),
       GetMediaCrypto().obj()));
 
   if (!media_codec_bridge_) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << " failed: cannot create video codec";
@@ skipping 156 matching lines @@
 
   // |update_current_time_cb_| might be null if there is audio stream.
   // Do not update current time for stand-alone EOS frames.
   if (!update_current_time_cb_.is_null() && update_time) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(update_current_time_cb_, pts, pts, false));
   }
 }
 
 }  // namespace media