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

media/cdm/ppapi/cdm_adapter.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 "media/cdm/ppapi/cdm_adapter.h"
 
 #include "media/base/limits.h"
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
@@ skipping 284 matching lines @@
       output_protection_(this),
       platform_verification_(this),
       output_link_mask_(0),
       output_protection_mask_(0),
       query_output_protection_in_progress_(false),
       uma_for_output_protection_query_reported_(false),
       uma_for_output_protection_positive_result_reported_(false),
 #endif
       allocator_(this),
       cdm_(NULL),
+      allow_distinctive_identifier_(false),
+      allow_persistent_state_(false),
       deferred_initialize_audio_decoder_(false),
       deferred_audio_decoder_config_id_(0),
       deferred_initialize_video_decoder_(false),
       deferred_video_decoder_config_id_(0),
       last_read_file_size_kb_(0),
       file_size_uma_reported_(false) {
   callback_factory_.Initialize(this);
 }
 
 CdmAdapter::~CdmAdapter() {}
@@ skipping 12 matching lines @@
   return success;
 }
 
 // No errors should be reported in this function because the spec says:
 // "Store this new error object internally with the MediaKeys instance being
 // created. This will be used to fire an error against any session created for
 // this instance." These errors will be reported during session creation
 // (CreateSession()) or session loading (LoadSession()).
 // TODO(xhwang): If necessary, we need to store the error here if we want to
 // support more specific error reporting (other than "Unknown").
-void CdmAdapter::Initialize(const std::string& key_system) {
+void CdmAdapter::Initialize(const std::string& key_system,
+                            bool allow_distinctive_identifier,
+                            bool allow_persistent_state) {
   PP_DCHECK(!key_system.empty());
   PP_DCHECK(key_system_.empty() || (key_system_ == key_system && cdm_));
 
 #if defined(CHECK_DOCUMENT_URL)
   PP_URLComponents_Dev url_components = {};
   const pp::URLUtil_Dev* url_util = pp::URLUtil_Dev::Get();
   if (!url_util)
     return;
   pp::Var href = url_util->GetDocumentURL(pp::InstanceHandle(pp_instance()),
                                           &url_components);
   PP_DCHECK(href.is_string());
   std::string url = href.AsString();
   PP_DCHECK(!url.empty());
   std::string url_scheme =
       url.substr(url_components.scheme.begin, url_components.scheme.len);
   if (url_scheme != "file") {
     // Skip this check for file:// URLs as they don't have a host component.
     PP_DCHECK(url_components.host.begin);
     PP_DCHECK(0 < url_components.host.len);
   }
 #endif  // defined(CHECK_DOCUMENT_URL)
 
   if (!cdm_ && !CreateCdmInstance(key_system))
     return;
 
   PP_DCHECK(cdm_);
   key_system_ = key_system;
+  allow_distinctive_identifier_ = allow_distinctive_identifier;
+  allow_persistent_state_ = allow_persistent_state;
 }
 
 void CdmAdapter::SetServerCertificate(uint32_t promise_id,
                                       pp::VarArrayBuffer server_certificate) {
   const uint8_t* server_certificate_ptr =
       static_cast<const uint8_t*>(server_certificate.Map());
   const uint32_t server_certificate_size = server_certificate.ByteLength();
 
   if (!server_certificate_ptr ||
       server_certificate_size < media::limits::kMinCertificateLength ||
@@ skipping 724 matching lines @@
       pp::Module::Get()->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console->Log(pp_instance(), PP_LOGLEVEL_LOG, value.pp_var());
 }
 #endif  // !defined(NDEBUG)
 
 void CdmAdapter::SendPlatformChallenge(const char* service_id,
                                        uint32_t service_id_size,
                                        const char* challenge,
                                        uint32_t challenge_size) {
 #if defined(OS_CHROMEOS)
-  pp::VarArrayBuffer challenge_var(challenge_size);
-  uint8_t* var_data = static_cast<uint8_t*>(challenge_var.Map());
-  memcpy(var_data, challenge, challenge_size);
+  // If access to a distinctive identifier is not allowed, block platform
+  // verification to prevent access to such an identifier.
+  if (allow_distinctive_identifier_) {
+    pp::VarArrayBuffer challenge_var(challenge_size);
+    uint8_t* var_data = static_cast<uint8_t*>(challenge_var.Map());
+    memcpy(var_data, challenge, challenge_size);
 
-  std::string service_id_str(service_id, service_id_size);
+    std::string service_id_str(service_id, service_id_size);
 
-  linked_ptr<PepperPlatformChallengeResponse> response(
-      new PepperPlatformChallengeResponse());
+    linked_ptr<PepperPlatformChallengeResponse> response(

[dcheng, 2015/03/09 20:57:23]

Are there any plans to make PPAPI's callback system support a similar set of
primitives as base::Callback so that we'd be able to use scoped_ptr (and
eventually unique_ptr) here?

[dmichael (off chromium), 2015/03/09 21:02:07]

No...  it's not really worth the effort and complexity to do that. Though it
would be fun.

+        new PepperPlatformChallengeResponse());
 
-  int32_t result = platform_verification_.ChallengePlatform(
-      pp::Var(service_id_str),
-      challenge_var,
-      &response->signed_data,
-      &response->signed_data_signature,
-      &response->platform_key_certificate,
-      callback_factory_.NewCallback(&CdmAdapter::SendPlatformChallengeDone,
-                                    response));
-  challenge_var.Unmap();
-  if (result == PP_OK_COMPLETIONPENDING)
-    return;
+    int32_t result = platform_verification_.ChallengePlatform(
+        pp::Var(service_id_str),
+        challenge_var,
+        &response->signed_data,
+        &response->signed_data_signature,
+        &response->platform_key_certificate,
+        callback_factory_.NewCallback(&CdmAdapter::SendPlatformChallengeDone,
+                                      response));
+    challenge_var.Unmap();
+    if (result == PP_OK_COMPLETIONPENDING)
+      return;
 
-  // Fall through on error and issue an empty OnPlatformChallengeResponse().
-  PP_DCHECK(result != PP_OK);
+    // Fall through on error and issue an empty OnPlatformChallengeResponse().
+    PP_DCHECK(result != PP_OK);
+  }
 #endif
 
   cdm::PlatformChallengeResponse platform_challenge_response = {};
   cdm_->OnPlatformChallengeResponse(platform_challenge_response);
 }
 
 void CdmAdapter::EnableOutputProtection(uint32_t desired_protection_mask) {
 #if defined(OS_CHROMEOS)
   int32_t result = output_protection_.EnableProtection(
       desired_protection_mask, callback_factory_.NewCallback(
@@ skipping 51 matching lines @@
                                         deferred_video_decoder_config_id_,
                                         decoder_status == cdm::kSuccess));
       deferred_initialize_video_decoder_ = false;
       deferred_video_decoder_config_id_ = 0;
       break;
   }
 }
 
 // The CDM owns the returned object and must call FileIO::Close() to release it.
 cdm::FileIO* CdmAdapter::CreateFileIO(cdm::FileIOClient* client) {
-  return new CdmFileIOImpl(
-      client,
-      pp_instance(),
-      callback_factory_.NewCallback(&CdmAdapter::OnFirstFileRead));
+  if (allow_persistent_state_) {
+    return new CdmFileIOImpl(
+        client,
+        pp_instance(),
+        callback_factory_.NewCallback(&CdmAdapter::OnFirstFileRead));
+  }
+
+  return nullptr;
 }
 
 #if defined(OS_CHROMEOS)
 void CdmAdapter::ReportOutputProtectionUMA(OutputProtectionStatus status) {
   pp::UMAPrivate uma_interface(this);
   uma_interface.HistogramEnumeration(
       "Media.EME.OutputProtection", status, OUTPUT_PROTECTION_MAX);
 }
 
 void CdmAdapter::ReportOutputProtectionQuery() {
@@ skipping 171 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp