1 files changed, 31 insertions, 25 deletions

diff --git a/cast/streaming/sender_message.cc b/cast/streaming/sender_message.cc
index 9c2b5388..2526f96a 100644
--- a/cast/streaming/sender_message.cc
+++ b/cast/streaming/sender_message.cc
@@ -20,13 +20,12 @@ namespace {
 
 EnumNameTable<SenderMessage::Type, 4> kMessageTypeNames{
     {{kMessageTypeOffer, SenderMessage::Type::kOffer},
-     {"GET_STATUS", SenderMessage::Type::kGetStatus},
      {"GET_CAPABILITIES", SenderMessage::Type::kGetCapabilities},
      {"RPC", SenderMessage::Type::kRpc}}};
 
 SenderMessage::Type GetMessageType(const Json::Value& root) {
   std::string type;
-  if (!json::ParseAndValidateString(root[kMessageType], &type)) {
+  if (!json::TryParseString(root[kMessageType], &type)) {
     return SenderMessage::Type::kUnknown;
   }
 
@@ -45,29 +44,36 @@ ErrorOr<SenderMessage> SenderMessage::Parse(const Json::Value& value) {
   }
 
   SenderMessage message;
-  message.type = GetMessageType(value);
-  if (!json::ParseAndValidateInt(value[kSequenceNumber],
-                                 &(message.sequence_number))) {
+  if (!json::TryParseInt(value[kSequenceNumber], &(message.sequence_number))) {
     message.sequence_number = -1;
   }
 
-  if (message.type == SenderMessage::Type::kOffer) {
-    ErrorOr<Offer> offer = Offer::Parse(value[kOfferMessageBody]);
-    if (offer.is_value()) {
-      message.body = std::move(offer.value());
-      message.valid = true;
-    }
-  } else if (message.type == SenderMessage::Type::kRpc) {
-    std::string rpc_body;
-    if (json::ParseAndValidateString(value[kRpcMessageBody], &rpc_body) &&
-        base64::Decode(rpc_body, &rpc_body)) {
-      message.body = rpc_body;
+  message.type = GetMessageType(value);
+  switch (message.type) {
+    case Type::kOffer: {
+      Offer offer;
+      if (Offer::TryParse(value[kOfferMessageBody], &offer).ok()) {
+        message.body = std::move(offer);
+        message.valid = true;
+      }
+    } break;
+
+    case Type::kRpc: {
+      std::string rpc_body;
+      std::vector<uint8_t> rpc;
+      if (json::TryParseString(value[kRpcMessageBody], &rpc_body) &&
+          base64::Decode(rpc_body, &rpc)) {
+        message.body = rpc;
+        message.valid = true;
+      }
+    } break;
+
+    case Type::kGetCapabilities:
       message.valid = true;
-    }
-  } else if (message.type == SenderMessage::Type::kGetStatus ||
-             message.type == SenderMessage::Type::kGetCapabilities) {
-    // These types of messages just don't have a body.
-    message.valid = true;
+      break;
+
+    default:
+      break;
   }
 
   return message;
@@ -86,15 +92,15 @@ ErrorOr<Json::Value> SenderMessage::ToJson() const {
 
   switch (type) {
     case SenderMessage::Type::kOffer:
-      root[kOfferMessageBody] = absl::get<Offer>(body).ToJson().value();
+      root[kOfferMessageBody] = absl::get<Offer>(body).ToJson();
       break;
 
     case SenderMessage::Type::kRpc:
-      root[kRpcMessageBody] = base64::Encode(absl::get<std::string>(body));
+      root[kRpcMessageBody] =
+          base64::Encode(absl::get<std::vector<uint8_t>>(body));
       break;
 
-    case SenderMessage::Type::kGetCapabilities:  // fallthrough
-    case SenderMessage::Type::kGetStatus:
+    case SenderMessage::Type::kGetCapabilities:
       break;
 
     default: