media: Add OutputProtectionProxy

media/cdm/ppapi/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/ppapi_cdm_adapter.h"
 
 #include <string.h>
 
 #include "base/macros.h"
 #include "build/build_config.h"
@@ skipping 302 matching lines @@
   return PP_CDMKEYSTATUS_INVALID;
 }
 
 }  // namespace
 
 namespace media {
 
 PpapiCdmAdapter::PpapiCdmAdapter(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::ContentDecryptor_Private(this),
-#if defined(OS_CHROMEOS)
       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),
+#if defined(OS_CHROMEOS)
+      platform_verification_(this),
 #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),
@@ skipping 721 matching lines @@
     // 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 PpapiCdmAdapter::EnableOutputProtection(uint32_t desired_protection_mask) {
-#if defined(OS_CHROMEOS)
   int32_t result = output_protection_.EnableProtection(
       desired_protection_mask,
       callback_factory_.NewCallback(&PpapiCdmAdapter::EnableProtectionDone));
 
   // Errors are ignored since clients must call QueryOutputProtectionStatus() to
   // inspect the protection status on a regular basis.
 
   if (result != PP_OK && result != PP_OK_COMPLETIONPENDING)
     CDM_DLOG() << __FUNCTION__ << " failed!";
-#endif
 }
 
 void PpapiCdmAdapter::QueryOutputProtectionStatus() {
-#if defined(OS_CHROMEOS)
   PP_DCHECK(!query_output_protection_in_progress_);
 
   output_link_mask_ = output_protection_mask_ = 0;
   const int32_t result = output_protection_.QueryStatus(
       &output_link_mask_, &output_protection_mask_,
       callback_factory_.NewCallback(
           &PpapiCdmAdapter::QueryOutputProtectionStatusDone));
   if (result == PP_OK_COMPLETIONPENDING) {
     query_output_protection_in_progress_ = true;
     ReportOutputProtectionQuery();
     return;
   }
 
   // Fall through on error and issue an empty OnQueryOutputProtectionStatus().
   PP_DCHECK(result != PP_OK);
   CDM_DLOG() << __FUNCTION__ << " failed, result = " << result;
-#endif
-  cdm_->OnQueryOutputProtectionStatus(cdm::kQueryFailed, 0, 0);
 }
 
 void PpapiCdmAdapter::OnDeferredInitializationDone(cdm::StreamType stream_type,
                                                    cdm::Status decoder_status) {
   switch (stream_type) {
     case cdm::kStreamTypeAudio:
       PP_DCHECK(deferred_initialize_audio_decoder_);
       CallOnMain(callback_factory_.NewCallback(
           &PpapiCdmAdapter::DecoderInitializeDone, PP_DECRYPTORSTREAMTYPE_AUDIO,
           deferred_audio_decoder_config_id_, decoder_status == cdm::kSuccess));
@@ skipping 17 matching lines @@
     CDM_DLOG()
         << "Cannot create FileIO because persistent state is not allowed.";
     return nullptr;
   }
 
   return new CdmFileIOImpl(
       client, pp_instance(),
       callback_factory_.NewCallback(&PpapiCdmAdapter::OnFirstFileRead));
 }
 
-#if defined(OS_CHROMEOS)
 void PpapiCdmAdapter::ReportOutputProtectionUMA(OutputProtectionStatus status) {
   pp::UMAPrivate uma_interface(this);
   uma_interface.HistogramEnumeration("Media.EME.OutputProtection", status,
                                      OUTPUT_PROTECTION_MAX);
 }
 
 void PpapiCdmAdapter::ReportOutputProtectionQuery() {
   if (uma_for_output_protection_query_reported_)
     return;
 
   ReportOutputProtectionUMA(OUTPUT_PROTECTION_QUERIED);
   uma_for_output_protection_query_reported_ = true;
 }
 
 void PpapiCdmAdapter::ReportOutputProtectionQueryResult() {
   if (uma_for_output_protection_positive_result_reported_)
     return;
 
   // Report UMAs for output protection query result.
   uint32_t external_links = (output_link_mask_ & ~cdm::kLinkTypeInternal);
 
   if (!external_links) {
     ReportOutputProtectionUMA(OUTPUT_PROTECTION_NO_EXTERNAL_LINK);
     uma_for_output_protection_positive_result_reported_ = true;
     return;
   }
 
   const uint32_t kProtectableLinks =
       cdm::kLinkTypeHDMI | cdm::kLinkTypeDVI | cdm::kLinkTypeDisplayPort;
-  bool is_unprotectable_link_connected = external_links & ~kProtectableLinks;
+  bool is_unprotectable_link_connected =
+      (external_links & ~kProtectableLinks) != 0;
   bool is_hdcp_enabled_on_all_protectable_links =
-      output_protection_mask_ & cdm::kProtectionHDCP;
+      (output_protection_mask_ & cdm::kProtectionHDCP) != 0;
 
   if (!is_unprotectable_link_connected &&
       is_hdcp_enabled_on_all_protectable_links) {
     ReportOutputProtectionUMA(OUTPUT_PROTECTION_ALL_EXTERNAL_LINKS_PROTECTED);
     uma_for_output_protection_positive_result_reported_ = true;
     return;
   }
 
   // Do not report a negative result because it could be a false negative.
   // Instead, we will calculate number of negatives using the total number of
   // queries and success results.
 }
 
+#if defined(OS_CHROMEOS)
 void PpapiCdmAdapter::SendPlatformChallengeDone(
     int32_t result,
     const linked_ptr<PepperPlatformChallengeResponse>& response) {
   if (result != PP_OK) {
     CDM_DLOG() << __FUNCTION__ << ": Platform challenge failed!";
     cdm::PlatformChallengeResponse platform_challenge_response = {};
     cdm_->OnPlatformChallengeResponse(platform_challenge_response);
     return;
   }
 
   pp::VarArrayBuffer signed_data_var(response->signed_data);
   pp::VarArrayBuffer signed_data_signature_var(response->signed_data_signature);
   std::string platform_key_certificate_string =
       response->platform_key_certificate.AsString();
 
   cdm::PlatformChallengeResponse platform_challenge_response = {
       static_cast<uint8_t*>(signed_data_var.Map()),
       signed_data_var.ByteLength(),
       static_cast<uint8_t*>(signed_data_signature_var.Map()),
       signed_data_signature_var.ByteLength(),
       reinterpret_cast<const uint8_t*>(platform_key_certificate_string.data()),
       static_cast<uint32_t>(platform_key_certificate_string.length())};
   cdm_->OnPlatformChallengeResponse(platform_challenge_response);
 
   signed_data_var.Unmap();
   signed_data_signature_var.Unmap();
 }
+#endif
 
 void PpapiCdmAdapter::EnableProtectionDone(int32_t result) {
   // Does nothing since clients must call QueryOutputProtectionStatus() to
   // inspect the protection status on a regular basis.
   CDM_DLOG() << __FUNCTION__ << " : " << result;
 }
 
 void PpapiCdmAdapter::QueryOutputProtectionStatusDone(int32_t result) {
   PP_DCHECK(query_output_protection_in_progress_);
   query_output_protection_in_progress_ = false;
 
   // Return a query status of failed on error.
   cdm::QueryResult query_result;
   if (result != PP_OK) {
     CDM_DLOG() << __FUNCTION__ << " failed, result = " << result;
     output_link_mask_ = output_protection_mask_ = 0;
     query_result = cdm::kQueryFailed;
   } else {
     query_result = cdm::kQuerySucceeded;
     ReportOutputProtectionQueryResult();
   }
 
   cdm_->OnQueryOutputProtectionStatus(query_result, output_link_mask_,
                                       output_protection_mask_);
 }
-#endif
 
 PpapiCdmAdapter::SessionError::SessionError(
     cdm::Error error,
     uint32_t system_code,
     const std::string& error_description)
     : error(error),
       system_code(system_code),
       error_description(error_description) {}
 
 PpapiCdmAdapter::SessionMessage::SessionMessage(
@@ skipping 66 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::PpapiCdmAdapterModule();
 }
 
 }  // namespace pp