[eme] Break mojo connection during call

media/base/mock_filters.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 "media/base/mock_filters.h"
 
 #include "base/logging.h"
+#include "media/base/cdm_config.h"
 
 using ::testing::_;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 MATCHER(NotEmpty, "") {
   return !arg.empty();
 }
 
 namespace media {
@@ skipping 155 matching lines @@
     EXPECT_CALL(*this, resolve(_)).Times(0);
     EXPECT_CALL(*this, reject(_, _, NotEmpty()));
   }
 }
 
 MockCdmSessionPromise::~MockCdmSessionPromise() {
   // The EXPECT calls will verify that the promise is in fact fulfilled.
   MarkPromiseSettled();
 }
 
+MockCdm::MockCdm() {}
+
+MockCdm::~MockCdm() {}
+
+void MockCdm::SetServerCertificate(const std::vector<uint8_t>& certificate,
+                                   std::unique_ptr<SimpleCdmPromise> promise) {
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  OnSetServerCertificate(certificate, promise_id);
+}
+
+void MockCdm::CreateSessionAndGenerateRequest(
+    CdmSessionType session_type,
+    EmeInitDataType init_data_type,
+    const std::vector<uint8_t>& init_data,
+    std::unique_ptr<NewSessionCdmPromise> promise) {
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  OnCreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
+                                    promise_id);
+}
+
+void MockCdm::LoadSession(CdmSessionType session_type,
+                          const std::string& session_id,
+                          std::unique_ptr<NewSessionCdmPromise> promise) {
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  OnLoadSession(session_type, session_id, promise_id);
+}
+
+void MockCdm::UpdateSession(const std::string& session_id,
+                            const std::vector<uint8_t>& response,
+                            std::unique_ptr<SimpleCdmPromise> promise) {
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  OnUpdateSession(session_id, response, promise_id);
+}
+
+void MockCdm::CloseSession(const std::string& session_id,
+                           std::unique_ptr<SimpleCdmPromise> promise) {
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  OnCloseSession(session_id, promise_id);
+}
+
+void MockCdm::RemoveSession(const std::string& session_id,
+                            std::unique_ptr<SimpleCdmPromise> promise) {
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
+  OnRemoveSession(session_id, promise_id);
+}
+
+void MockCdm::ResolvePromise(uint32_t promise_id) {
+  cdm_promise_adapter_.ResolvePromise(promise_id);
+}
+
+void MockCdm::ResolvePromiseWithSession(uint32_t promise_id,
+                                        const std::string& session_id) {
+  cdm_promise_adapter_.ResolvePromise(promise_id, session_id);
+}
+
+void MockCdm::RejectPromise(uint32_t promise_id) {
+  cdm_promise_adapter_.RejectPromise(promise_id, CdmPromise::UNKNOWN_ERROR, 23,
+                                     "Promise rejected");
+}
+
+void MockCdm::SetCallbacks(
+    const SessionMessageCB& session_message_cb,
+    const SessionClosedCB& session_closed_cb,
+    const SessionKeysChangeCB& session_keys_change_cb,
+    const SessionExpirationUpdateCB& session_expiration_update_cb) {
+  session_message_cb_ = session_message_cb;
+  session_closed_cb_ = session_closed_cb;
+  session_keys_change_cb_ = session_keys_change_cb;
+  session_expiration_update_cb_ = session_expiration_update_cb;
+}
+
+void MockCdm::CallSessionMessageCB(
+    const std::string& session_id,
+    ContentDecryptionModule::MessageType message_type,
+    const std::vector<uint8_t>& message) {
+  session_message_cb_.Run(session_id, message_type, message);
+}
+
+void MockCdm::CallSessionClosedCB(const std::string& session_id) {
+  session_closed_cb_.Run(session_id);
+}
+
+void MockCdm::CallSessionKeysChangeCB(const std::string& session_id,
+                                      bool has_additional_usable_key,
+                                      CdmKeysInfo keys_info) {
+  session_keys_change_cb_.Run(session_id, has_additional_usable_key,
+                              std::move(keys_info));
+}
+
+void MockCdm::CallSessionExpirationUpdateCB(const std::string& session_id,
+                                            base::Time new_expiry_time) {
+  session_expiration_update_cb_.Run(session_id, new_expiry_time);
+}
+
+MockCdmFactory::MockCdmFactory() {}
+
+MockCdmFactory::~MockCdmFactory() {}
+
 MockStreamParser::MockStreamParser() {}
 
 MockStreamParser::~MockStreamParser() {}
 
 }  // namespace media