EME: Remove obsolete legacy APIs related to versions of prefixed EME

media/test/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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 190 matching lines @@
 class FakeEncryptedMedia {
  public:
   // Defines the behavior of the "app" that responds to EME events.
   class AppBase {
    public:
     virtual ~AppBase() {}
 
     virtual void OnSessionMessage(const std::string& session_id,
                                   MediaKeys::MessageType message_type,
                                   const std::vector<uint8_t>& message,
-                                  const GURL& legacy_destination_url,
                                   AesDecryptor* decryptor) = 0;
 
     virtual void OnSessionClosed(const std::string& session_id) = 0;
 
     virtual void OnSessionKeysChange(const std::string& session_id,
                                      bool has_additional_usable_key,
                                      CdmKeysInfo keys_info) = 0;
 
-    // Errors are not expected unless overridden.
-    virtual void OnLegacySessionError(const std::string& session_id,
-                                      const std::string& error_name,
-                                      uint32_t system_code,
-                                      const std::string& error_message) {
-      FAIL() << "Unexpected Key Error";
-    }
-
     virtual void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                           const std::vector<uint8_t>& init_data,
                                           AesDecryptor* decryptor) = 0;
   };
 
   FakeEncryptedMedia(AppBase* app)
       : decryptor_(new AesDecryptor(
             GURL::EmptyGURL(),
             base::Bind(&FakeEncryptedMedia::OnSessionMessage,
                        base::Unretained(this)),
             base::Bind(&FakeEncryptedMedia::OnSessionClosed,
                        base::Unretained(this)),
             base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
                        base::Unretained(this)))),
         cdm_context_(decryptor_.get()),
         app_(app) {}
 
   CdmContext* GetCdmContext() { return &cdm_context_; }
 
   // Callbacks for firing session events. Delegate to |app_|.
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
-                        const std::vector<uint8_t>& message,
-                        const GURL& legacy_destination_url) {
-    app_->OnSessionMessage(session_id, message_type, message,
-                           legacy_destination_url, decryptor_.get());
+                        const std::vector<uint8_t>& message) {
+    app_->OnSessionMessage(session_id, message_type, message, decryptor_.get());
   }
 
   void OnSessionClosed(const std::string& session_id) {
     app_->OnSessionClosed(session_id);
   }
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) {
     app_->OnSessionKeysChange(session_id, has_additional_usable_key,
                               std::move(keys_info));
   }
 
-  void OnLegacySessionError(const std::string& session_id,
-                            const std::string& error_name,
-                            uint32_t system_code,
-                            const std::string& error_message) {
-    app_->OnLegacySessionError(session_id, error_name, system_code,
-                               error_message);
-  }
-
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data) {
     app_->OnEncryptedMediaInitData(init_data_type, init_data, decryptor_.get());
   }
 
  private:
   class TestCdmContext : public CdmContext {
    public:
     TestCdmContext(Decryptor* decryptor) : decryptor_(decryptor) {}
 
@@ skipping 49 matching lines @@
             base::Bind(&KeyProvidingApp::OnResolveWithSession,
                        base::Unretained(this), expected),
             base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
                        expected)));
     return promise;
   }
 
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
                         const std::vector<uint8_t>& message,
-                        const GURL& legacy_destination_url,
                         AesDecryptor* decryptor) override {
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
     EXPECT_EQ(current_session_id_, session_id);
     EXPECT_EQ(MediaKeys::MessageType::LICENSE_REQUEST, message_type);
 
     // Extract the key ID from |message|. For Clear Key this is a JSON object
     // containing a set of "kids". There should only be 1 key ID in |message|.
     std::string message_string(message.begin(), message.end());
     KeyIdList key_ids;
@@ skipping 101 matching lines @@
 
   uint32_t num_distinct_need_key_calls_;
 };
 
 // Ignores the encrypted event and does not perform a license request.
 class NoResponseApp : public FakeEncryptedMedia::AppBase {
  public:
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
                         const std::vector<uint8_t>& message,
-                        const GURL& legacy_destination_url,
                         AesDecryptor* decryptor) override {
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
     FAIL() << "Unexpected Message";
   }
 
   void OnSessionClosed(const std::string& session_id) override {
     EXPECT_FALSE(session_id.empty());
     FAIL() << "Unexpected Closed";
   }
@@ skipping 1921 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media