Use std::string for decryption key ID in webm parser.

media/webm/webm_cluster_parser.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 "media/webm/webm_cluster_parser.h"
 
+#include <vector>
+
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/webm/webm_constants.h"
 
 namespace media {
 
 // Generates a 16 byte CTR counter block. The CTR counter block format is a
 // CTR IV appended with a CTR block counter. |iv| is an 8 byte CTR IV.
 // Always returns a valid pointer to a buffer of kDecryptionKeySize bytes.
 static scoped_array<uint8> GenerateCounterBlock(uint64 iv) {
   scoped_array<uint8> counter_block_data(
       new uint8[DecryptConfig::kDecryptionKeySize]);
 
   // Set the IV.
   memcpy(counter_block_data.get(), &iv, sizeof(iv));
 
   // Set block counter to all 0's.
   memset(counter_block_data.get() + sizeof(iv),
          0,
          DecryptConfig::kDecryptionKeySize - sizeof(iv));
 
   return counter_block_data.Pass();
 }
 
 WebMClusterParser::WebMClusterParser(int64 timecode_scale,
                                      int audio_track_num,
                                      int video_track_num,
-                                     const uint8* video_encryption_key_id,
-                                     int video_encryption_key_id_size)
+                                     const std::string& video_encryption_key_id)
     : timecode_multiplier_(timecode_scale / 1000.0),
-      video_encryption_key_id_size_(video_encryption_key_id_size),
+      video_encryption_key_id_(video_encryption_key_id),
       parser_(kWebMIdCluster, this),
       last_block_timecode_(-1),
       block_data_size_(-1),
       block_duration_(-1),
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
       audio_(audio_track_num),
       video_(video_track_num) {
-  CHECK_GE(video_encryption_key_id_size, 0);
-  if (video_encryption_key_id_size > 0) {
-    video_encryption_key_id_.reset(new uint8[video_encryption_key_id_size]);
-    memcpy(video_encryption_key_id_.get(), video_encryption_key_id,
-           video_encryption_key_id_size);
-  }
 }
 
 WebMClusterParser::~WebMClusterParser() {}
 
 void WebMClusterParser::Reset() {
   last_block_timecode_ = -1;
   cluster_timecode_ = -1;
   cluster_start_time_ = kNoTimestamp();
   cluster_ended_ = false;
   parser_.Reset();
@@ skipping 149 matching lines @@
 
   last_block_timecode_ = timecode;
 
   base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
       (cluster_timecode_ + timecode) * timecode_multiplier_);
 
   // Every encrypted Block has an HMAC and IV prepended to it. Current encrypted
   // WebM request for comments specification is here
   // http://wiki.webmproject.org/encryption/webm-encryption-rfc
   bool encrypted = track_num == video_.track_num() &&
-                   video_encryption_key_id_.get();
+                   !video_encryption_key_id_.empty();

[scherkus (not reviewing), 2012/08/01 21:39:28]

this should be 4-space indent

[xhwang, 2012/08/01 22:01:10]

Done.

   // If encrypted skip past the HMAC. Encrypted buffers must include the IV and
   // the encrypted frame because the decryptor will verify this data before
   // decryption. The HMAC and IV will be copied into DecryptConfig.
   int offset = (encrypted) ? kWebMHmacSize : 0;
 
   // The first bit of the flags is set when the block contains only keyframes.
   // http://www.matroska.org/technical/specs/index.html
   bool is_keyframe = (flags & 0x80) != 0;
   scoped_refptr<StreamParserBuffer> buffer =
       StreamParserBuffer::CopyFrom(data + offset, size - offset, is_keyframe);
 
   if (encrypted) {
     uint64 network_iv;
     memcpy(&network_iv, data + kWebMHmacSize, sizeof(network_iv));
     const uint64 iv = base::NetToHost64(network_iv);
 
     scoped_array<uint8> counter_block(GenerateCounterBlock(iv));
     buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
-        std::string(
-            reinterpret_cast<const char*>(video_encryption_key_id_.get()),
-            video_encryption_key_id_size_),
+        video_encryption_key_id_,
         std::string(
             reinterpret_cast<const char*>(counter_block.get()),
             DecryptConfig::kDecryptionKeySize),
         std::string(reinterpret_cast<const char*>(data), kWebMHmacSize),
         sizeof(iv),
         std::vector<SubsampleEntry>())));
   }
 
   buffer->SetTimestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
@@ skipping 30 matching lines @@
 
   buffers_.push_back(buffer);
   return true;
 }
 
 void WebMClusterParser::Track::Reset() {
   buffers_.clear();
 }
 
 }  // namespace media