Add 'cbcs' encryption scheme support in Android media.

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 315 matching lines @@
     // We should never be here if a SurfaceView is required.
     DCHECK_EQ(config_.surface_id, SurfaceManager::kNoSurfaceID);
     defer_surface_creation_ = true;
     NotifyInitializationComplete(true);
     return true;
   }
 
   // We signaled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
-  if (config_.is_encrypted && !deferred_initialization_pending_) {
+  if (config_.is_encrypted() && !deferred_initialization_pending_) {
     DLOG(ERROR) << "Deferred initialization must be used for encrypted streams";
     return false;
   }
 
   if (AVDACodecAllocator::Instance()->AllocateSurface(this,
                                                       config_.surface_id)) {
     // We now own the surface, so finish initialization.
     return InitializePictureBufferManager();
   }
 
@@ skipping 20 matching lines @@
 
   codec_config_->surface =
       picture_buffer_manager_.Initialize(config_.surface_id);
   if (codec_config_->surface.IsEmpty())
     return false;
 
   if (!AVDACodecAllocator::Instance()->StartThread(this))
     return false;
 
   // If we are encrypted, then we aren't able to create the codec yet.
-  if (config_.is_encrypted) {
+  if (config_.is_encrypted()) {
     InitializeCdm();
     return true;
   }
 
   if (deferred_initialization_pending_ || defer_surface_creation_) {
     defer_surface_creation_ = false;
     ConfigureMediaCodecAsynchronously();
     return true;
   }
 
@@ skipping 109 matching lines @@
   const std::vector<SubsampleEntry>& subsamples = bitstream_buffer.subsamples();
 
   MediaCodecStatus status;
   if (key_id.empty() || iv.empty()) {
     status = media_codec_->QueueInputBuffer(input_buf_index, memory,
                                             bitstream_buffer.size(),
                                             presentation_timestamp);
   } else {
     status = media_codec_->QueueSecureInputBuffer(
         input_buf_index, memory, bitstream_buffer.size(), key_id, iv,
-        subsamples, presentation_timestamp);
+        subsamples, config_.encryption_scheme, presentation_timestamp);
   }
 
   DVLOG(2) << __func__
            << ": Queue(Secure)InputBuffer: pts:" << presentation_timestamp
            << " status:" << status;
 
   if (status == MEDIA_CODEC_NO_KEY) {
     // Keep trying to enqueue the same input buffer.
     // The buffer is owned by us (not the MediaCodec) and is filled with data.
     DVLOG(1) << "QueueSecureInputBuffer failed: NO_KEY";
@@ skipping 927 matching lines @@
   }
 #endif
 
   return capabilities;
 }
 
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
-  return !config_.is_encrypted && (codec_config_->codec == kCodecVP8 ||
-                                   codec_config_->codec == kCodecVP9);
+  return !config_.is_encrypted() && (codec_config_->codec == kCodecVP8 ||
+                                     codec_config_->codec == kCodecVP9);
 }
 
 bool AndroidVideoDecodeAccelerator::UpdateSurface() {
   DCHECK(pending_surface_id_);
   DCHECK_NE(config_.surface_id, pending_surface_id_.value());
   DCHECK(config_.surface_id == SurfaceManager::kNoSurfaceID ||
          pending_surface_id_.value() == SurfaceManager::kNoSurfaceID);
 
   const int previous_surface_id = config_.surface_id;
   const int new_surface_id = pending_surface_id_.value();
@@ skipping 43 matching lines @@
     AVDACodecAllocator::Instance()->DeallocateSurface(this, new_surface_id);
   }
 
   // Regardless of whether we succeeded, we no longer own the previous surface.
   AVDACodecAllocator::Instance()->DeallocateSurface(this, previous_surface_id);
 
   return success;
 }
 
 }  // namespace media