Rename Device to Receiver

This patch renames relevant usages of Device to Receiver.

Bug: b/155337619
Change-Id: Ib21c99ee7ceb6a7f73247e00c0e2638a92c342c1
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/2998268
Commit-Queue: Jordan Bayles <jophba@chromium.org>
Reviewed-by: Jordan Bayles <jophba@chromium.org>

16 files changed, 200 insertions, 190 deletions

diff --git a/cast/common/BUILD.gn b/cast/common/BUILD.gn
index d9d3c96b..750d72ea 100644
--- a/cast/common/BUILD.gn
+++ b/cast/common/BUILD.gn
@@ -89,6 +89,7 @@ source_set("public") {
 
   deps = [
     "../../discovery:dnssd",
+    "../../discovery:mdns",
     "../../discovery:public",
     "../../platform",
     "../../third_party/abseil",
@@ -106,6 +107,7 @@ if (!build_with_chromium) {
     deps = [
       ":public",
       "../../discovery:dnssd",
+      "../../discovery:mdns",
       "../../discovery:public",
       "../../platform:standalone_impl",
       "../../testing/util",
@@ -131,6 +133,7 @@ source_set("test_helpers") {
     ":channel",
     ":public",
     "../../discovery:dnssd",
+    "../../discovery:mdns",
     "../../platform:test",
     "../../testing/util",
     "../../third_party/abseil",
diff --git a/cast/common/public/DEPS b/cast/common/public/DEPS
index c098d4db..d31bade2 100644
--- a/cast/common/public/DEPS
+++ b/cast/common/public/DEPS
@@ -4,5 +4,6 @@ include_rules = [
   # Dependencies on the implementation are not allowed in public/.
   '-cast/common',
   '+cast/common/public',
-  '+discovery/dnssd/public'
+  '+discovery/dnssd/public',
+  '+discovery/mdns/public'
 ]
diff --git a/cast/common/public/receiver_info.cc b/cast/common/public/receiver_info.cc
index 8c8b0654..ec45efea 100644
--- a/cast/common/public/receiver_info.cc
+++ b/cast/common/public/receiver_info.cc
@@ -11,24 +11,22 @@
 
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_replace.h"
+#include "discovery/mdns/public/mdns_constants.h"
 #include "util/osp_logging.h"
 
 namespace openscreen {
 namespace cast {
 namespace {
 
-// Maximum size for registered MDNS service instance names.
-const size_t kMaxDeviceNameSize = 63;
-
-// Maximum size for the device model prefix at start of MDNS service instance
+// Maximum size for the receiver model prefix at start of MDNS service instance
 // names. Any model names that are larger than this size will be truncated.
-const size_t kMaxDeviceModelSize = 20;
+const size_t kMaxReceiverModelSize = 20;
 
-// Build the MDNS instance name for service. This will be the device model (up
-// to 20 bytes) appended with the virtual device ID (device UUID) and optionally
-// appended with extension at the end to resolve name conflicts. The total MDNS
-// service instance name is kept below 64 bytes so it can easily fit into a
-// single domain name label.
+// Build the MDNS instance name for service. This will be the receiver model (up
+// to 20 bytes) appended with the virtual receiver ID (receiver UUID) and
+// optionally appended with extension at the end to resolve name conflicts. The
+// total MDNS service instance name is kept below 64 bytes so it can easily fit
+// into a single domain name label.
 //
 // NOTE: This value is based on what is currently done by Eureka, not what is
 // called out in the CastV2 spec. Eureka uses |model|-|uuid|, so the same
@@ -36,24 +34,24 @@ const size_t kMaxDeviceModelSize = 20;
 // not use the instance ID in any way, so the specific calculation used should
 // not be important.
 std::string CalculateInstanceId(const ReceiverInfo& info) {
-  // First set the device model, truncated to 20 bytes at most. Replace any
-  // whitespace characters (" ") with hyphens ("-") in the device model before
+  // First set the receiver model, truncated to 20 bytes at most. Replace any
+  // whitespace characters (" ") with hyphens ("-") in the receiver model before
   // truncation.
   std::string instance_name =
       absl::StrReplaceAll(info.model_name, {{" ", "-"}});
-  instance_name = std::string(instance_name, 0, kMaxDeviceModelSize);
+  instance_name = std::string(instance_name, 0, kMaxReceiverModelSize);
 
-  // Append the virtual device ID to the instance name separated by a single
-  // '-' character if not empty. Strip all hyphens from the device ID prior
+  // Append the receiver ID to the instance name separated by a single
+  // '-' character if not empty. Strip all hyphens from the receiver ID prior
   // to appending it.
-  std::string device_id = absl::StrReplaceAll(info.unique_id, {{"-", ""}});
+  std::string receiver_id = absl::StrReplaceAll(info.unique_id, {{"-", ""}});
 
   if (!instance_name.empty()) {
     instance_name.push_back('-');
   }
-  instance_name.append(device_id);
+  instance_name.append(receiver_id);
 
-  return std::string(instance_name, 0, kMaxDeviceNameSize);
+  return std::string(instance_name, 0, discovery::kMaxLabelLength);
 }
 
 // Returns the value for the provided |key| in the |txt| record if it exists;
@@ -124,7 +122,7 @@ discovery::DnsSdInstance ReceiverInfoToDnsSdInstance(const ReceiverInfo& info) {
 ErrorOr<ReceiverInfo> DnsSdInstanceEndpointToReceiverInfo(
     const discovery::DnsSdInstanceEndpoint& endpoint) {
   if (endpoint.service_id() != kCastV2ServiceId) {
-    return {Error::Code::kParameterInvalid, "Not a Cast device."};
+    return {Error::Code::kParameterInvalid, "Not a Cast receiver."};
   }
 
   ReceiverInfo record;
@@ -148,7 +146,7 @@ ErrorOr<ReceiverInfo> DnsSdInstanceEndpointToReceiverInfo(
   record.unique_id = GetStringFromRecord(endpoint.txt(), kUniqueIdKey);
   if (record.unique_id.empty()) {
     return {Error::Code::kParameterInvalid,
-            "Missing device unique ID in record."};
+            "Missing receiver unique ID in record."};
   }
 
   // Cast protocol version supported. Begins at 2 and is incremented by 1 with
@@ -169,15 +167,15 @@ ErrorOr<ReceiverInfo> DnsSdInstanceEndpointToReceiverInfo(
   }
   record.protocol_version = static_cast<uint8_t>(version);
 
-  // A bitset of device capabilities.
+  // A bitset of receiver capabilities.
   a_decimal_number = GetStringFromRecord(endpoint.txt(), kCapabilitiesKey);
   if (a_decimal_number.empty()) {
     return {Error::Code::kParameterInvalid,
-            "Missing device capabilities in record."};
+            "Missing receiver capabilities in record."};
   }
   if (!absl::SimpleAtoi(a_decimal_number, &record.capabilities)) {
     return {Error::Code::kParameterInvalid,
-            "Invalid device capabilities field in record."};
+            "Invalid receiver capabilities field in record."};
   }
 
   // Receiver status flag.
@@ -194,11 +192,11 @@ ErrorOr<ReceiverInfo> DnsSdInstanceEndpointToReceiverInfo(
   // [Optional] Receiver model name.
   record.model_name = GetStringFromRecord(endpoint.txt(), kModelNameKey);
 
-  // The friendly name of the device.
+  // The friendly name of the receiver.
   record.friendly_name = GetStringFromRecord(endpoint.txt(), kFriendlyNameKey);
   if (record.friendly_name.empty()) {
     return {Error::Code::kParameterInvalid,
-            "Missing device friendly name in record."};
+            "Missing receiver friendly name in record."};
   }
 
   return record;
diff --git a/cast/common/public/receiver_info.h b/cast/common/public/receiver_info.h
index 445797ef..c4e82c82 100644
--- a/cast/common/public/receiver_info.h
+++ b/cast/common/public/receiver_info.h
@@ -87,10 +87,10 @@ struct ReceiverInfo {
   // Status of the service instance.
   ReceiverStatus status = ReceiverStatus::kIdle;
 
-  // The model name of the device, e.g. “Eureka v1”, “Mollie”.
+  // The model name of the receiver, e.g. “Eureka v1”, “Mollie”.
   std::string model_name;
 
-  // The friendly name of the device, e.g. “Living Room TV".
+  // The friendly name of the receiver, e.g. “Living Room TV".
   std::string friendly_name;
 
  private:
diff --git a/cast/sender/cast_app_availability_tracker.cc b/cast/sender/cast_app_availability_tracker.cc
index 0a018d19..7e980797 100644
--- a/cast/sender/cast_app_availability_tracker.cc
+++ b/cast/sender/cast_app_availability_tracker.cc
@@ -54,10 +54,10 @@ void CastAppAvailabilityTracker::UnregisterSource(
 }
 
 std::vector<CastMediaSource> CastAppAvailabilityTracker::UpdateAppAvailability(
-    const std::string& device_id,
+    const std::string& receiver_id,
     const std::string& app_id,
     AppAvailability availability) {
-  auto& availabilities = app_availabilities_[device_id];
+  auto& availabilities = app_availabilities_[receiver_id];
   auto it = availabilities.find(app_id);
 
   AppAvailabilityResult old_availability = it == availabilities.end()
@@ -84,21 +84,22 @@ std::vector<CastMediaSource> CastAppAvailabilityTracker::UpdateAppAvailability(
   return affected_sources;
 }
 
-std::vector<CastMediaSource> CastAppAvailabilityTracker::RemoveResultsForDevice(
-    const std::string& device_id) {
-  auto affected_sources = GetSupportedSources(device_id);
-  app_availabilities_.erase(device_id);
+std::vector<CastMediaSource>
+CastAppAvailabilityTracker::RemoveResultsForReceiver(
+    const std::string& receiver_id) {
+  auto affected_sources = GetSupportedSources(receiver_id);
+  app_availabilities_.erase(receiver_id);
   return affected_sources;
 }
 
 std::vector<CastMediaSource> CastAppAvailabilityTracker::GetSupportedSources(
-    const std::string& device_id) const {
-  auto it = app_availabilities_.find(device_id);
+    const std::string& receiver_id) const {
+  auto it = app_availabilities_.find(receiver_id);
   if (it == app_availabilities_.end()) {
     return std::vector<CastMediaSource>();
   }
 
-  // Find all app IDs that are available on the device.
+  // Find all app IDs that are available on the receiver.
   std::vector<std::string> supported_app_ids;
   for (const auto& availability : it->second) {
     if (availability.second.availability == AppAvailabilityResult::kAvailable) {
@@ -106,7 +107,7 @@ std::vector<CastMediaSource> CastAppAvailabilityTracker::GetSupportedSources(
     }
   }
 
-  // Find all registered sources whose query results contain the device ID.
+  // Find all registered sources whose query results contain the receiver ID.
   std::vector<CastMediaSource> sources;
   for (const auto& source : registered_sources_) {
     if (source.second.ContainsAnyAppIdFrom(supported_app_ids)) {
@@ -117,9 +118,9 @@ std::vector<CastMediaSource> CastAppAvailabilityTracker::GetSupportedSources(
 }
 
 CastAppAvailabilityTracker::AppAvailability
-CastAppAvailabilityTracker::GetAvailability(const std::string& device_id,
+CastAppAvailabilityTracker::GetAvailability(const std::string& receiver_id,
                                             const std::string& app_id) const {
-  auto availabilities_it = app_availabilities_.find(device_id);
+  auto availabilities_it = app_availabilities_.find(receiver_id);
   if (availabilities_it == app_availabilities_.end()) {
     return {AppAvailabilityResult::kUnknown, Clock::time_point{}};
   }
@@ -142,10 +143,11 @@ std::vector<std::string> CastAppAvailabilityTracker::GetRegisteredApps() const {
   return registered_apps;
 }
 
-std::vector<std::string> CastAppAvailabilityTracker::GetAvailableDevices(
+std::vector<std::string> CastAppAvailabilityTracker::GetAvailableReceivers(
     const CastMediaSource& source) const {
-  std::vector<std::string> device_ids;
-  // For each device, check if there is at least one available app in |source|.
+  std::vector<std::string> receiver_ids;
+  // For each receiver, check if there is at least one available app in
+  // |source|.
   for (const auto& availabilities : app_availabilities_) {
     for (const std::string& app_id : source.app_ids()) {
       const auto& availabilities_map = availabilities.second;
@@ -153,12 +155,12 @@ std::vector<std::string> CastAppAvailabilityTracker::GetAvailableDevices(
       if (availability_it != availabilities_map.end() &&
           availability_it->second.availability ==
               AppAvailabilityResult::kAvailable) {
-        device_ids.push_back(availabilities.first);
+        receiver_ids.push_back(availabilities.first);
         break;
       }
     }
   }
-  return device_ids;
+  return receiver_ids;
 }
 
 }  // namespace cast
diff --git a/cast/sender/cast_app_availability_tracker.h b/cast/sender/cast_app_availability_tracker.h
index c0bded96..74d3bc25 100644
--- a/cast/sender/cast_app_availability_tracker.h
+++ b/cast/sender/cast_app_availability_tracker.h
@@ -16,8 +16,8 @@
 namespace openscreen {
 namespace cast {
 
-// Tracks device queries and their extracted Cast app IDs and their
-// availabilities on discovered devices.
+// Tracks receiver queries and their extracted Cast app IDs and their
+// availabilities on discovered receivers.
 // Example usage:
 ///
 // (1) A page is interested in a Cast URL (e.g. by creating a
@@ -28,24 +28,24 @@ namespace cast {
 //   auto new_app_ids = tracker.RegisterSource(source.value());
 //
 // (2) The set of app IDs returned by the tracker can then be used by the caller
-// to send an app availability request to each of the discovered devices.
+// to send an app availability request to each of the discovered receivers.
 //
-// (3) Once the caller knows the availability value for a (device, app) pair, it
-// may inform the tracker to update its results:
+// (3) Once the caller knows the availability value for a (receiver, app) pair,
+// it may inform the tracker to update its results:
 //   auto affected_sources =
-//       tracker.UpdateAppAvailability(device_id, app_id, {availability, now});
+//       tracker.UpdateAppAvailability(receiver_id, app_id, {availability,
+//       now});
 //
 // (4) The tracker returns a subset of discovered sources that were affected by
-// the update. The caller can then call |GetAvailableDevices()| to get the
+// the update. The caller can then call |GetAvailableReceivers()| to get the
 // updated results for each affected source.
 //
-// (5a): At any time, the caller may call |RemoveResultsForDevice()| to remove
-// cached results pertaining to the device, when it detects that a device is
+// (5a): At any time, the caller may call |RemoveResultsForReceiver()| to remove
+// cached results pertaining to the receiver, when it detects that a receiver is
 // removed or no longer valid.
 //
-// (5b): At any time, the caller may call |GetAvailableDevices()| (even before
+// (5b): At any time, the caller may call |GetAvailableReceivers()| (even before
 // the source is registered) to determine if there are cached results available.
-// TODO(crbug.com/openscreen/112): Device -> Receiver renaming.
 class CastAppAvailabilityTracker {
  public:
   // The result of an app availability request and the time when it is obtained.
@@ -69,40 +69,40 @@ class CastAppAvailabilityTracker {
   void UnregisterSource(const std::string& source_id);
   void UnregisterSource(const CastMediaSource& source);
 
-  // Updates the availability of |app_id| on |device_id| to |availability|.
+  // Updates the availability of |app_id| on |receiver_id| to |availability|.
   // Returns a list of registered CastMediaSources for which the set of
-  // available devices might have been updated by this call. The caller should
-  // call |GetAvailableDevices| with the returned CastMediaSources to get the
+  // available receivers might have been updated by this call. The caller should
+  // call |GetAvailableReceivers| with the returned CastMediaSources to get the
   // updated lists.
   std::vector<CastMediaSource> UpdateAppAvailability(
-      const std::string& device_id,
+      const std::string& receiver_id,
       const std::string& app_id,
       AppAvailability availability);
 
-  // Removes all results associated with |device_id|, i.e. when the device
+  // Removes all results associated with |receiver_id|, i.e. when the receiver
   // becomes invalid.  Returns a list of registered CastMediaSources for which
-  // the set of available devices might have been updated by this call. The
-  // caller should call |GetAvailableDevices| with the returned CastMediaSources
-  // to get the updated lists.
-  std::vector<CastMediaSource> RemoveResultsForDevice(
-      const std::string& device_id);
+  // the set of available receivers might have been updated by this call. The
+  // caller should call |GetAvailableReceivers| with the returned
+  // CastMediaSources to get the updated lists.
+  std::vector<CastMediaSource> RemoveResultsForReceiver(
+      const std::string& receiver_id);
 
-  // Returns a list of registered CastMediaSources supported by |device_id|.
+  // Returns a list of registered CastMediaSources supported by |receiver_id|.
   std::vector<CastMediaSource> GetSupportedSources(
-      const std::string& device_id) const;
+      const std::string& receiver_id) const;
 
-  // Returns the availability for |app_id| on |device_id| and the time at which
-  // the availability was determined. If availability is kUnknown, then the time
-  // may be null (e.g. if an availability request was never sent).
-  AppAvailability GetAvailability(const std::string& device_id,
+  // Returns the availability for |app_id| on |receiver_id| and the time at
+  // which the availability was determined. If availability is kUnknown, then
+  // the time may be null (e.g. if an availability request was never sent).
+  AppAvailability GetAvailability(const std::string& receiver_id,
                                   const std::string& app_id) const;
 
   // Returns a list of registered app IDs.
   std::vector<std::string> GetRegisteredApps() const;
 
-  // Returns a list of device IDs compatible with |source|, using the current
+  // Returns a list of receiver IDs compatible with |source|, using the current
   // availability info.
-  std::vector<std::string> GetAvailableDevices(
+  std::vector<std::string> GetAvailableReceivers(
       const CastMediaSource& source) const;
 
  private:
@@ -115,7 +115,7 @@ class CastAppAvailabilityTracker {
   // App IDs tracked and the number of registered sources containing them.
   std::map<std::string, int> registration_count_by_app_id_;
 
-  // IDs and app availabilities of known devices.
+  // IDs and app availabilities of known receivers.
   std::map<std::string, AppAvailabilityMap> app_availabilities_;
 };
 
diff --git a/cast/sender/cast_app_availability_tracker_unittest.cc b/cast/sender/cast_app_availability_tracker_unittest.cc
index b45d3563..1b721577 100644
--- a/cast/sender/cast_app_availability_tracker_unittest.cc
+++ b/cast/sender/cast_app_availability_tracker_unittest.cc
@@ -97,62 +97,63 @@ TEST_F(CastAppAvailabilityTrackerTest, UpdateAppAvailability) {
   // |source3| not affected.
   EXPECT_THAT(
       tracker_.UpdateAppAvailability(
-          "deviceId1", "AAA", {AppAvailabilityResult::kAvailable, Now()}),
+          "receiverId1", "AAA", {AppAvailabilityResult::kAvailable, Now()}),
       CastMediaSourcesEqual(std::vector<CastMediaSource>()));
 
-  std::vector<std::string> devices_1 = {"deviceId1"};
-  std::vector<std::string> devices_1_2 = {"deviceId1", "deviceId2"};
+  std::vector<std::string> receivers_1 = {"receiverId1"};
+  std::vector<std::string> receivers_1_2 = {"receiverId1", "receiverId2"};
   std::vector<CastMediaSource> sources_1 = {source1};
   std::vector<CastMediaSource> sources_1_2 = {source1, source2};
 
-  // Tracker returns available devices even though sources aren't registered.
-  EXPECT_EQ(devices_1, tracker_.GetAvailableDevices(source1));
-  EXPECT_EQ(devices_1, tracker_.GetAvailableDevices(source2));
-  EXPECT_TRUE(tracker_.GetAvailableDevices(source3).empty());
+  // Tracker returns available receivers even though sources aren't registered.
+  EXPECT_EQ(receivers_1, tracker_.GetAvailableReceivers(source1));
+  EXPECT_EQ(receivers_1, tracker_.GetAvailableReceivers(source2));
+  EXPECT_TRUE(tracker_.GetAvailableReceivers(source3).empty());
 
   tracker_.RegisterSource(source1);
   // Only |source1| is registered for this app.
   EXPECT_THAT(
       tracker_.UpdateAppAvailability(
-          "deviceId2", "AAA", {AppAvailabilityResult::kAvailable, Now()}),
+          "receiverId2", "AAA", {AppAvailabilityResult::kAvailable, Now()}),
       CastMediaSourcesEqual(sources_1));
-  EXPECT_THAT(tracker_.GetAvailableDevices(source1),
-              UnorderedElementsAreArray(devices_1_2));
-  EXPECT_THAT(tracker_.GetAvailableDevices(source2),
-              UnorderedElementsAreArray(devices_1_2));
-  EXPECT_TRUE(tracker_.GetAvailableDevices(source3).empty());
+  EXPECT_THAT(tracker_.GetAvailableReceivers(source1),
+              UnorderedElementsAreArray(receivers_1_2));
+  EXPECT_THAT(tracker_.GetAvailableReceivers(source2),
+              UnorderedElementsAreArray(receivers_1_2));
+  EXPECT_TRUE(tracker_.GetAvailableReceivers(source3).empty());
 
   tracker_.RegisterSource(source2);
   EXPECT_THAT(
       tracker_.UpdateAppAvailability(
-          "deviceId2", "AAA", {AppAvailabilityResult::kUnavailable, Now()}),
+          "receiverId2", "AAA", {AppAvailabilityResult::kUnavailable, Now()}),
       CastMediaSourcesEqual(sources_1_2));
-  EXPECT_EQ(devices_1, tracker_.GetAvailableDevices(source1));
-  EXPECT_EQ(devices_1, tracker_.GetAvailableDevices(source2));
-  EXPECT_TRUE(tracker_.GetAvailableDevices(source3).empty());
+  EXPECT_EQ(receivers_1, tracker_.GetAvailableReceivers(source1));
+  EXPECT_EQ(receivers_1, tracker_.GetAvailableReceivers(source2));
+  EXPECT_TRUE(tracker_.GetAvailableReceivers(source3).empty());
 }
 
-TEST_F(CastAppAvailabilityTrackerTest, RemoveResultsForDevice) {
+TEST_F(CastAppAvailabilityTrackerTest, RemoveResultsForReceiver) {
   CastMediaSource source1("cast:AAA?clientId=1", {"AAA"});
 
-  tracker_.UpdateAppAvailability("deviceId1", "AAA",
+  tracker_.UpdateAppAvailability("receiverId1", "AAA",
                                  {AppAvailabilityResult::kAvailable, Now()});
   EXPECT_EQ(AppAvailabilityResult::kAvailable,
-            tracker_.GetAvailability("deviceId1", "AAA").availability);
+            tracker_.GetAvailability("receiverId1", "AAA").availability);
 
-  std::vector<std::string> expected_device_ids = {"deviceId1"};
-  EXPECT_EQ(expected_device_ids, tracker_.GetAvailableDevices(source1));
+  std::vector<std::string> expected_receiver_ids = {"receiverId1"};
+  EXPECT_EQ(expected_receiver_ids, tracker_.GetAvailableReceivers(source1));
 
-  // Unrelated device ID.
-  tracker_.RemoveResultsForDevice("deviceId2");
+  // Unrelated receiver ID.
+  tracker_.RemoveResultsForReceiver("receiverId2");
   EXPECT_EQ(AppAvailabilityResult::kAvailable,
-            tracker_.GetAvailability("deviceId1", "AAA").availability);
-  EXPECT_EQ(expected_device_ids, tracker_.GetAvailableDevices(source1));
+            tracker_.GetAvailability("receiverId1", "AAA").availability);
+  EXPECT_EQ(expected_receiver_ids, tracker_.GetAvailableReceivers(source1));
 
-  tracker_.RemoveResultsForDevice("deviceId1");
+  tracker_.RemoveResultsForReceiver("receiverId1");
   EXPECT_EQ(AppAvailabilityResult::kUnknown,
-            tracker_.GetAvailability("deviceId1", "AAA").availability);
-  EXPECT_EQ(std::vector<std::string>{}, tracker_.GetAvailableDevices(source1));
+            tracker_.GetAvailability("receiverId1", "AAA").availability);
+  EXPECT_EQ(std::vector<std::string>{},
+            tracker_.GetAvailableReceivers(source1));
 }
 
 }  // namespace cast
diff --git a/cast/sender/cast_app_discovery_service_impl.cc b/cast/sender/cast_app_discovery_service_impl.cc
index 822410c1..1e428a79 100644
--- a/cast/sender/cast_app_discovery_service_impl.cc
+++ b/cast/sender/cast_app_discovery_service_impl.cc
@@ -41,10 +41,10 @@ CastAppDiscoveryServiceImpl::StartObservingAvailability(
   const std::string& source_id = source.source_id();
 
   // Return cached results immediately, if available.
-  std::vector<std::string> cached_device_ids =
-      availability_tracker_.GetAvailableDevices(source);
-  if (!cached_device_ids.empty()) {
-    callback(source, GetReceiversByIds(cached_device_ids));
+  std::vector<std::string> cached_receiver_ids =
+      availability_tracker_.GetAvailableReceivers(source);
+  if (!cached_receiver_ids.empty()) {
+    callback(source, GetReceiversByIds(cached_receiver_ids));
   }
 
   auto& callbacks = avail_queries_[source_id];
@@ -77,50 +77,53 @@ void CastAppDiscoveryServiceImpl::Refresh() {
 
 void CastAppDiscoveryServiceImpl::AddOrUpdateReceiver(
     const ReceiverInfo& receiver) {
-  const std::string& device_id = receiver.unique_id;
-  receivers_by_id_[device_id] = receiver;
+  const std::string& receiver_id = receiver.unique_id;
+  receivers_by_id_[receiver_id] = receiver;
 
   // Any queries that currently contain this receiver should be updated.
   UpdateAvailabilityQueries(
-      availability_tracker_.GetSupportedSources(device_id));
+      availability_tracker_.GetSupportedSources(receiver_id));
 
   for (const std::string& app_id : availability_tracker_.GetRegisteredApps()) {
-    RequestAppAvailability(device_id, app_id);
+    RequestAppAvailability(receiver_id, app_id);
   }
 }
 
 void CastAppDiscoveryServiceImpl::RemoveReceiver(const ReceiverInfo& receiver) {
-  const std::string& device_id = receiver.unique_id;
-  receivers_by_id_.erase(device_id);
+  const std::string& receiver_id = receiver.unique_id;
+  receivers_by_id_.erase(receiver_id);
   UpdateAvailabilityQueries(
-      availability_tracker_.RemoveResultsForDevice(device_id));
+      availability_tracker_.RemoveResultsForReceiver(receiver_id));
 }
 
 void CastAppDiscoveryServiceImpl::RequestAppAvailability(
-    const std::string& device_id,
+    const std::string& receiver_id,
     const std::string& app_id) {
-  if (ShouldRefreshAppAvailability(device_id, app_id, clock_())) {
+  if (ShouldRefreshAppAvailability(receiver_id, app_id, clock_())) {
     platform_client_->RequestAppAvailability(
-        device_id, app_id,
-        [self = weak_factory_.GetWeakPtr(), device_id](
+        receiver_id, app_id,
+        [self = weak_factory_.GetWeakPtr(), receiver_id](
             const std::string& app_id, AppAvailabilityResult availability) {
           if (self) {
-            self->UpdateAppAvailability(device_id, app_id, availability);
+            self->UpdateAppAvailability(receiver_id, app_id, availability);
           }
         });
   }
 }
 
 void CastAppDiscoveryServiceImpl::UpdateAppAvailability(
-    const std::string& device_id,
+    const std::string& receiver_id,
     const std::string& app_id,
     AppAvailabilityResult availability) {
-  if (receivers_by_id_.find(device_id) == receivers_by_id_.end()) {
+  if (receivers_by_id_.find(receiver_id) == receivers_by_id_.end()) {
     return;
   }
 
+  OSP_DVLOG << "App " << app_id << " on receiver " << receiver_id << " is "
+            << ToString(availability);
+
   UpdateAvailabilityQueries(availability_tracker_.UpdateAppAvailability(
-      device_id, app_id, {availability, clock_()}));
+      receiver_id, app_id, {availability, clock_()}));
 }
 
 void CastAppDiscoveryServiceImpl::UpdateAvailabilityQueries(
@@ -130,9 +133,9 @@ void CastAppDiscoveryServiceImpl::UpdateAvailabilityQueries(
     auto it = avail_queries_.find(source_id);
     if (it == avail_queries_.end())
       continue;
-    std::vector<std::string> device_ids =
-        availability_tracker_.GetAvailableDevices(source);
-    std::vector<ReceiverInfo> receivers = GetReceiversByIds(device_ids);
+    std::vector<std::string> receiver_ids =
+        availability_tracker_.GetAvailableReceivers(source);
+    std::vector<ReceiverInfo> receivers = GetReceiversByIds(receiver_ids);
     for (const auto& callback : it->second) {
       callback.callback(source, receivers);
     }
@@ -140,10 +143,10 @@ void CastAppDiscoveryServiceImpl::UpdateAvailabilityQueries(
 }
 
 std::vector<ReceiverInfo> CastAppDiscoveryServiceImpl::GetReceiversByIds(
-    const std::vector<std::string>& device_ids) const {
+    const std::vector<std::string>& receiver_ids) const {
   std::vector<ReceiverInfo> receivers;
-  for (const std::string& device_id : device_ids) {
-    auto entry = receivers_by_id_.find(device_id);
+  for (const std::string& receiver_id : receiver_ids) {
+    auto entry = receivers_by_id_.find(receiver_id);
     if (entry != receivers_by_id_.end()) {
       receivers.push_back(entry->second);
     }
@@ -152,13 +155,14 @@ std::vector<ReceiverInfo> CastAppDiscoveryServiceImpl::GetReceiversByIds(
 }
 
 bool CastAppDiscoveryServiceImpl::ShouldRefreshAppAvailability(
-    const std::string& device_id,
+    const std::string& receiver_id,
     const std::string& app_id,
     Clock::time_point now) const {
   // TODO(btolsch): Consider an exponential backoff mechanism instead.
   // Receivers will typically respond with "unavailable" immediately after boot
   // and then become available 10-30 seconds later.
-  auto availability = availability_tracker_.GetAvailability(device_id, app_id);
+  auto availability =
+      availability_tracker_.GetAvailability(receiver_id, app_id);
   switch (availability.availability) {
     case AppAvailabilityResult::kAvailable:
       return false;
diff --git a/cast/sender/cast_app_discovery_service_impl.h b/cast/sender/cast_app_discovery_service_impl.h
index aa2354d2..49943994 100644
--- a/cast/sender/cast_app_discovery_service_impl.h
+++ b/cast/sender/cast_app_discovery_service_impl.h
@@ -33,7 +33,7 @@ class CastAppDiscoveryServiceImpl : public CastAppDiscoveryService {
       const CastMediaSource& source,
       AvailabilityCallback callback) override;
 
-  // Reissues app availability requests for currently registered (device_id,
+  // Reissues app availability requests for currently registered (receiver_id,
   // app_id) pairs whose status is kUnavailable or kUnknown.
   void Refresh() override;
 
@@ -47,13 +47,13 @@ class CastAppDiscoveryServiceImpl : public CastAppDiscoveryService {
   };
 
   // Issues an app availability request for |app_id| to the receiver given by
-  // |device_id|.
-  void RequestAppAvailability(const std::string& device_id,
+  // |receiver_id|.
+  void RequestAppAvailability(const std::string& receiver_id,
                               const std::string& app_id);
 
-  // Updates the availability result for |device_id| and |app_id| with |result|,
-  // and notifies callbacks with updated availability query results.
-  void UpdateAppAvailability(const std::string& device_id,
+  // Updates the availability result for |receiver_id| and |app_id| with
+  // |result|, and notifies callbacks with updated availability query results.
+  void UpdateAppAvailability(const std::string& receiver_id,
                              const std::string& app_id,
                              AppAvailabilityResult result);
 
@@ -61,12 +61,12 @@ class CastAppDiscoveryServiceImpl : public CastAppDiscoveryService {
   void UpdateAvailabilityQueries(const std::vector<CastMediaSource>& sources);
 
   std::vector<ReceiverInfo> GetReceiversByIds(
-      const std::vector<std::string>& device_ids) const;
+      const std::vector<std::string>& receiver_ids) const;
 
   // Returns true if an app availability request should be issued for
-  // |device_id| and |app_id|. |now| is used for checking whether previously
+  // |receiver_id| and |app_id|. |now| is used for checking whether previously
   // cached results should be refreshed.
-  bool ShouldRefreshAppAvailability(const std::string& device_id,
+  bool ShouldRefreshAppAvailability(const std::string& receiver_id,
                                     const std::string& app_id,
                                     Clock::time_point now) const;
 
diff --git a/cast/sender/cast_app_discovery_service_impl_unittest.cc b/cast/sender/cast_app_discovery_service_impl_unittest.cc
index 7f08b13e..60175f59 100644
--- a/cast/sender/cast_app_discovery_service_impl_unittest.cc
+++ b/cast/sender/cast_app_discovery_service_impl_unittest.cc
@@ -32,7 +32,7 @@ class CastAppDiscoveryServiceImplTest : public ::testing::Test {
 
     receiver_.v4_address = fake_cast_socket_pair_.remote_endpoint.address;
     receiver_.port = fake_cast_socket_pair_.remote_endpoint.port;
-    receiver_.unique_id = "deviceId1";
+    receiver_.unique_id = "receiverId1";
     receiver_.friendly_name = "Some Name";
   }
 
@@ -110,8 +110,8 @@ TEST_F(CastAppDiscoveryServiceImplTest, StartObservingAvailability) {
   EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   ASSERT_EQ(receivers2.size(), 1u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
-  EXPECT_EQ(receivers2[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
+  EXPECT_EQ(receivers2[0].unique_id, "receiverId1");
 
   // No more updates for |source_a_1_| (i.e. |receivers1|).
   subscription1.Reset();
@@ -119,7 +119,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, StartObservingAvailability) {
   app_discovery_service_.RemoveReceiver(receiver_);
   ASSERT_EQ(receivers1.size(), 1u);
   EXPECT_EQ(receivers2.size(), 0u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
 }
 
 TEST_F(CastAppDiscoveryServiceImplTest, ReAddAvailQueryUsesCachedValue) {
@@ -132,7 +132,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, ReAddAvailQueryUsesCachedValue) {
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
   EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
 
   subscription1.Reset();
   receivers1.clear();
@@ -141,7 +141,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, ReAddAvailQueryUsesCachedValue) {
   EXPECT_CALL(peer_client(), OnMessage(_, _)).Times(0);
   subscription1 = StartObservingAvailability(source_a_1_, &receivers1);
   ASSERT_EQ(receivers1.size(), 1u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
 }
 
 TEST_F(CastAppDiscoveryServiceImplTest, AvailQueryUpdatedOnReceiverUpdate) {
@@ -155,7 +155,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, AvailQueryUpdatedOnReceiverUpdate) {
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
   EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
 
   // Updating |receiver_| causes |source_a_1_| query to be updated, but it's too
   // soon for a new message to be sent.
@@ -207,7 +207,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, Refresh) {
   EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   ASSERT_EQ(receivers2.size(), 0u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
 
   // Not enough time has passed for a refresh.
   clock_.Advance(std::chrono::seconds(30));
@@ -253,7 +253,7 @@ TEST_F(CastAppDiscoveryServiceImplTest,
   CastSocket* socket2 = fake_sockets2.socket.get();
   router_.TakeSocket(&mock_error_handler_, std::move(fake_sockets2.socket));
   ReceiverInfo receiver2;
-  receiver2.unique_id = "deviceId2";
+  receiver2.unique_id = "receiverId2";
   receiver2.v4_address = fake_sockets2.remote_endpoint.address;
   receiver2.port = fake_sockets2.remote_endpoint.port;
 
@@ -292,7 +292,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, StartObservingAvailabilityCachedValue) {
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
   EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
-  EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers1[0].unique_id, "receiverId1");
 
   // Same app ID should not trigger another request, but it should return
   // cached value.
@@ -300,7 +300,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, StartObservingAvailabilityCachedValue) {
   std::vector<ReceiverInfo> receivers2;
   auto subscription2 = StartObservingAvailability(source_a_2_, &receivers2);
   ASSERT_EQ(receivers2.size(), 1u);
-  EXPECT_EQ(receivers2[0].unique_id, "deviceId1");
+  EXPECT_EQ(receivers2[0].unique_id, "receiverId1");
 }
 
 TEST_F(CastAppDiscoveryServiceImplTest, AvailabilityUnknownOrUnavailable) {
diff --git a/cast/sender/cast_platform_client.cc b/cast/sender/cast_platform_client.cc
index fda03b9a..b0b956a8 100644
--- a/cast/sender/cast_platform_client.cc
+++ b/cast/sender/cast_platform_client.cc
@@ -38,7 +38,7 @@ CastPlatformClient::~CastPlatformClient() {
   virtual_conn_router_->RemoveConnectionsByLocalId(sender_id_);
   virtual_conn_router_->RemoveHandlerForLocalId(sender_id_);
 
-  for (auto& pending_requests : pending_requests_by_device_id_) {
+  for (auto& pending_requests : pending_requests_by_receiver_id_) {
     for (auto& avail_request : pending_requests.second.availability) {
       avail_request.callback(avail_request.app_id,
                              AppAvailabilityResult::kUnknown);
@@ -47,11 +47,11 @@ CastPlatformClient::~CastPlatformClient() {
 }
 
 absl::optional<int> CastPlatformClient::RequestAppAvailability(
-    const std::string& device_id,
+    const std::string& receiver_id,
     const std::string& app_id,
     AppAvailabilityCallback callback) {
-  auto entry = socket_id_by_device_id_.find(device_id);
-  if (entry == socket_id_by_device_id_.end()) {
+  auto entry = socket_id_by_receiver_id_.find(receiver_id);
+  if (entry == socket_id_by_receiver_id_.end()) {
     callback(app_id, AppAvailabilityResult::kUnknown);
     return absl::nullopt;
   }
@@ -62,7 +62,8 @@ absl::optional<int> CastPlatformClient::RequestAppAvailability(
       CreateAppAvailabilityRequest(sender_id_, request_id, app_id);
   OSP_DCHECK(message);
 
-  PendingRequests& pending_requests = pending_requests_by_device_id_[device_id];
+  PendingRequests& pending_requests =
+      pending_requests_by_receiver_id_[receiver_id];
   auto timeout = std::make_unique<Alarm>(clock_, task_runner_);
   timeout->ScheduleFromNow(
       [this, request_id]() { CancelAppAvailabilityRequest(request_id); },
@@ -82,28 +83,28 @@ absl::optional<int> CastPlatformClient::RequestAppAvailability(
   return request_id;
 }
 
-void CastPlatformClient::AddOrUpdateReceiver(const ReceiverInfo& device,
+void CastPlatformClient::AddOrUpdateReceiver(const ReceiverInfo& receiver,
                                              int socket_id) {
-  socket_id_by_device_id_[device.unique_id] = socket_id;
+  socket_id_by_receiver_id_[receiver.unique_id] = socket_id;
 }
 
-void CastPlatformClient::RemoveReceiver(const ReceiverInfo& device) {
+void CastPlatformClient::RemoveReceiver(const ReceiverInfo& receiver) {
   auto pending_requests_it =
-      pending_requests_by_device_id_.find(device.unique_id);
-  if (pending_requests_it != pending_requests_by_device_id_.end()) {
+      pending_requests_by_receiver_id_.find(receiver.unique_id);
+  if (pending_requests_it != pending_requests_by_receiver_id_.end()) {
     for (const AvailabilityRequest& availability :
          pending_requests_it->second.availability) {
       availability.callback(availability.app_id,
                             AppAvailabilityResult::kUnknown);
     }
-    pending_requests_by_device_id_.erase(pending_requests_it);
+    pending_requests_by_receiver_id_.erase(pending_requests_it);
   }
-  socket_id_by_device_id_.erase(device.unique_id);
+  socket_id_by_receiver_id_.erase(receiver.unique_id);
 }
 
 void CastPlatformClient::CancelRequest(int request_id) {
-  for (auto entry = pending_requests_by_device_id_.begin();
-       entry != pending_requests_by_device_id_.end(); ++entry) {
+  for (auto entry = pending_requests_by_receiver_id_.begin();
+       entry != pending_requests_by_receiver_id_.end(); ++entry) {
     auto& pending_requests = entry->second;
     auto it = std::find_if(pending_requests.availability.begin(),
                            pending_requests.availability.end(),
@@ -136,22 +137,22 @@ void CastPlatformClient::OnMessage(VirtualConnectionRouter* router,
       MaybeGetInt(dict, JSON_EXPAND_FIND_CONSTANT_ARGS(kMessageKeyRequestId));
   if (request_id) {
     auto entry = std::find_if(
-        socket_id_by_device_id_.begin(), socket_id_by_device_id_.end(),
+        socket_id_by_receiver_id_.begin(), socket_id_by_receiver_id_.end(),
         [socket_id =
              ToCastSocketId(socket)](const std::pair<std::string, int>& entry) {
           return entry.second == socket_id;
         });
-    if (entry != socket_id_by_device_id_.end()) {
+    if (entry != socket_id_by_receiver_id_.end()) {
       HandleResponse(entry->first, request_id.value(), dict);
     }
   }
 }
 
-void CastPlatformClient::HandleResponse(const std::string& device_id,
+void CastPlatformClient::HandleResponse(const std::string& receiver_id,
                                         int request_id,
                                         const Json::Value& message) {
-  auto entry = pending_requests_by_device_id_.find(device_id);
-  if (entry == pending_requests_by_device_id_.end()) {
+  auto entry = pending_requests_by_receiver_id_.find(receiver_id);
+  if (entry == pending_requests_by_receiver_id_.end()) {
     return;
   }
   PendingRequests& pending_requests = entry->second;
@@ -187,7 +188,7 @@ void CastPlatformClient::HandleResponse(const std::string& device_id,
 }
 
 void CastPlatformClient::CancelAppAvailabilityRequest(int request_id) {
-  for (auto& entry : pending_requests_by_device_id_) {
+  for (auto& entry : pending_requests_by_receiver_id_) {
     PendingRequests& pending_requests = entry.second;
     auto it = std::find_if(pending_requests.availability.begin(),
                            pending_requests.availability.end(),
diff --git a/cast/sender/cast_platform_client.h b/cast/sender/cast_platform_client.h
index 0acb35a7..c80a8b95 100644
--- a/cast/sender/cast_platform_client.h
+++ b/cast/sender/cast_platform_client.h
@@ -41,15 +41,15 @@ class CastPlatformClient final : public CastMessageHandler {
   ~CastPlatformClient() override;
 
   // Requests availability information for |app_id| from the receiver identified
-  // by |device_id|.  |callback| will be called exactly once with a result.
-  absl::optional<int> RequestAppAvailability(const std::string& device_id,
+  // by |receiver_id|.  |callback| will be called exactly once with a result.
+  absl::optional<int> RequestAppAvailability(const std::string& receiver_id,
                                              const std::string& app_id,
                                              AppAvailabilityCallback callback);
 
   // Notifies this object about general receiver connectivity or property
   // changes.
-  void AddOrUpdateReceiver(const ReceiverInfo& device, int socket_id);
-  void RemoveReceiver(const ReceiverInfo& device);
+  void AddOrUpdateReceiver(const ReceiverInfo& receiver, int socket_id);
+  void RemoveReceiver(const ReceiverInfo& receiver);
 
   void CancelRequest(int request_id);
 
@@ -70,7 +70,7 @@ class CastPlatformClient final : public CastMessageHandler {
                  CastSocket* socket,
                  ::cast::channel::CastMessage message) override;
 
-  void HandleResponse(const std::string& device_id,
+  void HandleResponse(const std::string& receiver_id,
                       int request_id,
                       const Json::Value& message);
 
@@ -82,9 +82,9 @@ class CastPlatformClient final : public CastMessageHandler {
 
   const std::string sender_id_;
   VirtualConnectionRouter* const virtual_conn_router_;
-  std::map<std::string /* device_id */, int> socket_id_by_device_id_;
-  std::map<std::string /* device_id */, PendingRequests>
-      pending_requests_by_device_id_;
+  std::map<std::string /* receiver_id */, int> socket_id_by_receiver_id_;
+  std::map<std::string /* receiver_id */, PendingRequests>
+      pending_requests_by_receiver_id_;
 
   const ClockNowFunctionPtr clock_;
   TaskRunner* const task_runner_;
diff --git a/cast/sender/cast_platform_client_unittest.cc b/cast/sender/cast_platform_client_unittest.cc
index 4c10ac91..702e35eb 100644
--- a/cast/sender/cast_platform_client_unittest.cc
+++ b/cast/sender/cast_platform_client_unittest.cc
@@ -34,7 +34,7 @@ class CastPlatformClientTest : public ::testing::Test {
 
     receiver_.v4_address = IPAddress{192, 168, 0, 17};
     receiver_.port = 4434;
-    receiver_.unique_id = "deviceId1";
+    receiver_.unique_id = "receiverId1";
     platform_client_.AddOrUpdateReceiver(receiver_, socket_->socket_id());
   }
 
@@ -64,7 +64,7 @@ TEST_F(CastPlatformClientTest, AppAvailability) {
       });
   bool ran = false;
   platform_client_.RequestAppAvailability(
-      "deviceId1", "AAA",
+      "receiverId1", "AAA",
       [&ran](const std::string& app_id, AppAvailabilityResult availability) {
         EXPECT_EQ("AAA", app_id);
         EXPECT_EQ(availability, AppAvailabilityResult::kAvailable);
@@ -92,7 +92,7 @@ TEST_F(CastPlatformClientTest, CancelRequest) {
       });
   absl::optional<int> maybe_request_id =
       platform_client_.RequestAppAvailability(
-          "deviceId1", "AAA",
+          "receiverId1", "AAA",
           [](const std::string& app_id, AppAvailabilityResult availability) {
             EXPECT_TRUE(false);
           });
diff --git a/cast/sender/public/README.md b/cast/sender/public/README.md
index b670d110..eb7527f5 100644
--- a/cast/sender/public/README.md
+++ b/cast/sender/public/README.md
@@ -1,5 +1,5 @@
 # cast/sender/public
 
 This module contains an implementation of the Cast "sender", i.e. the client
-that discovers Cast devices on the LAN and launches apps on them.
+that discovers Cast receivers on the LAN and launches apps on them.
 
diff --git a/cast/sender/public/cast_app_discovery_service.h b/cast/sender/public/cast_app_discovery_service.h
index f85e35b1..2e095b6d 100644
--- a/cast/sender/public/cast_app_discovery_service.h
+++ b/cast/sender/public/cast_app_discovery_service.h
@@ -14,12 +14,12 @@ namespace cast {
 
 class CastMediaSource;
 
-// Interface for app discovery for Cast devices.
+// Interface for app discovery for Cast receivers.
 class CastAppDiscoveryService {
  public:
   using AvailabilityCallback =
       std::function<void(const CastMediaSource& source,
-                         const std::vector<ReceiverInfo>& devices)>;
+                         const std::vector<ReceiverInfo>& receivers)>;
 
   class Subscription {
    public:
@@ -47,7 +47,7 @@ class CastAppDiscoveryService {
   // returned via |callback| until the returned Subscription is destroyed by the
   // caller.  If there are cached results available, |callback| will be invoked
   // before this method returns.  |callback| may be invoked with an empty list
-  // if all devices respond to the respective queries with "unavailable" or
+  // if all receivers respond to the respective queries with "unavailable" or
   // don't respond before a timeout.  |callback| may be invoked successively
   // with the same list.
   virtual Subscription StartObservingAvailability(
diff --git a/cast/standalone_receiver/main.cc b/cast/standalone_receiver/main.cc
index d66d70e6..fb4ada9a 100644
--- a/cast/standalone_receiver/main.cc
+++ b/cast/standalone_receiver/main.cc
@@ -58,9 +58,9 @@ options:
                                 private key and certificate can then be used as
                                 values for the -p and -s flags.
 
-    -f, --friendly-name: Friendly name to be used for device discovery.
+    -f, --friendly-name: Friendly name to be used for receiver discovery.
 
-    -m, --model-name: Model name to be used for device discovery.
+    -m, --model-name: Model name to be used for receiver discovery.
 
     -t, --tracing: Enable performance tracing logging.
 
@@ -216,10 +216,10 @@ int RunStandaloneReceiver(int argc, char* argv[]) {
   OSP_CHECK(interface_name && strlen(interface_name) > 0)
       << "No interface name provided.";
 
-  std::string device_id =
+  std::string receiver_id =
       absl::StrCat("Standalone Receiver on ", interface_name);
   ErrorOr<GeneratedCredentials> creds = GenerateCredentials(
-      device_id, private_key_path, developer_certificate_path);
+      receiver_id, private_key_path, developer_certificate_path);
   OSP_CHECK(creds.is_value()) << creds.error();
 
   const InterfaceInfo interface = GetInterfaceInfoFromName(interface_name);