Add |legacy_destination_url| back to SessionMessage for EME

media/cdm/ppapi/cdm_adapter.h

 // 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.
 
 #ifndef MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
 #define MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 97 matching lines @@
   void QueryOutputProtectionStatus() override;
   void OnDeferredInitializationDone(cdm::StreamType stream_type,
                                     cdm::Status decoder_status) override;
   cdm::FileIO* CreateFileIO(cdm::FileIOClient* client) override;
 
   // cdm::Host_7 implementation.
   void OnSessionMessage(const char* session_id,
                         uint32_t session_id_size,
                         cdm::MessageType message_type,
                         const char* message,
-                        uint32_t message_size) override;
+                        uint32_t message_size,
+                        const char* legacy_destination_url,
+                        uint32_t legacy_destination_url_size) override;
   void OnSessionKeysChange(const char* session_id,
                            uint32_t session_id_size,
                            bool has_additional_usable_key,
                            const cdm::KeyInformation* keys_info,
                            uint32_t keys_info_count) override;
   void OnLegacySessionError(const char* session_id,
                             uint32_t session_id_size,
                             cdm::Error error,
                             uint32_t system_code,
                             const char* error_message,
@@ skipping 28 matching lines @@
     OUTPUT_PROTECTION_MAX = 3
   };
 
   typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
   typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
   typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;
 
   struct SessionError {
     SessionError(cdm::Error error,
                  uint32_t system_code,
-                 std::string error_description);
+                 const std::string& error_description);
     cdm::Error error;
     uint32_t system_code;
     std::string error_description;
   };
 
+  struct SessionMessage {
+    SessionMessage(const std::string& session_id,
+                   cdm::MessageType message_type,
+                   const char* message,
+                   uint32_t message_size,
+                   const std::string& legacy_destination_url);
+    std::string session_id;
+    cdm::MessageType message_type;
+    std::vector<uint8_t> message;
+    std::string legacy_destination_url;
+  };
+
   bool CreateCdmInstance(const std::string& key_system);
 
   // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
   // <code>callback_factory_</code> to ensure that calls into
   // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
   void SendPromiseResolvedInternal(int32_t result, uint32_t promise_id);
   void SendPromiseResolvedWithSessionInternal(int32_t result,
                                               uint32_t promise_id,
                                               const std::string& session_id);
   void SendPromiseRejectedInternal(int32_t result,
                                    uint32_t promise_id,
                                    const SessionError& error);
   void SendSessionMessageInternal(int32_t result,
-                                  const std::string& session_id,
-                                  cdm::MessageType message_type,
-                                  const std::vector<uint8_t>& message);
+                                  const SessionMessage& message);
   void SendSessionClosedInternal(int32_t result, const std::string& session_id);
   void SendSessionErrorInternal(int32_t result,
                                 const std::string& session_id,
                                 const SessionError& error);
   void SendSessionKeysChangeInternal(
       int32_t result,
       const std::string& session_id,
       bool has_additional_usable_key,
       const std::vector<PP_KeyInformation>& key_info);
   void SendExpirationChangeInternal(int32_t result,
@@ skipping 88 matching lines @@
 
   uint32_t last_read_file_size_kb_;
   bool file_size_uma_reported_;
 
   DISALLOW_COPY_AND_ASSIGN(CdmAdapter);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_CDM_PPAPI_CDM_ADAPTER_H_