Encrypted Media: Handle empty init_data in AesDecryptor::GenerateKeyRequest().

media/crypto/aes_decryptor_unittest.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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/mock_filters.h"
 #include "media/crypto/aes_decryptor.h"
 #include "media/webm/webm_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Gt;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::SaveArg;
 using ::testing::StrNe;
 
 namespace media {
 
+MATCHER_P2(ArrayEq, array, size, "") {
+  return !memcmp(arg, array, size);
+}
+
 // |encrypted_data| is encrypted from |plain_text| using |key|. |key_id| is
 // used to distinguish |key|.
 struct WebmEncryptedData {
   uint8 plain_text[32];
   int plain_text_size;
   uint8 key_id[32];
   int key_id_size;
   uint8 key[32];
   int key_size;
   uint8 encrypted_data[64];
@@ skipping 15 matching lines @@
       }, 20,
     // key
     { 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
       0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23
       }, 16,
     // encrypted_data
     { 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xf0, 0xd1, 0x12, 0xd5, 0x24, 0x81, 0x96,
       0x55, 0x1b, 0x68, 0x9f, 0x38, 0x91, 0x85
       }, 23
-  },
-  {
+  }, {
     // plaintext
     "Changed Original data.", 22,
     // key_id
     { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
       0x10, 0x11, 0x12, 0x13
       }, 20,
     // key
     { 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
       0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23
       }, 16,
     // encrypted_data
     { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x57, 0x66, 0xf4, 0x12, 0x1a, 0xed, 0xb5,
       0x79, 0x1c, 0x8e, 0x25, 0xd7, 0x17, 0xe7, 0x5e,
       0x16, 0xe3, 0x40, 0x08, 0x27, 0x11, 0xe9
       }, 31
-  },
-  {
+  }, {
     // plaintext
     "Original data.", 14,
     // key_id
     { 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
       0x2c, 0x2d, 0x2e, 0x2f, 0x30
       }, 13,
     // key
     { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
       0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40
       }, 16,
     // encrypted_data
     { 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x9c, 0x71, 0x26, 0x57, 0x3e, 0x25, 0x37,
       0xf7, 0x31, 0x81, 0x19, 0x64, 0xce, 0xbc
       }, 23
-  },
-  {
+  }, {
     // plaintext
     "Changed Original data.", 22,
     // key_id
     { 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
       0x2c, 0x2d, 0x2e, 0x2f, 0x30
       }, 13,
     // key
     { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
       0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40
       }, 16,
     // encrypted_data
     { 0x00, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64,
       0x20, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61,
       0x6c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e
       }, 23
   }
 };
 
-
-
 static const uint8 kWebmWrongSizedKey[] = { 0x20, 0x20 };
 
 static const uint8 kSubsampleOriginalData[] = "Original subsample data.";
 static const int kSubsampleOriginalDataSize = 24;
 
 static const uint8 kSubsampleKeyId[] = { 0x00, 0x01, 0x02, 0x03 };
 
 static const uint8 kSubsampleKey[] = {
   0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
   0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
@@ skipping 104 matching lines @@
       : decryptor_(&client_),
         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
                                base::Unretained(this))),
         subsample_entries_(kSubsampleEntries,
                            kSubsampleEntries + arraysize(kSubsampleEntries)) {
   }
 
  protected:
   void GenerateKeyRequest(const uint8* key_id, int key_id_size) {
     EXPECT_CALL(client_, KeyMessageMock(kClearKeySystem, StrNe(""),
-                                        NotNull(), Gt(0), ""))
+                                        ArrayEq(key_id, key_id_size),
+                                        key_id_size, ""))
         .WillOnce(SaveArg<1>(&session_id_string_));
     EXPECT_TRUE(decryptor_.GenerateKeyRequest(kClearKeySystem, "",
                                               key_id, key_id_size));
   }
 
   void AddKeyAndExpectToSucceed(const uint8* key_id, int key_id_size,
                                 const uint8* key, int key_size) {
     EXPECT_CALL(client_, KeyAdded(kClearKeySystem, session_id_string_));
     decryptor_.AddKey(kClearKeySystem, key, key_size, key_id, key_id_size,
                       session_id_string_);
@@ skipping 53 matching lines @@
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
   }
 
   MockDecryptorClient client_;
   AesDecryptor decryptor_;
   std::string session_id_string_;
   AesDecryptor::DecryptCB decrypt_cb_;
   std::vector<SubsampleEntry> subsample_entries_;
 };
 
+TEST_F(AesDecryptorTest, GenerateKeyRequestWithNullInitData) {
+  EXPECT_FALSE(decryptor_.GenerateKeyRequest(kClearKeySystem, "", NULL, 0));
+}
+
 TEST_F(AesDecryptorTest, NormalWebMDecryption) {
   const WebmEncryptedData& frame = kWebmEncryptedFrames[0];
   GenerateKeyRequest(frame.key_id, frame.key_id_size);
   AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size,
                            frame.key, frame.key_size);
   scoped_refptr<DecoderBuffer> encrypted_data =
       CreateWebMEncryptedBuffer(frame.encrypted_data,
                                 frame.encrypted_data_size,
                                 frame.key_id, frame.key_id_size);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data,
@@ skipping 254 matching lines @@
   scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer(
       kSubsampleData, arraysize(kSubsampleData),
       kSubsampleKeyId, arraysize(kSubsampleKeyId),
       kSubsampleIv, arraysize(kSubsampleIv),
       0,
       entries);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToFail(encrypted_data));
 }
 
 }  // namespace media