Change NeedKeyCB to use std::vector.

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/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
@@ skipping 68 matching lines @@
                           int system_code) {
       FAIL() << "Unexpected Key Error";
     }
 
     virtual void KeyMessage(const std::string& session_id,
                             const std::vector<uint8>& message,
                             const std::string& default_url) = 0;
 
     virtual void NeedKey(const std::string& session_id,
                          const std::string& type,
-                         scoped_ptr<uint8[]> init_data, int init_data_length,
+                         const std::vector<uint8>& init_data,
                          AesDecryptor* decryptor) = 0;
   };
 
   FakeEncryptedMedia(AppBase* app)
       : decryptor_(base::Bind(&FakeEncryptedMedia::KeyAdded,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::KeyError,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::KeyMessage,
                               base::Unretained(this))),
@@ skipping 16 matching lines @@
   }
 
   void KeyMessage(const std::string& session_id,
                   const std::vector<uint8>& message,
                   const std::string& default_url) {
     app_->KeyMessage(session_id, message, default_url);
   }
 
   void NeedKey(const std::string& session_id,
                const std::string& type,
-               scoped_ptr<uint8[]> init_data, int init_data_length) {
-    app_->NeedKey(session_id, type, init_data.Pass(), init_data_length,
-                  &decryptor_);
+               const std::vector<uint8>& init_data) {
+    app_->NeedKey(session_id, type, init_data, &decryptor_);
   }
 
  private:
   AesDecryptor decryptor_;
   scoped_ptr<AppBase> app_;
 };
 
 // Provides |kSecretKey| in response to needkey.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
   virtual void KeyAdded(const std::string& session_id) OVERRIDE {
     EXPECT_FALSE(session_id.empty());
   }
 
   virtual void KeyMessage(const std::string& session_id,
                           const std::vector<uint8>& message,
                           const std::string& default_url) OVERRIDE {
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
 
     current_session_id_ = session_id;
   }
 
   virtual void NeedKey(const std::string& session_id,
                        const std::string& type,
-                       scoped_ptr<uint8[]> init_data, int init_data_length,
+                       const std::vector<uint8>& init_data,
                        AesDecryptor* decryptor) OVERRIDE {
     current_session_id_ = session_id;
 
     if (current_session_id_.empty()) {
       EXPECT_TRUE(decryptor->GenerateKeyRequest(type, kInitData,
                                                 arraysize(kInitData)));
     }
 
     EXPECT_FALSE(current_session_id_.empty());
 
     // Clear Key really needs the key ID in |init_data|. For WebM, they are the
     // same, but this is not the case for ISO CENC. Therefore, provide the
     // correct key ID.
-    const uint8* key_id = init_data.get();
-    int key_id_length = init_data_length;
+    const uint8* key_id = init_data.empty() ? NULL : &init_data[0];
+    size_t key_id_length = init_data.size();
     if (type == kMP4AudioType || type == kMP4VideoType) {
       key_id = kKeyId;
       key_id_length = arraysize(kKeyId);
     }
 
     decryptor->AddKey(kSecretKey, arraysize(kSecretKey),
                       key_id, key_id_length, current_session_id_);
   }
 
   std::string current_session_id_;
@@ skipping 10 matching lines @@
   virtual void KeyMessage(const std::string& session_id,
                           const std::vector<uint8>& message,
                           const std::string& default_url) OVERRIDE {
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
     FAIL() << "Unexpected KeyMessage";
   }
 
   virtual void NeedKey(const std::string& session_id,
                        const std::string& type,
-                       scoped_ptr<uint8[]> init_data, int init_data_length,
+                       const std::vector<uint8>& init_data,
                        AesDecryptor* decryptor) OVERRIDE {
   }
 };
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
 class MockMediaSource {
  public:
   MockMediaSource(const std::string& filename, const std::string& mimetype,
                   int initial_append_size)
@@ skipping 80 matching lines @@
     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(const std::string& type,
-                      scoped_ptr<uint8[]> init_data, int init_data_size) {
-    DCHECK(init_data.get());
-    DCHECK_GT(init_data_size, 0);
+                      const std::vector<uint8>& init_data) {
+    DCHECK(!init_data.empty());
     CHECK(!need_key_cb_.is_null());
-    need_key_cb_.Run(std::string(), type, init_data.Pass(), init_data_size);
+    need_key_cb_.Run(std::string(), type, init_data);
   }
 
   scoped_ptr<TextTrack> OnTextTrack(TextKind kind,
                                     const std::string& label,
                                     const std::string& language) {
     return scoped_ptr<TextTrack>();
   }
 
  private:
   base::FilePath file_path_;
@@ skipping 659 matching lines @@
 
 // Verify that VP8 video with inband text track can be played back.
 TEST_F(PipelineIntegrationTest, BasicPlayback_VP8_WebVTT_WebM) {
   ASSERT_TRUE(Start(GetTestDataFilePath("bear-vp8-webvtt.webm"),
                     PIPELINE_OK));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 }  // namespace media