[Cast] Remove deprecated WiFi status code

The WiFi status logs have been turned down in Chrome, and no longer need
to be supported in libcast. This patch removes all references to the
GET_STATUS and STATUS_RESPONSE messages.

Bug: 1197178
Change-Id: Id48844c0e3dd921ec95d1cb803603161ddcdcbfe
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/2815609
Reviewed-by: Brandon Tolsch <btolsch@chromium.org>
Reviewed-by: Takumi Fujimoto <takumif@chromium.org>
Commit-Queue: Jordan Bayles <jophba@chromium.org>

18 files changed, 59 insertions, 247 deletions

diff --git a/cast/protocol/castv2/streaming_examples/answer.json b/cast/protocol/castv2/streaming_examples/answer.json
index 1c95b394..0e115fc1 100644
--- a/cast/protocol/castv2/streaming_examples/answer.json
+++ b/cast/protocol/castv2/streaming_examples/answer.json
@@ -30,7 +30,6 @@
     },
     "receiverRtcpEventLog": [0, 1],
     "receiverRtcpDscp": [234, 567],
-    "receiverGetStatus": true,
     "rtpExtensions": ["adaptive_playout_delay"]
   }
 }
\ No newline at end of file
diff --git a/cast/protocol/castv2/streaming_examples/offer.json b/cast/protocol/castv2/streaming_examples/offer.json
index 339b6d15..d1eba3a7 100644
--- a/cast/protocol/castv2/streaming_examples/offer.json
+++ b/cast/protocol/castv2/streaming_examples/offer.json
@@ -1,7 +1,6 @@
 {
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": [
       {
         "aesIvMask": "64A6AAC2821880145271BB15B0188821",
diff --git a/cast/protocol/castv2/streaming_schema.json b/cast/protocol/castv2/streaming_schema.json
index a967264d..e659e7bf 100644
--- a/cast/protocol/castv2/streaming_schema.json
+++ b/cast/protocol/castv2/streaming_schema.json
@@ -168,24 +168,10 @@
           "type": "array",
           "items": {"type": "integer", "minimum": 0}
         },
-        "receiverGetStatus": {"type": "boolean"},
         "rtpExtensions": {"$ref": "#/definitions/rtp_extensions"}
       },
       "required": ["udpPort", "sendIndexes", "ssrcs"]
     },
-    "status_response": {
-      "properties": {
-        "wifiSpeed": {
-          "type": "array",
-          "items": {"type": "integer", "minimum": 0}
-        },
-        "wifiFcsError": {
-          "type": "array",
-          "items": {"type": "integer", "minimum": 0}
-        },
-        "wifiSnr": {"type": "number", "examples": ["3.23", "50.1"]}
-      }
-    },
     "capabilities": {
       "$id": "#capabilities",
       "type": "object",
@@ -221,14 +207,6 @@
     "result": {"type": "string", "enum": ["ok", "error"]},
     "seqNum": {"type": "integer", "minimum": 0},
     "sessionId": {"type": "integer"},
-    "get_status": {
-      "type": "array",
-      "items": {
-        "type": "string",
-        "enum": ["wifiFcsError", "wifiSnr", "wifiSpeed"]
-      }
-    },
-    "status": {"$ref": "#/definitions/status_response"},
     "type": {
       "type": "string",
       "enum": [
@@ -270,14 +248,6 @@
       "then": {"required": ["capabilities"]}
     },
     {
-      "if": {"properties": {"type": {"const": "GET_STATUS"}}},
-      "then": {"required": ["get_status"]}
-    },
-    {
-      "if": {"properties": {"type": {"const": "STATUS_RESPONSE"}}},
-      "then": {"required": ["status"]}
-    },
-    {
       "if": {
         "properties": {"type": {"const": "RPC"}, "result": {"const": "ok"}}
       },
diff --git a/cast/streaming/answer_messages.cc b/cast/streaming/answer_messages.cc
index 1be73869..c59aeff8 100644
--- a/cast/streaming/answer_messages.cc
+++ b/cast/streaming/answer_messages.cc
@@ -106,8 +106,6 @@ static constexpr char kReceiverRtcpEventLog[] = "receiverRtcpEventLog";
 // OPtional array of numbers specifying the indexes of streams that will use
 // DSCP values specified in the OFFER message for RTCP packets.
 static constexpr char kReceiverRtcpDscp[] = "receiverRtcpDscp";
-// True if receiver can report wifi status.
-static constexpr char kReceiverGetStatus[] = "receiverGetStatus";
 // If this optional field is present the receiver supports the specific
 // RTP extensions (such as adaptive playout delay).
 static constexpr char kRtpExtensions[] = "rtpExtensions";
@@ -379,10 +377,6 @@ bool Answer::ParseAndValidate(const Json::Value& root, Answer* out) {
       !ParseOptional<DisplayDescription>(root[kDisplay], &(out->display))) {
     return false;
   }
-  if (!json::ParseBool(root[kReceiverGetStatus],
-                       &(out->supports_wifi_status_reporting))) {
-    out->supports_wifi_status_reporting = false;
-  }
 
   // These function set to empty array if not present, so we can ignore
   // the return value for optional values.
@@ -427,7 +421,6 @@ Json::Value Answer::ToJson() const {
     root[kDisplay] = display->ToJson();
   }
   root[kUdpPort] = udp_port;
-  root[kReceiverGetStatus] = supports_wifi_status_reporting;
   root[kSendIndexes] = PrimitiveVectorToJson(send_indexes);
   root[kSsrcs] = PrimitiveVectorToJson(ssrcs);
   // Some sender do not handle empty array properly, so we omit these fields
diff --git a/cast/streaming/answer_messages.h b/cast/streaming/answer_messages.h
index 7aa78e7f..3a811073 100644
--- a/cast/streaming/answer_messages.h
+++ b/cast/streaming/answer_messages.h
@@ -114,7 +114,6 @@ struct Answer {
   absl::optional<DisplayDescription> display;
   std::vector<int> receiver_rtcp_event_log;
   std::vector<int> receiver_rtcp_dscp;
-  bool supports_wifi_status_reporting = false;
 
   // RTP extensions should be empty, but not null.
   std::vector<std::string> rtp_extensions = {};
diff --git a/cast/streaming/answer_messages_unittest.cc b/cast/streaming/answer_messages_unittest.cc
index 9ddceac0..eb354ba4 100644
--- a/cast/streaming/answer_messages_unittest.cc
+++ b/cast/streaming/answer_messages_unittest.cc
@@ -63,7 +63,6 @@ constexpr char kValidAnswerJson[] = R"({
   },
   "receiverRtcpEventLog": [0, 1],
   "receiverRtcpDscp": [234, 567],
-  "receiverGetStatus": true,
   "rtpExtensions": ["adaptive_playout_delay"]
 })";
 
@@ -97,7 +96,6 @@ const Answer kValidAnswer{
     }),
     std::vector<int>{7, 8, 9},              // receiver_rtcp_event_log
     std::vector<int>{11, 12, 13},           // receiver_rtcp_dscp
-    true,                                   // receiver_get_status
     std::vector<std::string>{"foo", "bar"}  // rtp_extensions
 };
 
@@ -149,7 +147,6 @@ void ExpectEqualsValidAnswerJson(const Answer& answer) {
 
   EXPECT_THAT(answer.receiver_rtcp_event_log, ElementsAre(0, 1));
   EXPECT_THAT(answer.receiver_rtcp_dscp, ElementsAre(234, 567));
-  EXPECT_TRUE(answer.supports_wifi_status_reporting);
   EXPECT_THAT(answer.rtp_extensions, ElementsAre("adaptive_playout_delay"));
 }
 
@@ -247,8 +244,6 @@ TEST(AnswerMessagesTest, ProperlyPopulatedAnswerSerializesProperly) {
   EXPECT_EQ(receiver_rtcp_dscp[1], 12);
   EXPECT_EQ(receiver_rtcp_dscp[2], 13);
 
-  EXPECT_EQ(root["receiverGetStatus"], true);
-
   Json::Value rtp_extensions = std::move(root["rtpExtensions"]);
   EXPECT_EQ(rtp_extensions.type(), Json::ValueType::arrayValue);
   EXPECT_EQ(rtp_extensions[0], "foo");
@@ -319,8 +314,7 @@ TEST(AnswerMessagesTest, SucceedsWithMissingRtpFields) {
   ExpectSuccessOnParse(R"({
   "udpPort": 1234,
   "sendIndexes": [1, 3],
-  "ssrcs": [1233324, 2234222],
-  "receiverGetStatus": true
+  "ssrcs": [1233324, 2234222]
   })");
 }
 
@@ -331,37 +325,22 @@ TEST(AnswerMessagesTest, ErrorOnEmptyAnswer) {
 TEST(AnswerMessagesTest, ErrorOnMissingUdpPort) {
   ExpectFailureOnParse(R"({
     "sendIndexes": [1, 3],
-    "ssrcs": [1233324, 2234222],
-    "receiverGetStatus": true
+    "ssrcs": [1233324, 2234222]
   })");
 }
 
 TEST(AnswerMessagesTest, ErrorOnMissingSsrcs) {
   ExpectFailureOnParse(R"({
     "udpPort": 1234,
-    "sendIndexes": [1, 3],
-    "receiverGetStatus": true
+    "sendIndexes": [1, 3]
   })");
 }
 
 TEST(AnswerMessagesTest, ErrorOnMissingSendIndexes) {
   ExpectFailureOnParse(R"({
     "udpPort": 1234,
-    "ssrcs": [1233324, 2234222],
-    "receiverGetStatus": true
-  })");
-}
-
-TEST(AnswerMessagesTest, AssumesNoReportingIfGetStatusFalse) {
-  Answer answer;
-  ExpectSuccessOnParse(R"({
-    "udpPort": 1234,
-    "sendIndexes": [1, 3],
     "ssrcs": [1233324, 2234222]
-  })",
-                       &answer);
-
-  EXPECT_FALSE(answer.supports_wifi_status_reporting);
+  })");
 }
 
 TEST(AnswerMessagesTest, AllowsReceiverSideScaling) {
@@ -409,8 +388,7 @@ TEST(AnswerMessagesTest, AssumesMinBitRateIfOmitted) {
         "maxBitRate": 10000000,
         "maxDelay": 5000
       }
-    },
-    "receiverGetStatus": true
+    }
   })",
                        &answer);
 
diff --git a/cast/streaming/offer_messages.cc b/cast/streaming/offer_messages.cc
index e45cb1ce..8ade19d8 100644
--- a/cast/streaming/offer_messages.cc
+++ b/cast/streaming/offer_messages.cc
@@ -343,10 +343,8 @@ ErrorOr<Offer> Offer::Parse(const Json::Value& root) {
   if (!root.isObject()) {
     return json::CreateParseError("null offer");
   }
-  ErrorOr<CastMode> cast_mode =
+  const ErrorOr<CastMode> cast_mode =
       GetEnum(kCastModeNames, root["castMode"].asString());
-  const ErrorOr<bool> get_status = json::ParseBool(root, "receiverGetStatus");
-
   Json::Value supported_streams = root[kSupportedStreams];
   if (!supported_streams.isArray()) {
     return json::CreateParseError("supported streams in offer");
@@ -388,16 +386,14 @@ ErrorOr<Offer> Offer::Parse(const Json::Value& root) {
     }
   }
 
-  return Offer{cast_mode.value(CastMode::kMirroring), get_status.value({}),
-               std::move(audio_streams), std::move(video_streams)};
+  return Offer{cast_mode.value(CastMode::kMirroring), std::move(audio_streams),
+               std::move(video_streams)};
 }
 
 ErrorOr<Json::Value> Offer::ToJson() const {
   Json::Value root;
 
   root["castMode"] = GetEnumName(kCastModeNames, cast_mode).value();
-  root["receiverGetStatus"] = supports_wifi_status_reporting;
-
   Json::Value streams;
   for (auto& as : audio_streams) {
     auto eoj = as.ToJson();
diff --git a/cast/streaming/offer_messages.h b/cast/streaming/offer_messages.h
index d9fc5af2..a64280ff 100644
--- a/cast/streaming/offer_messages.h
+++ b/cast/streaming/offer_messages.h
@@ -96,9 +96,6 @@ struct Offer {
   ErrorOr<Json::Value> ToJson() const;
 
   CastMode cast_mode = CastMode::kMirroring;
-  // This field is poorly named in the spec (receiverGetStatus), so we use
-  // a more descriptive name here.
-  bool supports_wifi_status_reporting = {};
   std::vector<AudioStream> audio_streams = {};
   std::vector<VideoStream> video_streams = {};
 };
diff --git a/cast/streaming/offer_messages_unittest.cc b/cast/streaming/offer_messages_unittest.cc
index 81a84ec4..0614d522 100644
--- a/cast/streaming/offer_messages_unittest.cc
+++ b/cast/streaming/offer_messages_unittest.cc
@@ -21,7 +21,6 @@ namespace {
 
 constexpr char kValidOffer[] = R"({
   "castMode": "mirroring",
-  "receiverGetStatus": true,
   "supportedStreams": [
     {
       "index": 0,
@@ -100,7 +99,6 @@ void ExpectFailureOnParse(
 
 void ExpectEqualsValidOffer(const Offer& offer) {
   EXPECT_EQ(CastMode::kMirroring, offer.cast_mode);
-  EXPECT_EQ(true, offer.supports_wifi_status_reporting);
 
   // Verify list of video streams.
   EXPECT_EQ(2u, offer.video_streams.size());
diff --git a/cast/streaming/receiver_message.cc b/cast/streaming/receiver_message.cc
index 1ce675b7..5f433362 100644
--- a/cast/streaming/receiver_message.cc
+++ b/cast/streaming/receiver_message.cc
@@ -23,7 +23,6 @@ namespace {
 
 EnumNameTable<ReceiverMessage::Type, 5> kMessageTypeNames{
     {{kMessageTypeAnswer, ReceiverMessage::Type::kAnswer},
-     {"STATUS_RESPONSE", ReceiverMessage::Type::kStatusResponse},
      {"CAPABILITIES_RESPONSE", ReceiverMessage::Type::kCapabilitiesResponse},
      {"RPC", ReceiverMessage::Type::kRpc}}};
 
@@ -127,34 +126,6 @@ Json::Value ReceiverCapability::ToJson() const {
 }
 
 // static
-ErrorOr<ReceiverWifiStatus> ReceiverWifiStatus::Parse(
-    const Json::Value& value) {
-  if (!value) {
-    return Error(Error::Code::kParameterInvalid,
-                 "Empty JSON in status parsing");
-  }
-
-  double wifi_snr;
-  std::vector<int32_t> wifi_speed;
-  if (!json::ParseAndValidateDouble(value["wifiSnr"], &wifi_snr, true) ||
-      !json::ParseAndValidateIntArray(value["wifiSpeed"], &wifi_speed)) {
-    return Error::Code::kJsonParseError;
-  }
-  return ReceiverWifiStatus{wifi_snr, std::move(wifi_speed)};
-}
-
-Json::Value ReceiverWifiStatus::ToJson() const {
-  Json::Value root;
-  root["wifiSnr"] = wifi_snr;
-  Json::Value speeds(Json::ValueType::arrayValue);
-  for (const auto& speed : wifi_speed) {
-    speeds.append(speed);
-  }
-  root["wifiSpeed"] = std::move(speeds);
-  return root;
-}
-
-// static
 ErrorOr<ReceiverMessage> ReceiverMessage::Parse(const Json::Value& value) {
   ReceiverMessage message;
   if (!value || !json::ParseAndValidateInt(value[kSequenceNumber],
@@ -190,15 +161,6 @@ ErrorOr<ReceiverMessage> ReceiverMessage::Parse(const Json::Value& value) {
       }
     } break;
 
-    case Type::kStatusResponse: {
-      ErrorOr<ReceiverWifiStatus> status =
-          ReceiverWifiStatus::Parse(value[kStatusMessageBody]);
-      if (status.is_value()) {
-        message.body = std::move(status.value());
-        message.valid = true;
-      }
-    } break;
-
     case Type::kCapabilitiesResponse: {
       ErrorOr<ReceiverCapability> capability =
           ReceiverCapability::Parse(value[kCapabilitiesMessageBody]);
@@ -218,9 +180,7 @@ ErrorOr<ReceiverMessage> ReceiverMessage::Parse(const Json::Value& value) {
       }
     } break;
 
-    case Type::kUnknown:
     default:
-      message.valid = false;
       break;
   }
 
@@ -248,11 +208,6 @@ ErrorOr<Json::Value> ReceiverMessage::ToJson() const {
       }
       break;
 
-    case (ReceiverMessage::Type::kStatusResponse):
-      root[kResult] = kResultOk;
-      root[kStatusMessageBody] = absl::get<ReceiverWifiStatus>(body).ToJson();
-      break;
-
     case ReceiverMessage::Type::kCapabilitiesResponse:
       root[kResult] = kResultOk;
       root[kCapabilitiesMessageBody] =
diff --git a/cast/streaming/receiver_message.h b/cast/streaming/receiver_message.h
index b231149a..555016df 100644
--- a/cast/streaming/receiver_message.h
+++ b/cast/streaming/receiver_message.h
@@ -17,18 +17,6 @@
 namespace openscreen {
 namespace cast {
 
-struct ReceiverWifiStatus {
-  Json::Value ToJson() const;
-  static ErrorOr<ReceiverWifiStatus> Parse(const Json::Value& value);
-
-  // Current WiFi signal to noise ratio in decibels.
-  double wifi_snr = 0.0;
-
-  // Min, max, average, and current bandwidth in bps in order of the WiFi link.
-  // Example: [1200, 1300, 1250, 1230].
-  std::vector<int32_t> wifi_speed;
-};
-
 enum class MediaCapability {
   kAudio,
   kAac,
@@ -75,9 +63,6 @@ struct ReceiverMessage {
     // Response to OFFER message.
     kAnswer,
 
-    // Response to GET_STATUS message.
-    kStatusResponse,
-
     // Response to GET_CAPABILITIES message.
     kCapabilitiesResponse,
 
@@ -97,7 +82,6 @@ struct ReceiverMessage {
   absl::variant<absl::monostate,
                 Answer,
                 std::vector<uint8_t>,  // Binary-encoded RPC message.
-                ReceiverWifiStatus,
                 ReceiverCapability,
                 ReceiverError>
       body;
diff --git a/cast/streaming/receiver_session.cc b/cast/streaming/receiver_session.cc
index 78956c5d..46e1bac3 100644
--- a/cast/streaming/receiver_session.cc
+++ b/cast/streaming/receiver_session.cc
@@ -306,13 +306,8 @@ Answer ReceiverSession::ConstructAnswer(const SessionProperties& properties) {
     answer_constraints = std::move(constraints);
   }
   return Answer{environment_->GetBoundLocalEndpoint().port,
-                std::move(stream_indexes),
-                std::move(stream_ssrcs),
-                answer_constraints,
-                std::move(display),
-                std::vector<int>{},  // receiver_rtcp_event_log
-                std::vector<int>{},  // receiver_rtcp_dscp
-                supports_wifi_status_reporting_};
+                std::move(stream_indexes), std::move(stream_ssrcs),
+                std::move(answer_constraints), std::move(display)};
 }
 
 void ReceiverSession::SendErrorAnswerReply(int sequence_number,
diff --git a/cast/streaming/receiver_session.h b/cast/streaming/receiver_session.h
index 04b1d256..51ba49c6 100644
--- a/cast/streaming/receiver_session.h
+++ b/cast/streaming/receiver_session.h
@@ -236,7 +236,6 @@ class ReceiverSession final : public Environment::SocketSubscriber {
   // binding.
   std::unique_ptr<SessionProperties> pending_session_;
 
-  bool supports_wifi_status_reporting_ = false;
   ReceiverPacketRouter packet_router_;
 
   std::unique_ptr<Receiver> current_audio_receiver_;
diff --git a/cast/streaming/receiver_session_unittest.cc b/cast/streaming/receiver_session_unittest.cc
index e937233c..1ed169ec 100644
--- a/cast/streaming/receiver_session_unittest.cc
+++ b/cast/streaming/receiver_session_unittest.cc
@@ -34,7 +34,6 @@ constexpr char kValidOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": [
       {
         "index": 31337,
@@ -100,7 +99,6 @@ constexpr char kNoAudioOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": [
       {
         "index": 31338,
@@ -132,7 +130,6 @@ constexpr char kInvalidCodecOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": [
       {
         "index": 31338,
@@ -164,7 +161,6 @@ constexpr char kNoVideoOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": [
       {
         "index": 1337,
@@ -188,7 +184,6 @@ constexpr char kNoAudioOrVideoOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": []
   }
 })";
@@ -198,7 +193,6 @@ constexpr char kInvalidJsonOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": [
   }
 })";
@@ -212,7 +206,6 @@ constexpr char kMissingSeqNumOfferMessage[] = R"({
   "type": "OFFER",
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": []
   }
 })";
@@ -222,7 +215,6 @@ constexpr char kValidJsonInvalidFormatOfferMessage[] = R"({
   "seqNum": 1337,
   "offer": {
     "castMode": "mirroring",
-    "receiverGetStatus": true,
     "supportedStreams": "anything"
   }
 })";
@@ -365,9 +357,6 @@ TEST_F(ReceiverSessionTest, CanNegotiateWithDefaultPreferences) {
   EXPECT_LT(0, answer_body["udpPort"].asInt());
   EXPECT_GT(65535, answer_body["udpPort"].asInt());
 
-  // Get status should always be false, as we have no plans to implement it.
-  EXPECT_EQ(false, answer_body["receiverGetStatus"].asBool());
-
   // Constraints and display should not be present with no preferences.
   EXPECT_TRUE(answer_body["constraints"].isNull());
   EXPECT_TRUE(answer_body["display"].isNull());
diff --git a/cast/streaming/sender_message.cc b/cast/streaming/sender_message.cc
index 2983aa2f..e03cba18 100644
--- a/cast/streaming/sender_message.cc
+++ b/cast/streaming/sender_message.cc
@@ -20,7 +20,6 @@ namespace {
 
 EnumNameTable<SenderMessage::Type, 4> kMessageTypeNames{
     {{kMessageTypeOffer, SenderMessage::Type::kOffer},
-     {"GET_STATUS", SenderMessage::Type::kGetStatus},
      {"GET_CAPABILITIES", SenderMessage::Type::kGetCapabilities},
      {"RPC", SenderMessage::Type::kRpc}}};
 
@@ -45,30 +44,37 @@ ErrorOr<SenderMessage> SenderMessage::Parse(const Json::Value& value) {
   }
 
   SenderMessage message;
-  message.type = GetMessageType(value);
   if (!json::ParseAndValidateInt(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;
-    std::vector<uint8_t> rpc;
-    if (json::ParseAndValidateString(value[kRpcMessageBody], &rpc_body) &&
-        base64::Decode(rpc_body, &rpc)) {
-      message.body = rpc;
+  message.type = GetMessageType(value);
+  switch (message.type) {
+    case Type::kOffer: {
+      ErrorOr<Offer> offer = Offer::Parse(value[kOfferMessageBody]);
+      if (offer.is_value()) {
+        message.body = std::move(offer.value());
+        message.valid = true;
+      }
+    } break;
+
+    case Type::kRpc: {
+      std::string rpc_body;
+      std::vector<uint8_t> rpc;
+      if (json::ParseAndValidateString(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;
@@ -95,8 +101,7 @@ ErrorOr<Json::Value> SenderMessage::ToJson() const {
           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:
diff --git a/cast/streaming/sender_message.h b/cast/streaming/sender_message.h
index 2c45032c..adb0b09e 100644
--- a/cast/streaming/sender_message.h
+++ b/cast/streaming/sender_message.h
@@ -28,9 +28,6 @@ struct SenderMessage {
     // OFFER request message.
     kOffer,
 
-    // GET_STATUS request message.
-    kGetStatus,
-
     // GET_CAPABILITIES request message.
     kGetCapabilities,
 
diff --git a/cast/streaming/sender_session_unittest.cc b/cast/streaming/sender_session_unittest.cc
index 485f2fd9..c5231633 100644
--- a/cast/streaming/sender_session_unittest.cc
+++ b/cast/streaming/sender_session_unittest.cc
@@ -352,7 +352,6 @@ TEST_F(SenderSessionTest, SendsOfferMessage) {
   ASSERT_FALSE(offer_body.isNull());
   ASSERT_TRUE(offer_body.isObject());
   EXPECT_EQ("mirroring", offer_body["castMode"].asString());
-  EXPECT_EQ(false, offer_body["receiverGetStatus"].asBool());
 
   const Json::Value& streams = offer_body["supportedStreams"];
   EXPECT_TRUE(streams.isArray());
diff --git a/cast/streaming/session_messager_unittest.cc b/cast/streaming/session_messager_unittest.cc
index 21d70280..c06c64bb 100644
--- a/cast/streaming/session_messager_unittest.cc
+++ b/cast/streaming/session_messager_unittest.cc
@@ -24,7 +24,6 @@ constexpr char kReceiverId[] = "receiver-12345";
 // simply because it is massive.
 Offer kExampleOffer{
     CastMode::kMirroring,
-    false,
     {AudioStream{Stream{0,
                         Stream::Type::kAudioSource,
                         2,
@@ -104,8 +103,6 @@ class SessionMessagerTest : public ::testing::Test {
                                 message_store_.GetReplyCallback());
     receiver_messager_.SetHandler(SenderMessage::Type::kOffer,
                                   message_store_.GetRequestCallback());
-    receiver_messager_.SetHandler(SenderMessage::Type::kGetStatus,
-                                  message_store_.GetRequestCallback());
     receiver_messager_.SetHandler(SenderMessage::Type::kGetCapabilities,
                                   message_store_.GetRequestCallback());
     receiver_messager_.SetHandler(SenderMessage::Type::kRpc,
@@ -156,40 +153,6 @@ TEST_F(SessionMessagerTest, RpcMessaging) {
                                    message_store_.receiver_messages[0].body));
 }
 
-TEST_F(SessionMessagerTest, StatusMessaging) {
-  ASSERT_TRUE(sender_messager_
-                  .SendRequest(SenderMessage{SenderMessage::Type::kGetStatus,
-                                             3123, true /* valid */},
-                               ReceiverMessage::Type::kStatusResponse,
-                               message_store_.GetReplyCallback())
-                  .ok());
-
-  ASSERT_EQ(1u, message_store_.sender_messages.size());
-  ASSERT_TRUE(message_store_.receiver_messages.empty());
-  EXPECT_EQ(SenderMessage::Type::kGetStatus,
-            message_store_.sender_messages[0].type);
-  EXPECT_TRUE(message_store_.sender_messages[0].valid);
-
-  message_store_.sender_messages.clear();
-  ASSERT_TRUE(
-      receiver_messager_
-          .SendMessage(ReceiverMessage{
-              ReceiverMessage::Type::kStatusResponse, 3123, true /* valid */,
-              ReceiverWifiStatus{-5.7, std::vector<int32_t>{1200, 1300, 1250}}})
-          .ok());
-
-  ASSERT_TRUE(message_store_.sender_messages.empty());
-  ASSERT_EQ(1u, message_store_.receiver_messages.size());
-  EXPECT_EQ(ReceiverMessage::Type::kStatusResponse,
-            message_store_.receiver_messages[0].type);
-  EXPECT_TRUE(message_store_.receiver_messages[0].valid);
-
-  const auto& status =
-      absl::get<ReceiverWifiStatus>(message_store_.receiver_messages[0].body);
-  EXPECT_DOUBLE_EQ(-5.7, status.wifi_snr);
-  EXPECT_THAT(status.wifi_speed, ElementsAre(1200, 1300, 1250));
-}
-
 TEST_F(SessionMessagerTest, CapabilitiesMessaging) {
   ASSERT_TRUE(
       sender_messager_
@@ -304,12 +267,12 @@ TEST_F(SessionMessagerTest, OfferAndReceiverError) {
 }
 
 TEST_F(SessionMessagerTest, UnexpectedMessagesAreIgnored) {
-  EXPECT_FALSE(
-      receiver_messager_
-          .SendMessage(ReceiverMessage{
-              ReceiverMessage::Type::kStatusResponse, 3123, true /* valid */,
-              ReceiverWifiStatus{-5.7, std::vector<int32_t>{1200, 1300, 1250}}})
-          .ok());
+  EXPECT_FALSE(receiver_messager_
+                   .SendMessage(ReceiverMessage{
+                       ReceiverMessage::Type::kCapabilitiesResponse, 3123,
+                       true /* valid */,
+                       ReceiverCapability{2, {MediaCapability::kH264}}})
+                   .ok());
 
   // The message gets dropped and thus won't be in the store.
   EXPECT_TRUE(message_store_.sender_messages.empty());
@@ -393,19 +356,20 @@ TEST_F(SessionMessagerTest, SenderHandlesMessageMissingSequenceNumber) {
 
 TEST_F(SessionMessagerTest, ReceiverCannotSendFirst) {
   const Error error = receiver_messager_.SendMessage(ReceiverMessage{
-      ReceiverMessage::Type::kStatusResponse, 3123, true /* valid */,
-      ReceiverWifiStatus{-5.7, std::vector<int32_t>{1200, 1300, 1250}}});
+      ReceiverMessage::Type::kCapabilitiesResponse, 3123, true /* valid */,
+      ReceiverCapability{2, {MediaCapability::kAudio}}});
 
   EXPECT_EQ(Error::Code::kInitializationFailure, error.code());
 }
 
 TEST_F(SessionMessagerTest, ErrorMessageLoggedIfTimeout) {
-  ASSERT_TRUE(sender_messager_
-                  .SendRequest(SenderMessage{SenderMessage::Type::kGetStatus,
-                                             3123, true /* valid */},
-                               ReceiverMessage::Type::kStatusResponse,
-                               message_store_.GetReplyCallback())
-                  .ok());
+  ASSERT_TRUE(
+      sender_messager_
+          .SendRequest(SenderMessage{SenderMessage::Type::kGetCapabilities,
+                                     3123, true /* valid */},
+                       ReceiverMessage::Type::kCapabilitiesResponse,
+                       message_store_.GetReplyCallback())
+          .ok());
 
   ASSERT_EQ(1u, message_store_.sender_messages.size());
   ASSERT_TRUE(message_store_.receiver_messages.empty());
@@ -414,7 +378,7 @@ TEST_F(SessionMessagerTest, ErrorMessageLoggedIfTimeout) {
   ASSERT_EQ(1u, message_store_.sender_messages.size());
   ASSERT_EQ(1u, message_store_.receiver_messages.size());
   EXPECT_EQ(3123, message_store_.receiver_messages[0].sequence_number);
-  EXPECT_EQ(ReceiverMessage::Type::kStatusResponse,
+  EXPECT_EQ(ReceiverMessage::Type::kCapabilitiesResponse,
             message_store_.receiver_messages[0].type);
   EXPECT_FALSE(message_store_.receiver_messages[0].valid);
 }
@@ -423,15 +387,14 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessageFromWrongSender) {
   SimpleMessagePort port(kReceiverId);
   ReceiverSessionMessager messager(&port, kReceiverId,
                                    message_store_.GetErrorCallback());
-  messager.SetHandler(SenderMessage::Type::kGetStatus,
+  messager.SetHandler(SenderMessage::Type::kGetCapabilities,
                       message_store_.GetRequestCallback());
 
   // The first message should be accepted since we don't have a set sender_id
   // yet.
   port.ReceiveMessage("sender-31337", kCastWebrtcNamespace, R"({
-        "get_status": ["wifiSnr", "wifiSpeed"],
         "seqNum": 820263769,
-        "type": "GET_STATUS"
+        "type": "GET_CAPABILITIES"
       })");
   ASSERT_TRUE(message_store_.errors.empty());
   ASSERT_EQ(1u, message_store_.sender_messages.size());
@@ -439,9 +402,8 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessageFromWrongSender) {
 
   // The second message should just be ignored.
   port.ReceiveMessage("sender-42", kCastWebrtcNamespace, R"({
-        "get_status": ["wifiSnr"],
         "seqNum": 1234,
-        "type": "GET_STATUS"
+        "type": "GET_CAPABILITIES"
       })");
   ASSERT_TRUE(message_store_.errors.empty());
   ASSERT_TRUE(message_store_.sender_messages.empty());
@@ -449,9 +411,8 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessageFromWrongSender) {
   // But the third message should be accepted again since it's from the
   // first sender.
   port.ReceiveMessage("sender-31337", kCastWebrtcNamespace, R"({
-        "get_status": ["wifiSnr", "wifiSpeed"],
         "seqNum": 820263769,
-        "type": "GET_STATUS"
+        "type": "GET_CAPABILITIES"
       })");
   ASSERT_TRUE(message_store_.errors.empty());
   ASSERT_EQ(1u, message_store_.sender_messages.size());
@@ -481,15 +442,14 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessagesWithoutHandler) {
   SimpleMessagePort port(kReceiverId);
   ReceiverSessionMessager messager(&port, kReceiverId,
                                    message_store_.GetErrorCallback());
-  messager.SetHandler(SenderMessage::Type::kGetStatus,
+  messager.SetHandler(SenderMessage::Type::kGetCapabilities,
                       message_store_.GetRequestCallback());
 
   // The first message should be accepted since we don't have a set sender_id
   // yet.
   port.ReceiveMessage("sender-31337", kCastWebrtcNamespace, R"({
-        "get_status": ["wifiSnr", "wifiSpeed"],
         "seqNum": 820263769,
-        "type": "GET_STATUS"
+        "type": "GET_CAPABILITIES"
       })");
   ASSERT_TRUE(message_store_.errors.empty());
   ASSERT_EQ(1u, message_store_.sender_messages.size());
@@ -498,7 +458,7 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessagesWithoutHandler) {
   // The second message should be rejected since it doesn't have a handler.
   port.ReceiveMessage("sender-31337", kCastWebrtcNamespace, R"({
         "seqNum": 820263770,
-        "type": "GET_CAPABILITIES"
+        "type": "RPC"
       })");
   ASSERT_TRUE(message_store_.errors.empty());
   ASSERT_TRUE(message_store_.sender_messages.empty());