Update Clear Key to support keyids formatted init_data

media/cdm/json_web_key.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/json_web_key.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 
 namespace media {
 
 const char kKeysTag[] = "keys";
 const char kKeyTypeTag[] = "kty";
 const char kKeyTypeOct[] = "oct";  // Octet sequence.
 const char kAlgTag[] = "alg";
 const char kAlgA128KW[] = "A128KW";  // AES key wrap using a 128-bit key.
@@ skipping 196 matching lines @@
   } else {
     DVLOG(1) << "Invalid '" << kTypeTag << "' value: " << session_type_id;
     return false;
   }
 
   // All done.
   keys->swap(local_keys);
   return true;
 }
 
+bool ExtractKeyIdsFromKeyIdsInitData(const std::string& input,
+                                     KeyIdList* key_ids,
+                                     std::string* error_message) {
+  if (!base::IsStringASCII(input)) {
+    error_message->assign("Non ASCII: ");
+    error_message->append(input);

[sandersd (OOO until July 31), 2015/03/04 01:04:21]

Is it wise to have arbitrarily large error messages?

[jrummell, 2015/03/04 01:28:52]

Good catch. Done.

+    return false;
+  }
+
+  scoped_ptr<base::Value> root(base::JSONReader().ReadToValue(input));
+  if (!root.get() || root->GetType() != base::Value::TYPE_DICTIONARY) {
+    error_message->assign("Not valid JSON: ");
+    error_message->append(input);
+    return false;
+  }
+
+  // Locate the set from the dictionary.
+  base::DictionaryValue* dictionary =
+      static_cast<base::DictionaryValue*>(root.get());
+  base::ListValue* list_val = NULL;
+  if (!dictionary->GetList(kKeyIdsTag, &list_val)) {
+    error_message->assign("Missing '");
+    error_message->append(kKeyIdsTag);
+    error_message->append("' parameter or not a list");
+    return false;
+  }
+
+  // Create a local list of key ids, so that |key_ids| only gets updated on
+  // success.
+  KeyIdList local_key_ids;
+  for (size_t i = 0; i < list_val->GetSize(); ++i) {
+    std::string encoded_key_id;
+    if (!list_val->GetString(i, &encoded_key_id)) {
+      error_message->assign("Unable to access '");

[sandersd (OOO until July 31), 2015/03/04 01:04:21]

Presumably this happens only when the value at that index is not a string.

[jrummell, 2015/03/04 01:28:52]

Done.

+      error_message->append(kKeyIdsTag);
+      error_message->append("'[");
+      error_message->append(base::UintToString(i));
+      error_message->append("]");
+      return false;
+    }
+
+    // Key ID is a base64-encoded string, so decode it.
+    std::string raw_key_id = DecodeBase64Url(encoded_key_id);
+    if (raw_key_id.empty()) {
+      error_message->assign("'");
+      error_message->append(kKeyIdsTag);
+      error_message->append("'[");
+      error_message->append(base::UintToString(i));
+      error_message->append("] is not valid base64url encoded. Value: ");
+      error_message->append(encoded_key_id);
+      return false;
+    }
+
+    // Add the decoded key ID to the list.
+    local_key_ids.push_back(std::vector<uint8>(
+        raw_key_id.data(), raw_key_id.data() + raw_key_id.length()));
+  }
+
+  // All done.
+  key_ids->swap(local_key_ids);
+  error_message->clear();
+  return true;
+}
+
 void CreateLicenseRequest(const KeyIdList& key_ids,
                           MediaKeys::SessionType session_type,
                           std::vector<uint8>* license) {
   // Create the license request.
   scoped_ptr<base::DictionaryValue> request(new base::DictionaryValue());
   scoped_ptr<base::ListValue> list(new base::ListValue());
   for (const auto& key_id : key_ids)
     list->AppendString(EncodeBase64Url(&key_id[0], key_id.size()));
   request->Set(kKeyIdsTag, list.release());
 
@@ skipping 61 matching lines @@
     DVLOG(1) << "Invalid '" << kKeyIdsTag << "' value: " << encoded_key;
     return false;
   }
 
   std::vector<uint8> result(decoded_string.begin(), decoded_string.end());
   first_key->swap(result);
   return true;
 }
 
 }  // namespace media