Rename EME WD call parameters

media/filters/pipeline_integration_test.cc

Index: media/filters/pipeline_integration_test.cc
diff --git a/media/filters/pipeline_integration_test.cc b/media/filters/pipeline_integration_test.cc
index afff6a9910310306d72b46ae29a668ee6f62d5ac..4a1d8167b1a98613aa3f84cf9ecf5ee714fd3ae4 100644
--- a/media/filters/pipeline_integration_test.cc
+++ b/media/filters/pipeline_integration_test.cc
@@ -80,19 +80,19 @@ class FakeEncryptedMedia {
    public:
     virtual ~AppBase() {}
 
-    virtual void SetSession(uint32 reference_id,
-                            const std::string& session_id) = 0;
+    virtual void SetSession(uint32 session_id,

[ddorwin, 2013/12/05 00:44:52]

Should we rename these? At least to On..., right?

[jrummell, 2013/12/06 23:42:35]

Updated to match full names.

+                            const std::string& web_session_id) = 0;
 
-    virtual void Message(uint32 reference_id,
+    virtual void Message(uint32 session_id,
                          const std::vector<uint8>& message,
                          const std::string& destination_url) = 0;
 
-    virtual void Ready(uint32 reference_id) = 0;
+    virtual void Ready(uint32 session_id) = 0;
 
-    virtual void Closed(uint32 reference_id) = 0;
+    virtual void Closed(uint32 session_id) = 0;
 
     // Errors are not expected unless overridden.
-    virtual void Error(uint32 reference_id,
+    virtual void Error(uint32 session_id,
                        MediaKeys::KeyError error_code,
                        int system_code) {
       FAIL() << "Unexpected Key Error";
@@ -118,28 +118,28 @@ class FakeEncryptedMedia {
   }
 
   // Callbacks for firing session events. Delegate to |app_|.
-  void SetSession(uint32 reference_id, const std::string& session_id) {
-    app_->SetSession(reference_id, session_id);
+  void SetSession(uint32 session_id, const std::string& web_session_id) {
+    app_->SetSession(session_id, web_session_id);
   }
 
-  void Message(uint32 reference_id,
+  void Message(uint32 session_id,
                const std::vector<uint8>& message,
                const std::string& destination_url) {
-    app_->Message(reference_id, message, destination_url);
+    app_->Message(session_id, message, destination_url);
   }
 
-  void Ready(uint32 reference_id) {
-    app_->Ready(reference_id);
+  void Ready(uint32 session_id) {
+    app_->Ready(session_id);
   }
 
-  void Closed(uint32 reference_id) {
-    app_->Closed(reference_id);
+  void Closed(uint32 session_id) {
+    app_->Closed(session_id);
   }
 
-  void Error(uint32 reference_id,
+  void Error(uint32 session_id,
              MediaKeys::KeyError error_code,
              int system_code) {
-    app_->Error(reference_id, error_code, system_code);
+    app_->Error(session_id, error_code, system_code);
   }
 
   void NeedKey(const std::string& type,
@@ -155,40 +155,40 @@ class FakeEncryptedMedia {
 // Provides |kSecretKey| in response to needkey.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
-  KeyProvidingApp() : current_reference_id_(0) {}
+  KeyProvidingApp() : current_session_id_(0) {}
 
-  virtual void SetSession(uint32 reference_id,
-                          const std::string& session_id) OVERRIDE {
-    EXPECT_GT(reference_id, 0u);
-    EXPECT_FALSE(session_id.empty());
+  virtual void SetSession(uint32 session_id,
+                          const std::string& web_session_id) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
+    EXPECT_FALSE(web_session_id.empty());
   }
 
-  virtual void Message(uint32 reference_id,
+  virtual void Message(uint32 session_id,
                        const std::vector<uint8>& message,
                        const std::string& default_url) OVERRIDE {
-    EXPECT_GT(reference_id, 0u);
+    EXPECT_GT(session_id, 0u);
     EXPECT_FALSE(message.empty());
 
-    current_reference_id_ = reference_id;
+    current_session_id_ = session_id;
   }
 
-  virtual void Ready(uint32 reference_id) OVERRIDE {
-    EXPECT_GT(reference_id, 0u);
+  virtual void Ready(uint32 session_id) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
   }
 
-  virtual void Closed(uint32 reference_id) OVERRIDE {
-    EXPECT_GT(reference_id, 0u);
+  virtual void Closed(uint32 session_id) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
   }
 
   virtual void NeedKey(const std::string& type,
                        const std::vector<uint8>& init_data,
                        AesDecryptor* decryptor) OVERRIDE {
-    if (current_reference_id_ == 0u) {
+    if (current_session_id_ == 0u) {
       EXPECT_TRUE(
           decryptor->CreateSession(12, type, kInitData, arraysize(kInitData)));
     }
 
-    EXPECT_EQ(current_reference_id_, 12u);
+    EXPECT_EQ(current_session_id_, 12u);
 
     // 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
@@ -203,40 +203,40 @@ class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
     // Convert key into a JSON structure and then add it.
     std::string jwk = GenerateJWKSet(
         kSecretKey, arraysize(kSecretKey), key_id, key_id_length);
-    decryptor->UpdateSession(current_reference_id_,
+    decryptor->UpdateSession(current_session_id_,
                              reinterpret_cast<const uint8*>(jwk.data()),
                              jwk.size());
   }
 
-  uint32 current_reference_id_;
+  uint32 current_session_id_;
 };
 
 // Ignores needkey and does not perform a license request
 class NoResponseApp : public FakeEncryptedMedia::AppBase {
  public:
-   virtual void SetSession(uint32 reference_id,
-                           const std::string& session_id) OVERRIDE {
-     EXPECT_GT(reference_id, 0u);
-     EXPECT_FALSE(session_id.empty());
-   }
-
-   virtual void Message(uint32 reference_id,
-                        const std::vector<uint8>& message,
-                        const std::string& default_url) OVERRIDE {
-     EXPECT_GT(reference_id, 0u);
-     EXPECT_FALSE(message.empty());
-     FAIL() << "Unexpected KeyMessage";
-   }
-
-   virtual void Ready(uint32 reference_id) OVERRIDE {
-     EXPECT_GT(reference_id, 0u);
-     FAIL() << "Unexpected Ready";
-   }
-
-   virtual void Closed(uint32 reference_id) OVERRIDE {
-     EXPECT_GT(reference_id, 0u);
-     FAIL() << "Unexpected Closed";
-   }
+  virtual void SetSession(uint32 session_id,
+                          const std::string& web_session_id) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
+    EXPECT_FALSE(web_session_id.empty());
+  }
+
+  virtual void Message(uint32 session_id,
+                       const std::vector<uint8>& message,
+                       const std::string& default_url) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
+    EXPECT_FALSE(message.empty());
+    FAIL() << "Unexpected KeyMessage";
+  }
+
+  virtual void Ready(uint32 session_id) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
+    FAIL() << "Unexpected Ready";
+  }
+
+  virtual void Closed(uint32 session_id) OVERRIDE {
+    EXPECT_GT(session_id, 0u);
+    FAIL() << "Unexpected Closed";
+  }
 
   virtual void NeedKey(const std::string& type,
                        const std::vector<uint8>& init_data,