Add |legacy_destination_url| back to SessionMessage for EME

media/cdm/aes_decryptor_unittest.cc

 // Copyright 2013 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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
@@ skipping 264 matching lines @@
                        expected_result),
             base::Bind(&AesDecryptorTest::OnReject,
                        base::Unretained(this),
                        expected_result)));
     return promise.Pass();
   }
 
   // Creates a new session using |key_id|. Returns the session ID.
   std::string CreateSession(const std::vector<uint8>& key_id) {
     DCHECK(!key_id.empty());
-    EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary()));
+    EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
+                                        GURL::EmptyGURL()));
     decryptor_.CreateSessionAndGenerateRequest(
         MediaKeys::TEMPORARY_SESSION, std::string(), &key_id[0], key_id.size(),
         CreateSessionPromise(RESOLVED));
     // This expects the promise to be called synchronously, which is the case
     // for AesDecryptor.
     return web_session_id_;
   }
 
   // Closes the session specified by |session_id|.
   void CloseSession(const std::string& session_id) {
@@ skipping 100 matching lines @@
       case DATA_AND_SIZE_MISMATCH:
         EXPECT_NE(plain_text.size(), decrypted_text.size());
         break;
       case DECRYPT_ERROR:
       case NO_KEY:
         EXPECT_TRUE(decrypted_text.empty());
         break;
     }
   }
 
-  MOCK_METHOD3(OnSessionMessage,
+  MOCK_METHOD4(OnSessionMessage,
                void(const std::string& web_session_id,
                     MediaKeys::MessageType message_type,
-                    const std::vector<uint8>& message));
+                    const std::vector<uint8>& message,
+                    const GURL& legacy_destination_url));
   MOCK_METHOD1(OnSessionClosed, void(const std::string& web_session_id));
 
   AesDecryptor decryptor_;
   AesDecryptor::DecryptCB decrypt_cb_;
   std::string web_session_id_;
   CdmKeysInfo keys_info_;
 
   // Constants for testing.
   const std::vector<uint8> original_data_;
   const std::vector<uint8> encrypted_data_;
   const std::vector<uint8> subsample_encrypted_data_;
   const std::vector<uint8> key_id_;
   const std::vector<uint8> iv_;
   const std::vector<SubsampleEntry> normal_subsample_entries_;
   const std::vector<SubsampleEntry> no_subsample_entries_;
 };
 
 TEST_F(AesDecryptorTest, CreateSessionWithNullInitData) {
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsEmpty()));
+  EXPECT_CALL(*this,
+              OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   decryptor_.CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                              std::string(), NULL, 0,
                                              CreateSessionPromise(RESOLVED));
 }
 
 TEST_F(AesDecryptorTest, MultipleCreateSession) {
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsEmpty()));
+  EXPECT_CALL(*this,
+              OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   decryptor_.CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                              std::string(), NULL, 0,
                                              CreateSessionPromise(RESOLVED));
 
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsEmpty()));
+  EXPECT_CALL(*this,
+              OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   decryptor_.CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                              std::string(), NULL, 0,
                                              CreateSessionPromise(RESOLVED));
 
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsEmpty()));
+  EXPECT_CALL(*this,
+              OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   decryptor_.CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                              std::string(), NULL, 0,
                                              CreateSessionPromise(RESOLVED));
 }
 
 TEST_F(AesDecryptorTest, NormalDecryption) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
@@ skipping 409 matching lines @@
   EXPECT_TRUE(KeysInfoContains(key_id1));
   EXPECT_FALSE(KeysInfoContains(key_id2));
 
   // Add second key, verify both IDs returned.
   UpdateSessionAndExpect(session_id, kKey2AsJWK, RESOLVED);
   EXPECT_TRUE(KeysInfoContains(key_id1));
   EXPECT_TRUE(KeysInfoContains(key_id2));
 }
 
 }  // namespace media