[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"
 
 using ::testing::_;
 using ::testing::Return;
@@ skipping 162 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) {
+  OnSetServerCertificate(certificate, promise);
+}
+
+void MockCdm::CreateSessionAndGenerateRequest(
+    CdmSessionType session_type,
+    EmeInitDataType init_data_type,
+    const std::vector<uint8_t>& init_data,
+    std::unique_ptr<NewSessionCdmPromise> promise) {
+  OnCreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
+                                    promise);
+}
+
+void MockCdm::LoadSession(CdmSessionType session_type,
+                          const std::string& session_id,
+                          std::unique_ptr<NewSessionCdmPromise> promise) {
+  OnLoadSession(session_type, session_id, promise);
+}
+
+void MockCdm::UpdateSession(const std::string& session_id,
+                            const std::vector<uint8_t>& response,
+                            std::unique_ptr<SimpleCdmPromise> promise) {
+  OnUpdateSession(session_id, response, promise);
+}
+
+void MockCdm::CloseSession(const std::string& session_id,
+                           std::unique_ptr<SimpleCdmPromise> promise) {
+  OnCloseSession(session_id, promise);
+}
+
+void MockCdm::RemoveSession(const std::string& session_id,
+                            std::unique_ptr<SimpleCdmPromise> promise) {
+  OnRemoveSession(session_id, promise);
+}
+
+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() {}
+
+void MockCdmFactory::Create(
+    const std::string& key_system,
+    const GURL& security_origin,
+    const CdmConfig& cdm_config,
+    const SessionMessageCB& session_message_cb,
+    const SessionClosedCB& session_closed_cb,
+    const SessionKeysChangeCB& session_keys_change_cb,
+    const SessionExpirationUpdateCB& session_expiration_update_cb,
+    const CdmCreatedCB& cdm_created_cb) {
+  // If no CDM provided, notify that Create() failed.
+  if (!cdm_) {
+    cdm_created_cb.Run(nullptr, "CDM creation failed");
+    return;
+  }
+
+  // Since there is a CDM, call |before_creation_cb_| first.
+  if (!before_creation_cb_.is_null())
+    before_creation_cb_.Run();
+
+  // Update the callbacks on the MockCDM, and then return it.
+  cdm_->SetCallbacks(session_message_cb, session_closed_cb,
+                     session_keys_change_cb, session_expiration_update_cb);

[xhwang, 2017/01/06 06:21:36]

Can we create the CDM within this factory so that we can pass these callbacks in
MockCdm's ctor? Then we don't need SetCallbacks().

Then, instead of having to pass in a CDM in Initialize(), we can provide a get()
function to get a raw pointer or a  ref to the created CDM, so the test can set
expectations on it.

[jrummell, 2017/01/06 18:59:28]

Done.

+  cdm_created_cb.Run(std::move(cdm_), "");
+}
+
+void MockCdmFactory::Initialize(const scoped_refptr<MockCdm>& cdm,
+                                const base::Closure& before_creation_cb) {
+  cdm_ = cdm;
+  before_creation_cb_ = before_creation_cb;

[xhwang, 2017/01/06 06:21:36]

If we create the CDM within this factory, we don't need pass in the CDM here. So
this function is more like set_before_creation_cb() instead of Initialize().

[jrummell, 2017/01/06 18:59:28]

Done.

+}
+
 MockStreamParser::MockStreamParser() {}
 
 MockStreamParser::~MockStreamParser() {}
 
 }  // namespace media