Rename EME WD call parameters

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 "media/base/decoder_buffer.h"
@@ skipping 177 matching lines @@
       : decryptor_(base::Bind(&AesDecryptorTest::OnSessionCreated,
                               base::Unretained(this)),
                    base::Bind(&AesDecryptorTest::OnSessionMessage,
                               base::Unretained(this)),
                    base::Bind(&AesDecryptorTest::OnSessionReady,
                               base::Unretained(this)),
                    base::Bind(&AesDecryptorTest::OnSessionClosed,
                               base::Unretained(this)),
                    base::Bind(&AesDecryptorTest::OnSessionError,
                               base::Unretained(this))),
-        reference_id_(MediaKeys::kInvalidReferenceId),
+        session_id_(MediaKeys::kInvalidSessionId),
         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
                                base::Unretained(this))),
         original_data_(kOriginalData, kOriginalData + kOriginalDataSize),
         encrypted_data_(kEncryptedData,
                         kEncryptedData + arraysize(kEncryptedData)),
         subsample_encrypted_data_(
             kSubsampleEncryptedData,
             kSubsampleEncryptedData + arraysize(kSubsampleEncryptedData)),
         key_id_(kKeyId, kKeyId + arraysize(kKeyId)),
         iv_(kIv, kIv + arraysize(kIv)),
         normal_subsample_entries_(
             kSubsampleEntriesNormal,
             kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) {
   }
 
  protected:
   void CreateSession(const std::vector<uint8>& key_id) {
-    reference_id_ = 6;
+    session_id_ = 6;
     DCHECK(!key_id.empty());
-    EXPECT_CALL(*this, OnSessionCreated(reference_id_, StrNe(std::string())));
-    EXPECT_CALL(*this, OnSessionMessage(reference_id_, key_id, ""));
+    EXPECT_CALL(*this, OnSessionCreated(session_id_, StrNe(std::string())));
+    EXPECT_CALL(*this, OnSessionMessage(session_id_, key_id, ""));
     EXPECT_TRUE(decryptor_.CreateSession(
-        reference_id_, std::string(), &key_id[0], key_id.size()));
+        session_id_, std::string(), &key_id[0], key_id.size()));
   }
 
   enum AddKeyExpectation {
     KEY_ADDED,
     KEY_ERROR
   };
 
   void AddKeyAndExpect(const std::string& key, AddKeyExpectation result) {
     DCHECK(!key.empty());
 
     if (result == KEY_ADDED) {
-      EXPECT_CALL(*this, OnSessionReady(reference_id_));
+      EXPECT_CALL(*this, OnSessionReady(session_id_));
     } else if (result == KEY_ERROR) {
       EXPECT_CALL(*this,
-                  OnSessionError(reference_id_, MediaKeys::kUnknownError, 0));
+                  OnSessionError(session_id_, MediaKeys::kUnknownError, 0));
     } else {
       NOTREACHED();
     }
 
-    decryptor_.UpdateSession(reference_id_,
-                             reinterpret_cast<const uint8*>(key.c_str()),
-                             key.length());
+    decryptor_.UpdateSession(
+        session_id_, reinterpret_cast<const uint8*>(key.c_str()), key.length());
   }
 
   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
                                      const scoped_refptr<DecoderBuffer>&));
 
   enum DecryptExpectation {
     SUCCESS,
     DATA_MISMATCH,
     DATA_AND_SIZE_MISMATCH,
     DECRYPT_ERROR
@@ skipping 31 matching lines @@
       case DATA_AND_SIZE_MISMATCH:
         EXPECT_NE(plain_text.size(), decrypted_text.size());
         break;
       case DECRYPT_ERROR:
         EXPECT_TRUE(decrypted_text.empty());
         break;
     }
   }
 
   MOCK_METHOD2(OnSessionCreated,
-               void(uint32 reference_id, const std::string& session_id));
+               void(uint32 session_id, const std::string& web_session_id));
   MOCK_METHOD3(OnSessionMessage,
-               void(uint32 reference_id,
+               void(uint32 session_id,
                     const std::vector<uint8>& message,
                     const std::string& default_url));
-  MOCK_METHOD1(OnSessionReady, void(uint32 reference_id));
-  MOCK_METHOD1(OnSessionClosed, void(uint32 reference_id));
+  MOCK_METHOD1(OnSessionReady, void(uint32 session_id));
+  MOCK_METHOD1(OnSessionClosed, void(uint32 session_id));
   MOCK_METHOD3(OnSessionError,
-               void(uint32 reference_id, MediaKeys::KeyError, int system_code));
+               void(uint32 session_id, MediaKeys::KeyError, int system_code));
 
   AesDecryptor decryptor_;
-  uint32 reference_id_;
+  uint32 session_id_;
   AesDecryptor::DecryptCB decrypt_cb_;
 
   // 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) {
-  reference_id_ = 8;
-  EXPECT_CALL(*this, OnSessionMessage(reference_id_, IsEmpty(), ""));
-  EXPECT_CALL(*this, OnSessionCreated(reference_id_, StrNe(std::string())));
-  EXPECT_TRUE(decryptor_.CreateSession(reference_id_, std::string(), NULL, 0));
+  session_id_ = 8;
+  EXPECT_CALL(*this, OnSessionMessage(session_id_, IsEmpty(), ""));
+  EXPECT_CALL(*this, OnSessionCreated(session_id_, StrNe(std::string())));
+  EXPECT_TRUE(decryptor_.CreateSession(session_id_, std::string(), NULL, 0));
 }
 
 TEST_F(AesDecryptorTest, MultipleCreateSession) {
-  uint32 reference_id1 = 10;
-  EXPECT_CALL(*this, OnSessionMessage(reference_id1, IsEmpty(), ""));
-  EXPECT_CALL(*this, OnSessionCreated(reference_id1, StrNe(std::string())));
-  EXPECT_TRUE(decryptor_.CreateSession(reference_id1, std::string(), NULL, 0));
+  uint32 session_id1 = 10;
+  EXPECT_CALL(*this, OnSessionMessage(session_id1, IsEmpty(), ""));
+  EXPECT_CALL(*this, OnSessionCreated(session_id1, StrNe(std::string())));
+  EXPECT_TRUE(decryptor_.CreateSession(session_id1, std::string(), NULL, 0));
 
-  uint32 reference_id2 = 11;
-  EXPECT_CALL(*this, OnSessionMessage(reference_id2, IsEmpty(), ""));
-  EXPECT_CALL(*this, OnSessionCreated(reference_id2, StrNe(std::string())));
-  EXPECT_TRUE(decryptor_.CreateSession(reference_id2, std::string(), NULL, 0));
+  uint32 session_id2 = 11;
+  EXPECT_CALL(*this, OnSessionMessage(session_id2, IsEmpty(), ""));
+  EXPECT_CALL(*this, OnSessionCreated(session_id2, StrNe(std::string())));
+  EXPECT_TRUE(decryptor_.CreateSession(session_id2, std::string(), NULL, 0));
 
-  uint32 reference_id3 = 23;
-  EXPECT_CALL(*this, OnSessionMessage(reference_id3, IsEmpty(), ""));
-  EXPECT_CALL(*this, OnSessionCreated(reference_id3, StrNe(std::string())));
-  EXPECT_TRUE(decryptor_.CreateSession(reference_id3, std::string(), NULL, 0));
+  uint32 session_id3 = 23;
+  EXPECT_CALL(*this, OnSessionMessage(session_id3, IsEmpty(), ""));
+  EXPECT_CALL(*this, OnSessionCreated(session_id3, StrNe(std::string())));
+  EXPECT_TRUE(decryptor_.CreateSession(session_id3, std::string(), NULL, 0));
 }
 
 TEST_F(AesDecryptorTest, NormalDecryption) {
   CreateSession(key_id_);
   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, 0, no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 }
 
@@ skipping 303 matching lines @@
       "      \"kty\": \"oct\","
       "      \"kid\": \"\","
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   AddKeyAndExpect(kJwksWithEmptyKeyId, KEY_ERROR);
 }
 
 }  // namespace media