Do not require a key before processing unencrypted frames within a potentially encrypted stream.

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/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/crypto/aes_decryptor.h"
 
 using testing::AtMost;
 
 namespace media {
 
@@ skipping 18 matching lines @@
 static const int kAppendTimeSec = 1;
 static const int kAppendTimeMs = kAppendTimeSec * 1000;
 static const int k320WebMFileDurationMs = 2737;
 static const int k640WebMFileDurationMs = 2763;
 static const int k1280IsoFileDurationMs = 2736;
 
 // Note: Tests using this class only exercise the DecryptingDemuxerStream path.
 // They do not exercise the Decrypting{Audio|Video}Decoder path.
 class FakeEncryptedMedia {
  public:
-  FakeEncryptedMedia()
+  // Defines the behavior of the "app" that responds to EME events.
+  class AppBase {

[xhwang, 2013/01/09 21:18:21]

Looks like AppBase isn't doing a lot of work and isn't expected to be called
directly. What do you think of making it a pure interface and move these
implementations to NoResponseApp?

[ddorwin, 2013/01/10 04:44:46]

Done.
I left KeyError since that's likely to be common.

+   public:
+    virtual ~AppBase() {}
+
+    virtual void KeyAdded(const std::string& key_system,
+                          const std::string& session_id) {
+      EXPECT_EQ(kClearKeySystem, key_system);
+      EXPECT_FALSE(session_id.empty());
+      FAIL() << "Unexpected KeyAdded";
+    }
+
+    virtual void KeyMessage(const std::string& key_system,
+                            const std::string& session_id,
+                            const std::string& message,
+                            const std::string& default_url) {
+      EXPECT_EQ(kClearKeySystem, key_system);
+      EXPECT_FALSE(session_id.empty());
+      EXPECT_FALSE(message.empty());
+      FAIL() << "Unexpected KeyMessage";
+    }
+
+    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,
+                         AesDecryptor* decryptor) {
+      FAIL() << "Unexpected NeedKey";
+    }
+
+    virtual void KeyError(const std::string& key_system,
+                          const std::string& session_id,
+                          AesDecryptor::KeyError error_code,
+                          int system_code) {
+      FAIL() << "Unexpected Key Error";
+    }
+  };
+
+  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)),
                    base::Bind(&FakeEncryptedMedia::NeedKey,
-                              base::Unretained(this))) {
+                              base::Unretained(this))),
+        app_(app) {
   }
 
   AesDecryptor* decryptor() {
     return &decryptor_;
   }
 
-  // Callbacks for firing key events.
+  // Callbacks for firing key events. Delegate to |app_|.
   void KeyAdded(const std::string& key_system, const std::string& session_id) {
-    EXPECT_EQ(kClearKeySystem, key_system);
-    EXPECT_FALSE(session_id.empty());
+    app_->KeyAdded(key_system, session_id);
   }
 
   void KeyError(const std::string& key_system,
                 const std::string& session_id,
                 AesDecryptor::KeyError error_code,
                 int system_code) {
-    FAIL() << "Unexpected Key Error";
+    app_->KeyError(key_system, session_id, error_code, system_code);
   }
 
   void KeyMessage(const std::string& key_system,
                   const std::string& session_id,
                   const std::string& message,
                   const std::string& default_url) {
+    app_->KeyMessage(key_system, session_id, message, default_url);
+  }
+
+  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) {
+    app_->NeedKey(key_system, session_id, type,
+                  init_data.Pass(), init_data_length, &decryptor_);
+  }
+
+ private:
+  AesDecryptor decryptor_;
+  scoped_ptr<AppBase> app_;
+};
+
+// Provides |kSecretKey| in response to needkey.
+class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
+ public:
+  void KeyAdded(const std::string& key_system,
+                const std::string& session_id) OVERRIDE {
+    EXPECT_EQ(kClearKeySystem, key_system);
+    EXPECT_FALSE(session_id.empty());
+  }
+
+  void KeyMessage(const std::string& key_system,
+                  const std::string& session_id,
+                  const std::string& message,
+                  const std::string& default_url) OVERRIDE {
     EXPECT_EQ(kClearKeySystem, key_system);
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
 
     current_key_system_ = key_system;
     current_session_id_ = session_id;
   }
 
   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) {
+               scoped_array<uint8> init_data, int init_data_length,
+               AesDecryptor* decryptor) OVERRIDE {
     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()) {
       EXPECT_TRUE(current_session_id_.empty());
-      EXPECT_TRUE(decryptor_.GenerateKeyRequest(
+      EXPECT_TRUE(decryptor->GenerateKeyRequest(
           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),
+    decryptor->AddKey(current_key_system_, kSecretKey, arraysize(kSecretKey),
                       init_data.get(), init_data_length, current_session_id_);
   }
 
- private:
-  AesDecryptor decryptor_;
   std::string current_key_system_;
   std::string current_session_id_;
 };
 
+// Ignores needkey and does not perform a license request
+class NoResponseApp : public FakeEncryptedMedia::AppBase {
+ public:
+  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,
+               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)
       : file_path_(GetTestDataFilePath(filename)),
         current_position_(0),
         initial_append_size_(initial_append_size),
         mimetype_(mimetype) {
@@ skipping 228 matching lines @@
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
   source.Abort();
   Stop();
 }
 
 TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_Encrypted_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect-av-enc_av.webm", kWebM,
                          kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media;
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360-av-enc_av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->GetData(), second_file->GetDataSize());
 
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
   source.Abort();
   Stop();
 }
 
 // Config changes from encrypted to clear are not currently supported.
 TEST_F(PipelineIntegrationTest,
        MediaSource_ConfigChange_ClearThenEncrypted_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
                          kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media;
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360-av-enc_av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->GetData(), second_file->GetDataSize());
 
   source.EndOfStream();
 
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
   source.Abort();
 }
 
 // Config changes from clear to encrypted are not currently supported.
 TEST_F(PipelineIntegrationTest,
        MediaSource_ConfigChange_EncryptedThenClear_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect-av-enc_av.webm", kWebM,
                          kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media;
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->GetData(), second_file->GetDataSize());
 
   source.EndOfStream();
 
@@ skipping 37 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlayback_16x9AspectRatio) {
   ASSERT_TRUE(Start(GetTestDataFilePath("bear-320x240-16x9-aspect.webm"),
                     PIPELINE_OK));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 TEST_F(PipelineIntegrationTest, EncryptedPlayback) {
   MockMediaSource source("bear-320x240-encrypted.webm", kWebM, 219816);
-  FakeEncryptedMedia encrypted_media;
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
+  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Abort();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest, EncryptedPlayback_NoEncryptedFrames) {
+  MockMediaSource source("bear-320x240-av-enc_av_un-all.webm",
+                         kWebM, kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new NoResponseApp());
+  StartPipelineWithEncryptedMedia(&source, &encrypted_media);
+
+  source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Abort();
   Stop();
 }
 
 // TODO(acolwell): Fix flakiness http://crbug.com/117921
@@ skipping 52 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