media: Reject promises and close sessions in MojoCdm destructor

media/mojo/clients/mojo_cdm_unittest.cc

 // Copyright 2016 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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 49 matching lines @@
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
     0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 };
 
 }  // namespace
 
 class MojoCdmTest : public ::testing::Test {
  public:
   enum ExpectedResult {
     SUCCESS,
-    CONNECTION_ERROR_BEFORE,
-    CONNECTION_ERROR_DURING,
-    FAILURE
+    FAILURE,                  // Operation fails immediately.
+    PENDING,                  // Operation never completes.
+    CONNECTION_ERROR_BEFORE,  // Connection error happened before operation.
+    CONNECTION_ERROR_DURING,  // Connection error happens during operation.
   };
 
   MojoCdmTest()
       : mojo_cdm_service_(base::MakeUnique<MojoCdmService>(
             mojo_cdm_service_context_.GetWeakPtr(),
             &cdm_factory_)),
         cdm_binding_(mojo_cdm_service_.get()) {}
 
   virtual ~MojoCdmTest() {}
 
   void Initialize(ExpectedResult expected_result) {
+    // TODO(xhwang): Add pending init support.
+    DCHECK_NE(PENDING, expected_result);
+
     mojom::ContentDecryptionModulePtr remote_cdm;
     auto cdm_request = mojo::MakeRequest(&remote_cdm);
 
     cdm_binding_.Bind(std::move(cdm_request));
 
     std::string key_system;
     if (expected_result == CONNECTION_ERROR_BEFORE) {
       // Break the connection before the call.
       ForceConnectionError();
     } else if (expected_result != FAILURE) {
@@ skipping 86 matching lines @@
     mojo_cdm_->CreateSessionAndGenerateRequest(
         session_type, data_type, key_id,
         base::MakeUnique<MockCdmSessionPromise>(expected_result == SUCCESS,
                                                 &created_session_id));
     base::RunLoop().RunUntilIdle();
 
     // If the session was "created" ...
     if (expected_result == SUCCESS) {
       // Returned session ID must match the session ID provided.
       EXPECT_EQ(session_id, created_session_id);
-
-      // MojoCdm expects the session to be closed, so invoke SessionClosedCB
-      // to "close" it.
-      EXPECT_CALL(cdm_client_, OnSessionClosed(session_id));
-      remote_cdm_->CallSessionClosedCB(session_id);
       base::RunLoop().RunUntilIdle();
     }
   }
 
   void LoadSessionAndExpect(const std::string& session_id,
                             ExpectedResult expected_result) {
     const CdmSessionType session_type =
         CdmSessionType::PERSISTENT_LICENSE_SESSION;
     std::string loaded_session_id;
 
@@ skipping 86 matching lines @@
     switch (expected_result) {
       case SUCCESS:
         promise->resolve();
         break;
 
       case FAILURE:
         promise->reject(media::CdmPromise::UNKNOWN_ERROR, 0,
                         "Promise rejected");
         break;
 
+      case PENDING:
+        // Store the promise and never fulfill it.
+        pending_simple_cdm_promise_ = std::move(promise);
+        break;
+
       case CONNECTION_ERROR_BEFORE:
         // Connection should be broken before this is called.
         NOTREACHED();
         break;
 
       case CONNECTION_ERROR_DURING:
         ForceConnectionError();
 
         // Now that the connection is broken the promise result won't be passed
         // back. However, since we check that every promise is fulfilled, we
@@ skipping 11 matching lines @@
     switch (expected_result) {
       case SUCCESS:
         promise->resolve(session_id);
         break;
 
       case FAILURE:
         promise->reject(media::CdmPromise::UNKNOWN_ERROR, 0,
                         "Promise rejected");
         break;
 
+      case PENDING:
+        // Store the promise and never fulfill it.
+        pending_new_session_cdm_promise_ = std::move(promise);
+        break;
+
       case CONNECTION_ERROR_BEFORE:
         // Connection should be broken before this is called.
         NOTREACHED();
         break;
 
       case CONNECTION_ERROR_DURING:
         ForceConnectionError();
 
         // Now that the connection is broken the promise result won't be passed
         // back. However, since we check that every promise is fulfilled, we
         // need to do something with this promise. Resolve the promise to
         // fulfill it, but note that the original caller will get back a
         // failed promise due to the connection being broken.
         promise->resolve(session_id);
         break;
     }
   }
 
   // Fixture members.
   base::TestMessageLoop message_loop_;
 
   // |remote_cdm_| represents the CDM at the end of the mojo message pipe.
   MockCdm* remote_cdm_;
   MockCdmFactory cdm_factory_;
 
   MojoCdmServiceContext mojo_cdm_service_context_;
   StrictMock<MockCdmClient> cdm_client_;
 
+  // Declared before |mojo_cdm_| so they are destroyed after it.
+  std::unique_ptr<SimpleCdmPromise> pending_simple_cdm_promise_;
+  std::unique_ptr<NewSessionCdmPromise> pending_new_session_cdm_promise_;
+
   std::unique_ptr<MojoCdmService> mojo_cdm_service_;
   mojo::Binding<mojom::ContentDecryptionModule> cdm_binding_;
   scoped_refptr<ContentDecryptionModule> mojo_cdm_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MojoCdmTest);
 };
 
 TEST_F(MojoCdmTest, Create_Success) {
   Initialize(SUCCESS);
@@ skipping 16 matching lines @@
   Initialize(SUCCESS);
   SetServerCertificateAndExpect(certificate, SUCCESS);
 }
 
 TEST_F(MojoCdmTest, SetServerCertificate_Failure) {
   const std::vector<uint8_t> certificate = {1, 2, 3, 4, 5};
   Initialize(SUCCESS);
   SetServerCertificateAndExpect(certificate, FAILURE);
 }
 
+TEST_F(MojoCdmTest, SetServerCertificate_Pending) {
+  const std::vector<uint8_t> certificate = {1, 2, 3, 4, 5};
+  Initialize(SUCCESS);
+  SetServerCertificateAndExpect(certificate, PENDING);
+}
+
 TEST_F(MojoCdmTest, SetServerCertificate_ConnectionErrorBefore) {
   const std::vector<uint8_t> certificate = {3, 4};
   Initialize(SUCCESS);
   SetServerCertificateAndExpect(certificate, CONNECTION_ERROR_BEFORE);
 }
 
 TEST_F(MojoCdmTest, SetServerCertificate_ConnectionErrorDuring) {
   const std::vector<uint8_t> certificate = {10, 11, 12};
   Initialize(SUCCESS);
   SetServerCertificateAndExpect(certificate, CONNECTION_ERROR_DURING);
 }
 
 TEST_F(MojoCdmTest, CreateSession_Success) {
   const std::string session_id = "create1";
   Initialize(SUCCESS);
   CreateSessionAndExpect(session_id, SUCCESS);
+
+  // Created session should always be closed!
+  EXPECT_CALL(cdm_client_, OnSessionClosed(session_id));
 }
 
 TEST_F(MojoCdmTest, CreateSession_Failure) {
   const std::string session_id = "create2";
   Initialize(SUCCESS);
   CreateSessionAndExpect(session_id, FAILURE);
 }
 
+TEST_F(MojoCdmTest, CreateSession_Pending) {
+  const std::string session_id = "create2";
+  Initialize(SUCCESS);
+  CreateSessionAndExpect(session_id, PENDING);
+}
+
 TEST_F(MojoCdmTest, CreateSession_ConnectionErrorBefore) {
   const std::string session_id = "create3";
   Initialize(SUCCESS);
   CreateSessionAndExpect(session_id, CONNECTION_ERROR_BEFORE);
 }
 
 TEST_F(MojoCdmTest, CreateSession_ConnectionErrorDuring) {
   const std::string session_id = "create4";
   Initialize(SUCCESS);
   CreateSessionAndExpect(session_id, CONNECTION_ERROR_DURING);
 }
 
 TEST_F(MojoCdmTest, LoadSession_Success) {
   const std::string session_id = "load1";
   Initialize(SUCCESS);
   LoadSessionAndExpect(session_id, SUCCESS);
 }
 
 TEST_F(MojoCdmTest, LoadSession_Failure) {
   const std::string session_id = "load2";
   Initialize(SUCCESS);
   LoadSessionAndExpect(session_id, FAILURE);
 }
 
+TEST_F(MojoCdmTest, LoadSession_Pending) {
+  const std::string session_id = "load2";
+  Initialize(SUCCESS);
+  LoadSessionAndExpect(session_id, PENDING);
+}
+
 TEST_F(MojoCdmTest, LoadSession_ConnectionErrorBefore) {
   const std::string session_id = "load3";
   Initialize(SUCCESS);
   LoadSessionAndExpect(session_id, CONNECTION_ERROR_BEFORE);
 }
 
 TEST_F(MojoCdmTest, LoadSession_ConnectionErrorDuring) {
   const std::string session_id = "load4";
   Initialize(SUCCESS);
   LoadSessionAndExpect(session_id, CONNECTION_ERROR_DURING);
 }
 
 TEST_F(MojoCdmTest, UpdateSession_Success) {
   const std::string session_id = "update1";
   Initialize(SUCCESS);
   UpdateSessionAndExpect(session_id, SUCCESS);
 }
 
 TEST_F(MojoCdmTest, UpdateSession_Failure) {
   const std::string session_id = "update2";
   Initialize(SUCCESS);
   UpdateSessionAndExpect(session_id, FAILURE);
 }
 
+TEST_F(MojoCdmTest, UpdateSession_Pending) {
+  const std::string session_id = "update2";
+  Initialize(SUCCESS);
+  UpdateSessionAndExpect(session_id, PENDING);
+}
+
 TEST_F(MojoCdmTest, UpdateSession_ConnectionErrorBefore) {
   const std::string session_id = "update3";
   Initialize(SUCCESS);
   UpdateSessionAndExpect(session_id, CONNECTION_ERROR_BEFORE);
 }
 
 TEST_F(MojoCdmTest, UpdateSession_ConnectionErrorDuring) {
   const std::string session_id = "update4";
   Initialize(SUCCESS);
   UpdateSessionAndExpect(session_id, CONNECTION_ERROR_DURING);
 }
 
 TEST_F(MojoCdmTest, CloseSession_Success) {
   const std::string session_id = "close1";
   Initialize(SUCCESS);
   CloseSessionAndExpect(session_id, SUCCESS);
 }
 
 TEST_F(MojoCdmTest, CloseSession_Failure) {
   const std::string session_id = "close2";
   Initialize(SUCCESS);
   CloseSessionAndExpect(session_id, FAILURE);
 }
 
+TEST_F(MojoCdmTest, CloseSession_Pending) {
+  const std::string session_id = "close2";
+  Initialize(SUCCESS);
+  CloseSessionAndExpect(session_id, PENDING);
+}
+
 TEST_F(MojoCdmTest, CloseSession_ConnectionErrorBefore) {
   const std::string session_id = "close3";
   Initialize(SUCCESS);
   CloseSessionAndExpect(session_id, CONNECTION_ERROR_BEFORE);
 }
 
 TEST_F(MojoCdmTest, CloseSession_ConnectionErrorDuring) {
   const std::string session_id = "close4";
   Initialize(SUCCESS);
   CloseSessionAndExpect(session_id, CONNECTION_ERROR_DURING);
 }
 
 TEST_F(MojoCdmTest, RemoveSession_Success) {
   const std::string session_id = "remove1";
   Initialize(SUCCESS);
   RemoveSessionAndExpect(session_id, SUCCESS);
 }
 
 TEST_F(MojoCdmTest, RemoveSession_Failure) {
   const std::string session_id = "remove2";
   Initialize(SUCCESS);
   RemoveSessionAndExpect(session_id, FAILURE);
 }
 
+TEST_F(MojoCdmTest, RemoveSession_Pending) {
+  const std::string session_id = "remove2";
+  Initialize(SUCCESS);
+  RemoveSessionAndExpect(session_id, PENDING);
+}
+
 TEST_F(MojoCdmTest, RemoveSession_ConnectionErrorBefore) {
   const std::string session_id = "remove3";
   Initialize(SUCCESS);
   RemoveSessionAndExpect(session_id, CONNECTION_ERROR_BEFORE);
 }
 
 TEST_F(MojoCdmTest, RemoveSession_ConnectionErrorDuring) {
   const std::string session_id = "remove4";
   Initialize(SUCCESS);
   RemoveSessionAndExpect(session_id, CONNECTION_ERROR_DURING);
@@ skipping 28 matching lines @@
   CdmKeysInfo keys_info;
   Initialize(SUCCESS);
   EXPECT_CALL(cdm_client_,
               OnSessionKeysChangeCalled(session_id, has_additional_usable_key));
   remote_cdm_->CallSessionKeysChangeCB(session_id, has_additional_usable_key,
                                        std::move(keys_info));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media