Move MediaKeys::Exception to CdmPromise::Exception

media/cdm/aes_decryptor.cc

 // 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.
 
 #include "media/cdm/aes_decryptor.h"
 
 #include <stddef.h>
 #include <list>
 #include <utility>
 #include <vector>
@@ skipping 11 matching lines @@
 #include "media/base/limits.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/cdm/json_web_key.h"
 
 #if defined(USE_PROPRIETARY_CODECS)
 #include "media/cdm/cenc_utils.h"
 #endif
 
 namespace media {
-

[xhwang, 2016/10/24 17:06:13]

We actually like this empty line :)

 // Keeps track of the session IDs and DecryptionKeys. The keys are ordered by
 // insertion time (last insertion is first). It takes ownership of the
 // DecryptionKeys.
 class AesDecryptor::SessionIdDecryptionKeyMap {
   // Use a std::list to actually hold the data. Insertion is always done
   // at the front, so the "latest" decryption key is always the first one
   // in the list.
   using KeyList =
       std::list<std::pair<std::string, std::unique_ptr<DecryptionKey>>>;
 
@@ skipping 201 matching lines @@
   DCHECK(!session_keys_change_cb_.is_null());
 }
 
 AesDecryptor::~AesDecryptor() {
   key_map_.clear();
 }
 
 void AesDecryptor::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     std::unique_ptr<SimpleCdmPromise> promise) {
-  promise->reject(
-      NOT_SUPPORTED_ERROR, 0, "SetServerCertificate() is not supported.");
+  promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
+                  "SetServerCertificate() is not supported.");
 }
 
 void AesDecryptor::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   std::string session_id(base::UintToString(next_session_id_++));
   valid_sessions_.insert(session_id);
 
   // For now, the AesDecryptor does not care about |session_type|.
   // TODO(jrummell): Validate |session_type|.
 
   std::vector<uint8_t> message;
   std::vector<std::vector<uint8_t>> keys;
   switch (init_data_type) {
     case EmeInitDataType::WEBM:
       // |init_data| is simply the key needed.
       if (init_data.size() < limits::kMinKeyIdLength ||
           init_data.size() > limits::kMaxKeyIdLength) {
-        promise->reject(NOT_SUPPORTED_ERROR, 0, "Incorrect length");
+        promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0, "Incorrect length");
         return;
       }
       keys.push_back(init_data);
       break;
     case EmeInitDataType::CENC:
 #if defined(USE_PROPRIETARY_CODECS)
       // |init_data| is a set of 0 or more concatenated 'pssh' boxes.
       if (!GetKeyIdsForCommonSystemId(init_data, &keys)) {
-        promise->reject(NOT_SUPPORTED_ERROR, 0, "No supported PSSH box found.");
+        promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
+                        "No supported PSSH box found.");
         return;
       }
       break;
 #else
-      promise->reject(NOT_SUPPORTED_ERROR, 0,
+      promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
                       "Initialization data type CENC is not supported.");
       return;
 #endif
     case EmeInitDataType::KEYIDS: {
       std::string init_data_string(init_data.begin(), init_data.end());
       std::string error_message;
       if (!ExtractKeyIdsFromKeyIdsInitData(init_data_string, &keys,
                                            &error_message)) {
-        promise->reject(NOT_SUPPORTED_ERROR, 0, error_message);
+        promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0, error_message);
         return;
       }
       break;
     }
     default:
       NOTREACHED();
-      promise->reject(NOT_SUPPORTED_ERROR, 0, "init_data_type not supported.");
+      promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
+                      "init_data_type not supported.");
       return;
   }
   CreateLicenseRequest(keys, session_type, &message);
 
   promise->resolve(session_id);
 
   session_message_cb_.Run(session_id, LICENSE_REQUEST, message);
 }
 
 void AesDecryptor::LoadSession(SessionType session_type,
                                const std::string& session_id,
                                std::unique_ptr<NewSessionCdmPromise> promise) {
   // TODO(xhwang): Change this to NOTREACHED() when blink checks for key systems
   // that do not support loadSession. See http://crbug.com/342481
-  promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
+  promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
+                  "LoadSession() is not supported.");
 }
 
 void AesDecryptor::UpdateSession(const std::string& session_id,
                                  const std::vector<uint8_t>& response,
                                  std::unique_ptr<SimpleCdmPromise> promise) {
   CHECK(!response.empty());
 
   // TODO(jrummell): Convert back to a DCHECK once prefixed EME is removed.
   if (valid_sessions_.find(session_id) == valid_sessions_.end()) {
-    promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
+    promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                    "Session does not exist.");
     return;
   }
 
   std::string key_string(response.begin(), response.end());
 
   KeyIdAndKeyPairs keys;
   SessionType session_type = MediaKeys::TEMPORARY_SESSION;
   if (!ExtractKeysFromJWKSet(key_string, &keys, &session_type)) {
-    promise->reject(
-        INVALID_ACCESS_ERROR, 0, "Response is not a valid JSON Web Key Set.");
+    promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                    "Response is not a valid JSON Web Key Set.");
     return;
   }
 
   // Make sure that at least one key was extracted.
   if (keys.empty()) {
-    promise->reject(
-        INVALID_ACCESS_ERROR, 0, "Response does not contain any keys.");
+    promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                    "Response does not contain any keys.");
     return;
   }
 
   bool key_added = false;
   for (KeyIdAndKeyPairs::iterator it = keys.begin(); it != keys.end(); ++it) {
     if (it->second.length() !=
         static_cast<size_t>(DecryptConfig::kDecryptionKeySize)) {
       DVLOG(1) << "Invalid key length: " << it->second.length();
-      promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid key length.");
+      promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                      "Invalid key length.");
       return;
     }
 
     // If this key_id doesn't currently exist in this session,
     // a new key is added.
     if (!HasKey(session_id, it->first))
       key_added = true;
 
     if (!AddDecryptionKey(session_id, it->first, it->second)) {
-      promise->reject(INVALID_ACCESS_ERROR, 0, "Unable to add key.");
+      promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                      "Unable to add key.");
       return;
     }
   }
 
   {
     base::AutoLock auto_lock(new_key_cb_lock_);
 
     if (!new_audio_key_cb_.is_null())
       new_audio_key_cb_.Run();
 
@@ skipping 30 matching lines @@
   DeleteKeysForSession(session_id);
   promise->resolve();
 
   // Resolve the closed attribute.
   session_closed_cb_.Run(session_id);
 }
 
 void AesDecryptor::RemoveSession(const std::string& session_id,
                                  std::unique_ptr<SimpleCdmPromise> promise) {
   NOTIMPLEMENTED() << "Need to address https://crbug.com/616166.";
-  promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
+  promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                  "Session does not exist.");
 }
 
 CdmContext* AesDecryptor::GetCdmContext() {
   return this;
 }
 
 Decryptor* AesDecryptor::GetDecryptor() {
   return this;
 }
 
@@ skipping 163 matching lines @@
 bool AesDecryptor::DecryptionKey::Init() {
   CHECK(!secret_.empty());
   decryption_key_ =
       crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, secret_);
   if (!decryption_key_)
     return false;
   return true;
 }
 
 }  // namespace media