Add "type" in GenerateKeyRequest() and OnNeedKey().

media/filters/pipeline_integration_test.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/filters/pipeline_integration_test_base.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
@@ skipping 102 matching lines @@
     size_t quote1 = mimetype_.find("\"");
     size_t quote2 = mimetype_.find("\"", quote1 + 1);
     std::string codecStr = mimetype_.substr(quote1 + 1, quote2 - quote1 - 1);
     std::vector<std::string> codecs;
     Tokenize(codecStr, ",", &codecs);
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
     AppendData(initial_append_size_);
   }
 
-  void DemuxerNeedKey(scoped_array<uint8> init_data, int init_data_size) {
+  void DemuxerNeedKey(const std::string& type,
+                      scoped_array<uint8> init_data, int init_data_size) {
     DCHECK(init_data.get());
     DCHECK_GT(init_data_size, 0);
     DCHECK(decryptor_client_);
-    decryptor_client_->NeedKey("", "", init_data.Pass(), init_data_size);
+    decryptor_client_->NeedKey("", "", type, init_data.Pass(), init_data_size);
   }
 
  private:
   std::string url_;
   scoped_refptr<DecoderBuffer> file_data_;
   int current_position_;
   int initial_append_size_;
   std::string mimetype_;
   scoped_refptr<ChunkDemuxer> chunk_demuxer_;
   DecryptorClient* decryptor_client_;
@@ skipping 30 matching lines @@
     EXPECT_FALSE(session_id.empty());
     EXPECT_TRUE(message.get());
     EXPECT_GT(message_length, 0);
 
     current_key_system_ = key_system;
     current_session_id_ = session_id;
   }
 
   virtual void NeedKey(const std::string& key_system,
                        const std::string& session_id,
+                       const std::string& type,
                        scoped_array<uint8> init_data,
                        int init_data_length) {
     current_key_system_ = key_system;
     current_session_id_ = session_id;
 
     // When NeedKey is called from the demuxer, the |key_system| will be empty.
     // In this case, we need to call GenerateKeyRequest() to initialize a
     // session (which will call KeyMessage).
     if (current_key_system_.empty()) {
       DCHECK(current_session_id_.empty());
       EXPECT_TRUE(decryptor_.GenerateKeyRequest(
-          kClearKeySystem, kInitData, arraysize(kInitData)));
+          kClearKeySystem, type, kInitData, arraysize(kInitData)));
     }
 
     EXPECT_FALSE(current_key_system_.empty());
     EXPECT_FALSE(current_session_id_.empty());
     decryptor_.AddKey(current_key_system_, kSecretKey, arraysize(kSecretKey),
                       init_data.get(), init_data_length, current_session_id_);
   }
 
  private:
   AesDecryptor decryptor_;
@@ skipping 239 matching lines @@
 // Verify video decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", kVideoOnlyWebM,
                                  32768,
                                  base::TimeDelta::FromMilliseconds(200),
                                  base::TimeDelta::FromMilliseconds(1668),
                                  0x1C896, 65536));
 }
 
 }  // namespace media