Upgrade media/base from deprecated Value-conversion API

Bug: 1086733
Change-Id: Id166fe2202b50b274a6ce90d3503e0c619994b1d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2222242Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Commit-Queue: Nigel Tao <nigeltao@chromium.org>
Cr-Commit-Position: refs/heads/master@{#773927}

chrome/browser/media/android/cdm/media_drm_origin_id_manager.cc

@@ -14,7 +14,7 @@
 #include "base/task/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "base/value_conversions.h"
+#include "base/util/values/values_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/system_network_context_manager.h"
@@ -82,8 +82,7 @@ void SetExpirableTokenIfNeeded(PrefService* const pref_service) {
   DictionaryPrefUpdate update(pref_service, kMediaDrmOriginIds);
   auto* origin_id_dict = update.Get();
   origin_id_dict->SetKey(
-      kExpirableToken,
-      base::CreateTimeValue(base::Time::Now() + kExpirationDelta));
+      kExpirableToken, util::TimeToValue(base::Time::Now() + kExpirationDelta));
 }
 
 void RemoveExpirableToken(base::Value* origin_id_dict) {
@@ -119,13 +118,13 @@ bool CanPreProvision(base::Value* origin_id_dict) {
   if (!token_value)
     return false;
 
-  base::Time expiration_time;
-  if (!base::GetValueAsTime(*token_value, &expiration_time)) {
+  base::Optional<base::Time> expiration_time = util::ValueToTime(token_value);
+  if (!expiration_time) {
     RemoveExpirableToken(origin_id_dict);
     return false;
   }
 
-  if (base::Time::Now() > expiration_time) {
+  if (base::Time::Now() > *expiration_time) {
     DVLOG(3) << __func__ << ": Token exists but has expired";
     RemoveExpirableToken(origin_id_dict);
     return false;
@@ -163,13 +162,14 @@ base::UnguessableToken TakeFirstOriginId(PrefService* const pref_service) {
   if (origin_ids->GetList().empty())
     return base::UnguessableToken::Null();
 
-  base::UnguessableToken result;
   auto first_entry = origin_ids->GetList().begin();
-  if (!base::GetValueAsUnguessableToken(*first_entry, &result))
+  base::Optional<base::UnguessableToken> result =
+      util::ValueToUnguessableToken(*first_entry);
+  if (!result)
     return base::UnguessableToken::Null();
 
   origin_ids->EraseListIter(first_entry);
-  return result;
+  return *result;
 }
 
 void AddOriginId(base::Value* origin_id_dict,
@@ -181,7 +181,7 @@ void AddOriginId(base::Value* origin_id_dict,
   base::Value* origin_ids = origin_id_dict->FindListKey(kOriginIds);
   if (!origin_ids)
     origin_ids = origin_id_dict->SetKey(kOriginIds, base::ListValue());
-  origin_ids->Append(base::CreateUnguessableTokenValue(origin_id));
+  origin_ids->Append(util::UnguessableTokenToValue(origin_id));
 }
 
 // Helper class that creates a new origin ID and provisions it for both L1

chrome/browser/media/android/cdm/media_drm_origin_id_manager_unittest.cc

@@ -17,7 +17,7 @@
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "base/unguessable_token.h"
-#include "base/value_conversions.h"
+#include "base/util/values/values_util.h"
 #include "chrome/browser/media/android/cdm/media_drm_origin_id_manager_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
@@ -294,8 +294,8 @@ TEST_F(MediaDrmOriginIdManagerTest, OriginIdNotInList) {
   DVLOG(1) << "Checking preference " << kMediaDrmOriginIds;
   auto* dict = GetDictionary(kMediaDrmOriginIds);
   auto* list = dict->FindKey(kAvailableOriginIds);
-  EXPECT_FALSE(base::Contains(list->GetList(),
-                              CreateUnguessableTokenValue(origin_id.value())));
+  EXPECT_FALSE(base::Contains(
+      list->GetList(), util::UnguessableTokenToValue(origin_id.value())));
 }
 
 TEST_F(MediaDrmOriginIdManagerTest, ProvisioningFail) {

media/base/BUILD.gn

@@ -345,6 +345,7 @@ jumbo_source_set("base") {
   ]
   deps = [
     "//base/allocator:buildflags",
+    "//base/util/values:values_util",
     "//components/system_media_controls/linux/buildflags",
     "//gpu/command_buffer/common",
     "//gpu/ipc/common:common",

media/base/video_frame_metadata.cc

@@ -11,7 +11,7 @@
 #include "base/check_op.h"
 #include "base/no_destructor.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/value_conversions.h"
+#include "base/util/values/values_util.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace media {
@@ -71,20 +71,19 @@ void VideoFrameMetadata::SetString(Key key, const std::string& value) {
 }
 
 void VideoFrameMetadata::SetTimeDelta(Key key, const base::TimeDelta& value) {
-  dictionary_.SetKey(ToInternalKey(key), base::CreateTimeDeltaValue(value));
+  dictionary_.SetKey(ToInternalKey(key), util::TimeDeltaToValue(value));
 }
 
 void VideoFrameMetadata::SetTimeTicks(Key key, const base::TimeTicks& value) {
   // Serialize TimeTicks as TimeDeltas.
   dictionary_.SetKey(ToInternalKey(key),
-                     base::CreateTimeDeltaValue(value - base::TimeTicks()));
+                     util::TimeDeltaToValue(value - base::TimeTicks()));
 }
 
 void VideoFrameMetadata::SetUnguessableToken(
     Key key,
     const base::UnguessableToken& value) {
-  dictionary_.SetKey(ToInternalKey(key),
-                     base::CreateUnguessableTokenValue(value));
+  dictionary_.SetKey(ToInternalKey(key), util::UnguessableTokenToValue(value));
 }
 
 void VideoFrameMetadata::SetRect(Key key, const gfx::Rect& value) {
@@ -145,31 +144,33 @@ bool VideoFrameMetadata::GetString(Key key, std::string* value) const {
 }
 
 bool VideoFrameMetadata::GetTimeDelta(Key key, base::TimeDelta* value) const {
-  const base::Value* internal_value = dictionary_.FindKey(ToInternalKey(key));
-  if (!internal_value)
+  base::Optional<base::TimeDelta> delta =
+      util::ValueToTimeDelta(dictionary_.FindKey(ToInternalKey(key)));
+  if (!delta)
     return false;
-  return base::GetValueAsTimeDelta(*internal_value, value);
+  *value = *delta;
+  return true;
 }
 
 bool VideoFrameMetadata::GetTimeTicks(Key key, base::TimeTicks* value) const {
   // Deserialize TimeTicks from TimeDelta.
-  const base::Value* internal_value = dictionary_.FindKey(ToInternalKey(key));
-  base::TimeDelta delta;
-
-  if (!internal_value || !base::GetValueAsTimeDelta(*internal_value, &delta))
+  base::Optional<base::TimeDelta> delta =
+      util::ValueToTimeDelta(dictionary_.FindKey(ToInternalKey(key)));
+  if (!delta)
     return false;
-
-  *value = base::TimeTicks() + delta;
+  *value = base::TimeTicks() + *delta;
   return true;
 }
 
 bool VideoFrameMetadata::GetUnguessableToken(
     Key key,
     base::UnguessableToken* value) const {
-  const base::Value* internal_value = dictionary_.FindKey(ToInternalKey(key));
-  if (!internal_value)
+  base::Optional<base::UnguessableToken> token =
+      util::ValueToUnguessableToken(dictionary_.FindKey(ToInternalKey(key)));
+  if (!token)
     return false;
-  return base::GetValueAsUnguessableToken(*internal_value, value);
+  *value = *token;
+  return true;
 }
 
 bool VideoFrameMetadata::GetRect(Key key, gfx::Rect* value) const {