Add type argument to pepper content decryptor method GenerateKeyRequest().

ppapi/cpp/private/content_decryptor_private.cc

 // 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.
 
 #include "ppapi/cpp/private/content_decryptor_private.h"
 
 #include <cstring>  // memcpy
 
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/private/ppb_content_decryptor_private.h"
 #include "ppapi/c/private/ppp_content_decryptor_private.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/instance_handle.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/var.h"
 
 namespace pp {
 
 namespace {
 
 static const char kPPPContentDecryptorInterface[] =
     PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
 
 void GenerateKeyRequest(PP_Instance instance,
                         PP_Var key_system_arg,
+                        PP_Var type_arg,
                         PP_Var init_data_arg) {
   void* object =
       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
   if (!object)
     return;
 
   pp::Var key_system_var(pp::PASS_REF, key_system_arg);
-  if (key_system_var.is_string() == false)
+  if (!key_system_var.is_string())
+    return;
+
+  pp::Var type_var(pp::PASS_REF, type_arg);
+  if (!type_var.is_string())
     return;
 
   pp::Var init_data_var(pp::PASS_REF, init_data_arg);
-  if (init_data_var.is_array_buffer() == false)
+  if (!init_data_var.is_array_buffer())
     return;
   pp::VarArrayBuffer init_data_array_buffer(init_data_var);
 
   static_cast<ContentDecryptor_Private*>(object)->GenerateKeyRequest(
       key_system_var.AsString(),
+      type_var.AsString(),
       init_data_array_buffer);
 }
 
 void AddKey(PP_Instance instance,
             PP_Var session_id_arg,
             PP_Var key_arg,
             PP_Var init_data_arg) {
   void* object =
       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
   if (!object)
     return;
 
   pp::Var session_id_var(pp::PASS_REF, session_id_arg);
-  if (session_id_var.is_string() == false)
+  if (!session_id_var.is_string())
     return;
 
   pp::Var key_var(pp::PASS_REF, key_arg);
-  if (key_var.is_array_buffer() == false)
+  if (!key_var.is_array_buffer())
     return;
   pp::VarArrayBuffer key(key_var);
 
   pp::Var init_data_var(pp::PASS_REF, init_data_arg);
-  if (init_data_var.is_array_buffer() == false)
+  if (!init_data_var.is_array_buffer())
     return;
   pp::VarArrayBuffer init_data(init_data_var);
 
 
   static_cast<ContentDecryptor_Private*>(object)->AddKey(
       session_id_var.AsString(),
       key,
       init_data);
 }
 
 void CancelKeyRequest(PP_Instance instance, PP_Var session_id_arg) {
   void* object =
       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
   if (!object)
     return;
 
   pp::Var session_id_var(pp::PASS_REF, session_id_arg);
-  if (session_id_var.is_string() == false)
+  if (!session_id_var.is_string())
     return;
 
   static_cast<ContentDecryptor_Private*>(object)->CancelKeyRequest(
       session_id_var.AsString());
 }
 
 
 void Decrypt(PP_Instance instance,
              PP_Resource encrypted_resource,
              const PP_EncryptedBlockInfo* encrypted_block_info) {
@@ skipping 235 matching lines @@
     const PP_DecryptedBlockInfo& decrypted_block_info) {
   if (has_interface<PPB_ContentDecryptor_Private>()) {
     get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples(
         associated_instance_.pp_instance(),
         audio_frames.pp_resource(),
         &decrypted_block_info);
   }
 }
 
 }  // namespace pp