Block platform verification and file IO in the CDM adapter if the CDM configuration disallows them.

content/renderer/media/crypto/ppapi_decryptor.cc

 // Copyright 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 "content/renderer/media/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/key_systems.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 
 namespace content {
 
 scoped_ptr<PpapiDecryptor> PpapiDecryptor::Create(
     const std::string& key_system,
+    bool allow_distinctive_identifier,

[ddorwin, 2015/03/06 21:42:54]

Lots of passing lots of parameters around. We might consider a Params object in
the future. On the other hand, this ensures that we are actually handling new
values in each implementation of MediaKeys (see comments in the factory).

[sandersd (OOO until July 31), 2015/03/06 22:36:58]

Acknowledged.

+    bool allow_persistent_state,
     const GURL& security_origin,
     const CreatePepperCdmCB& create_pepper_cdm_cb,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb,
     const media::SessionKeysChangeCB& session_keys_change_cb,
     const media::SessionExpirationUpdateCB& session_expiration_update_cb) {
   std::string plugin_type = media::GetPepperType(key_system);
   DCHECK(!plugin_type.empty());
   scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper =
       create_pepper_cdm_cb.Run(plugin_type, security_origin);
   if (!pepper_cdm_wrapper) {
     DLOG(ERROR) << "Plugin instance creation failed.";
     return scoped_ptr<PpapiDecryptor>();
   }
 
   return scoped_ptr<PpapiDecryptor>(
       new PpapiDecryptor(key_system,
+                         allow_distinctive_identifier,
+                         allow_persistent_state,
                          pepper_cdm_wrapper.Pass(),
                          session_message_cb,
                          session_closed_cb,
                          session_error_cb,
                          session_keys_change_cb,
                          session_expiration_update_cb));
 }
 
 PpapiDecryptor::PpapiDecryptor(
     const std::string& key_system,
+    bool allow_distinctive_identifier,
+    bool allow_persistent_state,
     scoped_ptr<PepperCdmWrapper> pepper_cdm_wrapper,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb,
     const media::SessionKeysChangeCB& session_keys_change_cb,
     const media::SessionExpirationUpdateCB& session_expiration_update_cb)
     : pepper_cdm_wrapper_(pepper_cdm_wrapper.Pass()),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       session_error_cb_(session_error_cb),
       session_keys_change_cb_(session_keys_change_cb),
       session_expiration_update_cb_(session_expiration_update_cb),
       render_loop_proxy_(base::MessageLoopProxy::current()),
       weak_ptr_factory_(this) {
   DCHECK(pepper_cdm_wrapper_.get());
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!session_error_cb_.is_null());
   DCHECK(!session_keys_change_cb.is_null());
   DCHECK(!session_expiration_update_cb.is_null());
 
   base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
   CdmDelegate()->Initialize(
       key_system,
+      allow_distinctive_identifier,
+      allow_persistent_state,
       base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionError, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionKeysChange, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionExpirationUpdate, weak_this),
       base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this));
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
   pepper_cdm_wrapper_.reset();
@@ skipping 353 matching lines @@
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content