Support for parsing encrypted WebM streams by src.

media/webm/webm_cluster_parser_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 <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "media/base/decrypt_config.h"
 #include "media/webm/cluster_builder.h"
 #include "media/webm/webm_cluster_parser.h"
 #include "media/webm/webm_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::_;
 
 namespace media {
 
 enum {
   kTimecodeScale = 1000000,  // Timecode scale for millisecond timestamps.
   kAudioTrackNum = 1,
   kVideoTrackNum = 2,
   kTextTrackNum = 3,
 };
 
 struct BlockInfo {
   int track_num;
   int timestamp;
   int duration;
   bool use_simple_block;
 };
 
-const BlockInfo kDefaultBlockInfo[] = {
+static const BlockInfo kDefaultBlockInfo[] = {
   { kAudioTrackNum, 0, 23, true },
   { kAudioTrackNum, 23, 23, true },
   { kVideoTrackNum, 33, 34, true },
   { kAudioTrackNum, 46, 23, true },
   { kVideoTrackNum, 67, 33, false },
   { kAudioTrackNum, 69, 23, false },
   { kVideoTrackNum, 100, 33, false },
 };
 
+static const uint8 kEncryptedFrame[] = {
+  0x01,  // Block is encrypted
+  0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08  // IV
+};
+
 static scoped_ptr<Cluster> CreateCluster(int timecode,
                                          const BlockInfo* block_info,
                                          int block_count) {
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
 
   for (int i = 0; i < block_count; i++) {
     uint8 data[] = { 0x00 };
     if (block_info[i].use_simple_block) {
       cb.AddSimpleBlock(block_info[i].track_num,
                         block_info[i].timestamp,
                         0, data, sizeof(data));
       continue;
     }
 
     CHECK_GE(block_info[i].duration, 0);
     cb.AddBlockGroup(block_info[i].track_num,
                      block_info[i].timestamp,
                      block_info[i].duration,
                      0, data, sizeof(data));
   }
 
   return cb.Finish();
 }
 
+// Creates a Cluster with one encrypted Block. |bytes_to_write| is number of
+// bytes of the encrypted frame to write.
+static scoped_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
+  CHECK_GT(bytes_to_write, 0);
+  CHECK_LE(bytes_to_write, static_cast<int>(sizeof(kEncryptedFrame)));
+
+  ClusterBuilder cb;
+  cb.SetClusterTimecode(0);
+  cb.AddSimpleBlock(kVideoTrackNum, 0, 0, kEncryptedFrame, bytes_to_write);
+  return cb.Finish();
+}
+
 static bool VerifyBuffers(const WebMClusterParser::BufferQueue& audio_buffers,
                           const WebMClusterParser::BufferQueue& video_buffers,
                           const WebMClusterParser::BufferQueue& text_buffers,
                           const BlockInfo* block_info,
                           int block_count) {
   size_t audio_offset = 0;
   size_t video_offset = 0;
   size_t text_offset = 0;
   for (int i = 0; i < block_count; i++) {
     const WebMClusterParser::BufferQueue* buffers = NULL;
@@ skipping 78 matching lines @@
 
     const scoped_refptr<StreamParserBuffer> buffer = *buffer_iter++;
     EXPECT_EQ(buffer->GetTimestamp().InMilliseconds(), block_info.timestamp);
     EXPECT_EQ(buffer->GetDuration().InMilliseconds(), block_info.duration);
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
+static bool VerifyEncryptedBuffer(
+    scoped_refptr<StreamParserBuffer> buffer) {
+  EXPECT_TRUE(buffer->GetDecryptConfig());
+  EXPECT_EQ(DecryptConfig::kDecryptionKeySize,
+            buffer->GetDecryptConfig()->iv().length());
+  const uint8* data = buffer->GetData();
+  return data[0] & kWebMFlagEncryptedFrame;
+}
+
 static void AppendToEnd(const WebMClusterParser::BufferQueue& src,
                         WebMClusterParser::BufferQueue* dest) {
   for (WebMClusterParser::BufferQueue::const_iterator itr = src.begin();
        itr != src.end(); ++itr) {
     dest->push_back(*itr);
   }
 }
 
 class WebMClusterParserTest : public testing::Test {
  public:
@@ skipping 255 matching lines @@
 
   while (text_it(&text_track_num, &text_buffers)) {
     const TextTrackSet::const_iterator find_result =
         text_tracks.find(text_track_num);
     ASSERT_TRUE(find_result != text_tracks.end());
     ASSERT_TRUE(VerifyTextBuffers(parser_, kInputBlockInfo, input_block_count,
                                   text_track_num, *text_buffers));
   }
 }
 
+TEST_F(WebMClusterParserTest, ParseEncryptedBlock) {
+  scoped_ptr<Cluster> cluster(CreateEncryptedCluster(sizeof(kEncryptedFrame)));
+
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
+      std::set<int>(),
+      std::set<int64>(), "", "video_key_id",
+      LogCB()));
+  int result = parser_->Parse(cluster->data(), cluster->size());
+  EXPECT_EQ(cluster->size(), result);
+  ASSERT_EQ(1, parser_->video_buffers().size());
+  scoped_refptr<StreamParserBuffer> buffer = parser_->video_buffers()[0];
+  EXPECT_TRUE(VerifyEncryptedBuffer(buffer));
+}
+
+TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
+  scoped_ptr<Cluster> cluster(
+      CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
+
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
+      std::set<int>(),
+      std::set<int64>(), "", "video_key_id",
+      LogCB()));
+  int result = parser_->Parse(cluster->data(), cluster->size());
+  EXPECT_EQ(-1, result);
+}
+
 }  // namespace media