Code clean-up in AesDecryptor and test.

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/sys_byteorder.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 125 matching lines @@
 // byte 33 is changed from 0xf7 to 0xf8. Bytes 20+ of WebM encrypted data
 // contains the encrypted frame.
 static const unsigned char kWebmFrame0FrameDataChanged[] = {
   0xfb, 0xe7, 0x1d, 0xbb, 0x4c, 0x23, 0xce, 0xba,
   0xcc, 0xf8, 0xda, 0xc0, 0xff, 0xff, 0xff, 0xff,
   0xff, 0xff, 0xff, 0xff, 0x99, 0xaa, 0xff, 0xb7,
   0x74, 0x02, 0x4e, 0x1c, 0x75, 0x3d, 0xee, 0xcb,
   0x64, 0xf8
 };
 
+// Returns a 16 byte CTR counter block. The CTR counter block format is a
+// CTR IV appended with a CTR block counter. |iv| is a CTR IV. |iv_size| is
+// the size of |iv| in bytes.
+static std::string GenerateCounterBlock(const uint8* iv, int iv_size) {
+  const int kDecryptionKeySize = 16;
+  CHECK_GT(iv_size, 0);
+  CHECK_LE(iv_size, kDecryptionKeySize);
+  char counter_block_data[kDecryptionKeySize];
+
+  // Set the IV.
+  memcpy(counter_block_data, iv, iv_size);
+
+  // Set block counter to all 0's.
+  memset(counter_block_data + iv_size, 0, kDecryptionKeySize - iv_size);
+
+  return std::string(counter_block_data, kDecryptionKeySize);
+}
+
+// Creates a WebM encrypted buffer that the demuxer would pass to the
+// decryptor. |data| is the payload of a WebM encrypted Block. |key_id| is
+// initialization data from the WebM file. Every encrypted Block has
+// an HMAC and IV prepended to an encrypted frame. Current encrypted WebM
+// request for comments specification is here:
+// http://wiki.webmproject.org/encryption/webm-encryption-rfc
+static scoped_refptr<DecoderBuffer> CreateWebMEncryptedBuffer(
+    const uint8* data, int data_size,
+    const uint8* key_id, int key_id_size) {
+  scoped_refptr<DecoderBuffer> encrypted_buffer = DecoderBuffer::CopyFrom(
+      data + kWebMHmacSize, data_size - kWebMHmacSize);
+  CHECK(encrypted_buffer);
+
+  uint64 network_iv;
+  memcpy(&network_iv, data + kWebMHmacSize, sizeof(network_iv));
+  const uint64 iv = base::NetToHost64(network_iv);
+  std::string webm_iv = GenerateCounterBlock(
+      reinterpret_cast<const uint8*>(&iv), sizeof(iv));
+  encrypted_buffer->SetDecryptConfig(
+      scoped_ptr<DecryptConfig>(
+          new DecryptConfig(key_id, key_id_size,
+                            reinterpret_cast<const uint8*>(webm_iv.data()),
+                            webm_iv.size(), data, kWebMHmacSize, sizeof(iv))));
+  return encrypted_buffer;
+}
+
 class AesDecryptorTest : public testing::Test {
  public:
   AesDecryptorTest()
       : decryptor_(&client_),
         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
                                base::Unretained(this))) {
   }
 
  protected:
-  // Returns a 16 byte CTR counter block. The CTR counter block format is a
-  // CTR IV appended with a CTR block counter. |iv| is a CTR IV. |iv_size| is
-  // the size of |iv| in bytes.
-  static std::string GenerateCounterBlock(const uint8* iv, int iv_size) {
-    const int kDecryptionKeySize = 16;
-    CHECK_GT(iv_size, 0);
-    CHECK_LE(iv_size, kDecryptionKeySize);
-    char counter_block_data[kDecryptionKeySize];
-
-    // Set the IV.
-    memcpy(counter_block_data, iv, iv_size);
-
-    // Set block counter to all 0's.
-    memset(counter_block_data + iv_size, 0, kDecryptionKeySize - iv_size);
-
-    return std::string(counter_block_data, kDecryptionKeySize);
-  }
-
-  // Creates a WebM encrypted buffer that the demuxer would pass to the
-  // decryptor. |data| is the payload of a WebM encrypted Block. |key_id| is
-  // initialization data from the WebM file. Every encrypted Block has
-  // an HMAC and IV prepended to an encrypted frame. Current encrypted WebM
-  // request for comments specification is here
-  // http://wiki.webmproject.org/encryption/webm-encryption-rfc
-  scoped_refptr<DecoderBuffer> CreateWebMEncryptedBuffer(const uint8* data,
-                                                         int data_size,
-                                                         const uint8* key_id,
-                                                         int key_id_size) {
-    scoped_refptr<DecoderBuffer> encrypted_buffer = DecoderBuffer::CopyFrom(
-        data + kWebMHmacSize, data_size - kWebMHmacSize);
-    CHECK(encrypted_buffer);
-
-    uint64 network_iv;
-    memcpy(&network_iv, data + kWebMHmacSize, sizeof(network_iv));
-    const uint64 iv = base::NetToHost64(network_iv);
-    std::string webm_iv =
-        GenerateCounterBlock(reinterpret_cast<const uint8*>(&iv), sizeof(iv));
-    encrypted_buffer->SetDecryptConfig(
-        scoped_ptr<DecryptConfig>(new DecryptConfig(
-            key_id, key_id_size,
-            reinterpret_cast<const uint8*>(webm_iv.data()), webm_iv.size(),
-            data, kWebMHmacSize,
-            sizeof(iv))));
-    return encrypted_buffer;
-  }
-
   void GenerateKeyRequest(const uint8* key_id, int key_id_size) {
     EXPECT_CALL(client_, KeyMessageMock(kClearKeySystem, StrNe(std::string()),
                                         NotNull(), Gt(0), ""))
         .WillOnce(SaveArg<1>(&session_id_string_));
     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_));
@@ skipping 35 matching lines @@
         CreateWebMEncryptedBuffer(data, data_size, key_id, key_id_size);
     EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kError, IsNull()));
     decryptor_.Decrypt(encrypted_data, decrypt_cb_);
   }
 
   scoped_refptr<DecoderBuffer> encrypted_data_;
   MockDecryptorClient client_;
   AesDecryptor decryptor_;
   std::string session_id_string_;
   AesDecryptor::DecryptCB decrypt_cb_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AesDecryptorTest);
 };
 
 TEST_F(AesDecryptorTest, NormalDecryption) {
   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);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(frame.encrypted_data,
                                                     frame.encrypted_data_size,
                                                     frame.plain_text,
@@ skipping 109 matching lines @@
                            frame.key, frame.key_size);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToFail(kWebmFrame0FrameDataChanged,
                                                  frame.encrypted_data_size,
                                                  frame.plain_text,
                                                  frame.plain_text_size,
                                                  frame.key_id,
                                                  frame.key_id_size));
 }
 
 }  // namespace media