Generalize AesDecryptor to make it more spec compliant.

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 "media/base/decoder_buffer.h"
+#include "media/base/mock_filters.h"
 #include "media/base/test_data_util.h"
+#include "media/crypto/aes_decryptor.h"
+#include "media/crypto/decryptor_client.h"
 #include "media/filters/chunk_demuxer_client.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
 
 namespace media {
 
-// Key ID of the video track in test file "bear-320x240-encrypted.webm".
-static const unsigned char kKeyId[] =
-    "\x11\xa5\x18\x37\xc4\x73\x84\x03\xe5\xe6\x57\xed\x8e\x06\xd9\x7c";
-
-static const char* kSourceId = "SourceId";
+static const char kSourceId[] = "SourceId";
+static const char kClearKeySystem[] = "org.w3.clearkey";
+static const uint8 kInitData[] = { 0x69, 0x6e, 0x69, 0x74 };
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
 class MockMediaSource : public ChunkDemuxerClient {
  public:
   MockMediaSource(const std::string& filename, int initial_append_size,
                   bool has_audio, bool has_video)
       : url_(GetTestDataURL(filename)),
         current_position_(0),
         initial_append_size_(initial_append_size),
         has_audio_(has_audio),
         has_video_(has_video) {
     file_data_ = ReadTestDataFile(filename);
 
     DCHECK_GT(initial_append_size_, 0);
     DCHECK_LE(initial_append_size_, file_data_->GetDataSize());
   }
 
   virtual ~MockMediaSource() {}
 
-  void set_decryptor(AesDecryptor* decryptor) {
-    decryptor_ = decryptor;
-  }
-  AesDecryptor* decryptor() const {
-    return decryptor_;
+  void set_decryptor_client(DecryptorClient* decryptor_client) {
+    decryptor_client_ = decryptor_client;
   }
 
   const std::string& url() const { return url_; }
 
   void Seek(int new_position, int seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek();
 
     chunk_demuxer_->Abort(kSourceId);
 
     DCHECK_GE(new_position, 0);
@@ skipping 34 matching lines @@
       codecs.push_back("vp8");
 
     chunk_demuxer_->AddId(kSourceId, "video/webm", codecs);
     AppendData(initial_append_size_);
   }
 
   virtual void DemuxerClosed() {
     chunk_demuxer_ = NULL;
   }
 
-  virtual void KeyNeeded(scoped_array<uint8> init_data, int init_data_size) {
+  virtual void DemuxerNeedKey(scoped_array<uint8> init_data,
+                              int init_data_size) {
     DCHECK(init_data.get());
     DCHECK_EQ(init_data_size, 16);
-    DCHECK(decryptor());
-    // In test file bear-320x240-encrypted.webm, the decryption key is equal to
-    // |init_data|.
-    decryptor()->AddKey(init_data.get(), init_data_size,
-                        init_data.get(), init_data_size);
+    DCHECK(decryptor_client_);
+    decryptor_client_->NeedKey("", "", init_data.Pass(), init_data_size);
   }
 
  private:
   std::string url_;
   scoped_refptr<DecoderBuffer> file_data_;
   int current_position_;
   int initial_append_size_;
   bool has_audio_;
   bool has_video_;
   scoped_refptr<ChunkDemuxer> chunk_demuxer_;
-  AesDecryptor* decryptor_;
+  DecryptorClient* decryptor_client_;
+};
+
+class MockDecryptorClientImpl : public DecryptorClient {

[scherkus (not reviewing), 2012/06/15 04:29:21]

Based on our IM chat... could other clients (i.e., player_x11)  make use of this
if they were using AesDecryptor?

[xhwang, 2012/06/15 16:39:18]

This MockDecryptorClientImpl just simulates an application which would call
AddKey() on needkey event. In this sense, it should work. But the key added is
specific to the test file bear-320x240-encrypted.webm. The player_x11 won't work
if it needs to decrypt other encrypted files.

+ public:
+  MockDecryptorClientImpl() : decryptor_(this) {}
+
+  AesDecryptor* decryptor() {
+    return &decryptor_;
+  }
+
+  // DecryptorClient implementation.
+  virtual void KeyAdded(const std::string& key_system,

[ddorwin, 2012/06/15 04:29:25]

Why did you override these instead of using GMock matchers? Don't you get
warnings for an unexpected call? Previously, you had EXPECT_CALL().

[xhwang, 2012/06/15 16:39:18]

In the IM-chat, scherkus@ points out that in pipeline integration test we use
real stuff (real demuxers, real decoders, etc) and we create a minimal
implementation of auxiliary interfaces rather than using Mock-classes. If you
look at pipeline_integration_test.cc you won't see any real Mock classes used
and EXPECT_CALL is never used.

Quote scherkus's comment: "the outcome of a pipeline integration test should be
on basic pipeline stuff (i.e., most tests play a clip until the end)
we've had to implement a few basic interfaces to get stuff working, such as a
file-based data source and a null audio sink".

[ddorwin, 2012/06/16 02:01:32]

Ah, I missed the parent class change and the class name threw me. In a future
CL, please change the name to not include "Mock" since that implies it is a real
GMock class. FakeDecryptorClient is an appropriate name.

[xhwang, 2012/06/19 16:37:48]

Done in http://codereview.chromium.org/10539150/, patch 4.

+                        const std::string& session_id) {
+    EXPECT_EQ(key_system, kClearKeySystem);

[ddorwin, 2012/06/15 04:29:25]

Expected values should be on LHS

[xhwang, 2012/06/15 16:39:18]

Done.

+    EXPECT_FALSE(session_id.empty());
+  }
+
+  virtual void KeyError(const std::string& key_system,
+                        const std::string& session_id,
+                        AesDecryptor::KeyError error_code,
+                        int system_code) {
+    NOTIMPLEMENTED();

[ddorwin, 2012/06/15 04:29:25]

Isn't unexpected call enough from GMock enough?
This usually means it hasn't yet or won't be implemented.

[xhwang, 2012/06/15 16:39:18]

See comment above.

+  }
+
+  virtual void KeyMessage(const std::string& key_system,
+                          const std::string& session_id,
+                          scoped_array<uint8> message,
+                          int message_length,
+                          const std::string& default_url) {
+    EXPECT_TRUE(key_system == kClearKeySystem);
+    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,
+                       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());
+      decryptor_.GenerateKeyRequest(kClearKeySystem,
+                                    kInitData, arraysize(kInitData));
+    }
+
+    EXPECT_FALSE(current_key_system_.empty());
+    EXPECT_FALSE(current_session_id_.empty());
+    // In test file bear-320x240-encrypted.webm, the decryption key is equal to

[ddorwin, 2012/06/16 02:01:32]

If this Fake is specific to this one file. We might as well move AddKey to
KeyMessage() and do nothing if GKR has already been requested. I think that is
more like an app implementation.

[xhwang, 2012/06/19 16:37:48]

The reason I didn't put AddKey() in KeyMessage() is because in this test all
calls are synchronous. Then we'll have this reentrant calling sequence:
NeedKey() -> GKR() -> KeyMessage() -> AddKey(). I was trying to simulate the
scenario in a real application where these calls are not called in an reentrant
manner.

+    // |init_data|.
+    decryptor_.AddKey(current_key_system_, init_data.get(), init_data_length,
+                      init_data.get(), init_data_length, current_session_id_);
+  }
+
+ private:
+  AesDecryptor decryptor_;
+  std::string current_key_system_;
+  std::string current_session_id_;
 };
 
 class PipelineIntegrationTest
     : public testing::Test,
       public PipelineIntegrationTestBase {
  public:
-  void StartPipelineWithMediaSource(MockMediaSource& source) {
+  void StartPipelineWithMediaSource(MockMediaSource* source) {
     pipeline_->Start(
-        CreateFilterCollection(&source),
+        CreateFilterCollection(source),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK));
 
     ASSERT_TRUE(decoder_.get());
-    source.set_decryptor(decryptor_.get());
 
     message_loop_.Run();
   }
+
+  void StartPipelineWithEncryptedMedia(
+      MockMediaSource* source,
+      MockDecryptorClientImpl* encrypted_media) {
+    pipeline_->Start(
+        CreateFilterCollection(source),
+        base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
+        base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
+        QuitOnStatusCB(PIPELINE_OK));
+
+    ASSERT_TRUE(decoder_.get());
+    decoder_->set_decryptor(encrypted_media->decryptor());
+    source->set_decryptor_client(encrypted_media);
+
+    message_loop_.Run();
+  }
 
   // Verifies that seeking works properly for ChunkDemuxer when the
   // seek happens while there is a pending read on the ChunkDemuxer
   // and no data is available.
   bool TestSeekDuringRead(const std::string& filename,
                           int initial_append_size,
                           base::TimeDelta start_seek_time,
                           base::TimeDelta seek_time,
                           int seek_file_position,
                           int seek_append_size,
                           bool has_audio,
                           bool has_video) {
     MockMediaSource source(filename, initial_append_size, has_audio, has_video);
-    StartPipelineWithMediaSource(source);
+    StartPipelineWithMediaSource(&source);
 
     if (pipeline_status_ != PIPELINE_OK)
       return false;
 
     Play();
     if (!WaitUntilCurrentTimeIsAfter(start_seek_time))
       return false;
 
     source.Seek(seek_file_position, seek_append_size);
     if (!Seek(seek_time))
@@ skipping 22 matching lines @@
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(GetVideoHash(), "f0be120a90a811506777c99a2cdf7cc1");
   EXPECT_EQ(GetAudioHash(), "6138555be3389e6aba4c8e6f70195d50");
 }
 
 TEST_F(PipelineIntegrationTest, EncryptedPlayback) {
   MockMediaSource source("bear-320x240-encrypted.webm", 219726, true, true);
-  StartPipelineWithMediaSource(source);
+  MockDecryptorClientImpl encrypted_media;
+  StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Abort();
   Stop();
 }
@@ 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", 32768,
                                  base::TimeDelta::FromMilliseconds(200),
                                  base::TimeDelta::FromMilliseconds(1668),
                                  0x1C896, 65536, false, true));
 }
 
 }  // namespace media