Drop DecryptConfig::data_offset_.

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"
@@ skipping 165 matching lines @@
 
     const scoped_refptr<StreamParserBuffer> buffer = *buffer_iter++;
     EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info.timestamp);
     EXPECT_EQ(buffer->duration().InMilliseconds(), block_info.duration);
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
-static bool VerifyEncryptedBuffer(
+static void VerifyEncryptedBuffer(
     scoped_refptr<StreamParserBuffer> buffer) {
   EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
             buffer->decrypt_config()->iv().length());
-  const uint8* data = buffer->data();
-  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);
   }
 }
 
@@ skipping 298 matching lines @@
                                       kVideoTrackNum,
                                       WebMTracksParser::TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_EQ(1UL, parser_->video_buffers().size());
   scoped_refptr<StreamParserBuffer> buffer = parser_->video_buffers()[0];
-  EXPECT_TRUE(VerifyEncryptedBuffer(buffer));
+  VerifyEncryptedBuffer(buffer);
 }
 
 TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
   scoped_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kVideoTrackNum,
                                       WebMTracksParser::TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 }  // namespace media