Remove VideoDecodeAccelerator::SetCdm() and pass the cdm in Initialize()

media/video/video_decode_accelerator.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/bitstream_buffer.h"
+#include "media/base/cdm_context.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 typedef unsigned int GLenum;
 
 namespace base {
 class SingleThreadTaskRunner;
@@ skipping 82 matching lines @@
     // for PictureBuffers at the time of AssignPictureBuffers() call.
     // When set to IMPORT, the VDA will not allocate, but after receiving
     // AssignPictureBuffers() call, it will expect a call to
     // ImportBufferForPicture() for each PictureBuffer before use.
     enum class OutputMode {
       ALLOCATE,
       IMPORT,
     };
 
     Config() = default;
+
+    // Intentional converting constructor.
+    // TODO(watk): Make this explicit.
     Config(VideoCodecProfile profile);
-    Config(const VideoDecoderConfig& video_decoder_config);
 
     std::string AsHumanReadableString() const;
 
-    // |profile| combines the information about the codec and its profile.
+    // The video codec and profile.
     VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
 
-    // The flag indicating whether the stream is encrypted.
+    // Whether the stream is encrypted.
     bool is_encrypted = false;
 
-    // The flag indicating whether the client supports deferred initialization
-    // or not.
+    // The CDM that the VDA should use to decode encrypted streams. Must be
+    // set to a valid ID if |is_encrypted|.
+    int cdm_id = CdmContext::kInvalidCdmId;
+
+    // Whether the client supports deferred initialization.
     bool is_deferred_initialization_allowed = false;
 
     // An optional graphics surface that the VDA should render to. For setting
     // an output SurfaceView on Android. It's only valid when not equal to
     // |kNoSurfaceID|.
     int surface_id = kNoSurfaceID;
 
     // Coded size of the video frame hint, subject to change.
     gfx::Size initial_expected_coded_size = gfx::Size(320, 240);
 
@@ skipping 56 matching lines @@
   // decoder construction.  This call is synchronous and returns true iff
   // initialization is successful, unless deferred initialization is used.
   //
   // By default, deferred initialization is not used.  However, if Config::
   // is_deferred_initialization_allowed is set by the client, and if
   // Capabilities::Flags::SUPPORTS_DEFERRED_INITIALIZATION is set by the VDA,
   // and if VDA::Initialize returns true, then the client can expect a call to
   // NotifyInitializationComplete with the actual success / failure of
   // initialization.  Note that a return value of false from VDA::Initialize
   // indicates that initialization definitely failed, and no callback is needed.
-  // TODO(liberato): should we say that encrypted video requires deferred?
   //
-  // For encrpyted video, the decoder needs a CDM to be able to decode encrypted
-  // buffers. SetCdm() should be called after Initialize() to set such a CDM.
-  // Client::NotifyCdmAttached() will then be called to indicate whether the CDM
-  // is successfully attached to the decoder. Only when a CDM is successfully
-  // attached can we start to decode.
+  // For encrypted video, only deferred initialization is supported and |config|
+  // must contain a valid |cdm_id|.
   //
   // Parameters:
   //  |config| contains the initialization parameters.
   //  |client| is the client of this video decoder. Does not take ownership of
   //  |client| which must be valid until Destroy() is called.
   virtual bool Initialize(const Config& config, Client* client) = 0;
 
-  // Sets a CDM to be used by the decoder to decode encrypted buffers.
-  // Client::NotifyCdmAttached() will then be called to indicate whether the CDM
-  // is successfully attached to the decoder. The default implementation is a
-  // no-op since most VDAs don't support encrypted video.
-  virtual void SetCdm(int cdm_id);
-
   // Decodes given bitstream buffer that contains at most one frame.  Once
   // decoder is done with processing |bitstream_buffer| it will call
   // NotifyEndOfBitstreamBuffer() with the bitstream buffer id.
   // Parameters:
   //  |bitstream_buffer| is the input bitstream that is sent for decoding.
   virtual void Decode(const BitstreamBuffer& bitstream_buffer) = 0;
 
   // Assigns a set of texture-backed picture buffers to the video decoder.
   //
   // Ownership of each picture buffer remains with the client, but the client
@@ skipping 102 matching lines @@
 // std::unique_ptr<VideoDecodeAccelerator> uses "Destroy()" instead of trying to
 // use the destructor.
 template <>
 struct MEDIA_EXPORT default_delete<media::VideoDecodeAccelerator> {
   void operator()(media::VideoDecodeAccelerator* vda) const;
 };
 
 }  // namespace std
 
 #endif  // MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_