Rename ServiceInfo to ReceiverInfo

This patch renames ServiceInfo and all related usages to ReceiverInfo.

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

6 files changed, 84 insertions, 82 deletions

diff --git a/cast/common/BUILD.gn b/cast/common/BUILD.gn
index 9e32e27d..d9d3c96b 100644
--- a/cast/common/BUILD.gn
+++ b/cast/common/BUILD.gn
@@ -83,8 +83,8 @@ source_set("public") {
   sources = [
     "public/cast_socket.h",
     "public/message_port.h",
-    "public/service_info.cc",
-    "public/service_info.h",
+    "public/receiver_info.cc",
+    "public/receiver_info.h",
   ]
 
   deps = [
@@ -154,7 +154,7 @@ source_set("unittests") {
     "channel/message_framer_unittest.cc",
     "channel/namespace_router_unittest.cc",
     "channel/virtual_connection_router_unittest.cc",
-    "public/service_info_unittest.cc",
+    "public/receiver_info_unittest.cc",
   ]
 
   deps = [
diff --git a/cast/common/discovery/e2e_test/tests.cc b/cast/common/discovery/e2e_test/tests.cc
index 82234845..3f316ae3 100644
--- a/cast/common/discovery/e2e_test/tests.cc
+++ b/cast/common/discovery/e2e_test/tests.cc
@@ -11,7 +11,7 @@
 // ASSERTS due to asynchronous concerns around test failures.
 // Although this causes the entire test binary to fail instead of
 // just a single test, it makes debugging easier/possible.
-#include "cast/common/public/service_info.h"
+#include "cast/common/public/receiver_info.h"
 #include "discovery/common/config.h"
 #include "discovery/common/reporting_client.h"
 #include "discovery/public/dns_sd_service_factory.h"
@@ -44,12 +44,12 @@ constexpr milliseconds kCheckLoopSleepTime(100);
 constexpr int kMaxCheckLoopIterations = 25;
 
 // Publishes new service instances.
-class Publisher : public discovery::DnsSdServicePublisher<ServiceInfo> {
+class Publisher : public discovery::DnsSdServicePublisher<ReceiverInfo> {
  public:
   explicit Publisher(discovery::DnsSdService* service)  // NOLINT
-      : DnsSdServicePublisher<ServiceInfo>(service,
-                                           kCastV2ServiceId,
-                                           ServiceInfoToDnsSdInstance) {
+      : DnsSdServicePublisher<ReceiverInfo>(service,
+                                            kCastV2ServiceId,
+                                            ReceiverInfoToDnsSdInstance) {
     OSP_LOG_INFO << "Initializing Publisher...\n";
   }
 
@@ -71,40 +71,40 @@ class Publisher : public discovery::DnsSdServicePublisher<ServiceInfo> {
 };
 
 // Receives incoming services and outputs their results to stdout.
-class ServiceReceiver : public discovery::DnsSdServiceWatcher<ServiceInfo> {
+class ServiceReceiver : public discovery::DnsSdServiceWatcher<ReceiverInfo> {
  public:
   explicit ServiceReceiver(discovery::DnsSdService* service)  // NOLINT
-      : discovery::DnsSdServiceWatcher<ServiceInfo>(
+      : discovery::DnsSdServiceWatcher<ReceiverInfo>(
             service,
             kCastV2ServiceId,
-            DnsSdInstanceEndpointToServiceInfo,
+            DnsSdInstanceEndpointToReceiverInfo,
             [this](
-                std::vector<std::reference_wrapper<const ServiceInfo>> infos) {
+                std::vector<std::reference_wrapper<const ReceiverInfo>> infos) {
               ProcessResults(std::move(infos));
             }) {
     OSP_LOG_INFO << "Initializing ServiceReceiver...";
   }
 
-  bool IsServiceFound(const ServiceInfo& check_service) {
-    return std::find_if(service_infos_.begin(), service_infos_.end(),
-                        [&check_service](const ServiceInfo& info) {
+  bool IsServiceFound(const ReceiverInfo& check_service) {
+    return std::find_if(receiver_infos_.begin(), receiver_infos_.end(),
+                        [&check_service](const ReceiverInfo& info) {
                           return info.friendly_name ==
                                  check_service.friendly_name;
-                        }) != service_infos_.end();
+                        }) != receiver_infos_.end();
   }
 
-  void EraseReceivedServices() { service_infos_.clear(); }
+  void EraseReceivedServices() { receiver_infos_.clear(); }
 
  private:
   void ProcessResults(
-      std::vector<std::reference_wrapper<const ServiceInfo>> infos) {
-    service_infos_.clear();
-    for (const ServiceInfo& info : infos) {
-      service_infos_.push_back(info);
+      std::vector<std::reference_wrapper<const ReceiverInfo>> infos) {
+    receiver_infos_.clear();
+    for (const ReceiverInfo& info : infos) {
+      receiver_infos_.push_back(info);
     }
   }
 
-  std::vector<ServiceInfo> service_infos_;
+  std::vector<ReceiverInfo> receiver_infos_;
 };
 
 class FailOnErrorReporting : public discovery::ReportingClient {
@@ -145,8 +145,8 @@ class DiscoveryE2ETest : public testing::Test {
   }
 
  protected:
-  ServiceInfo GetInfo(int id) {
-    ServiceInfo hosted_service;
+  ReceiverInfo GetInfo(int id) {
+    ReceiverInfo hosted_service;
     hosted_service.port = 1234;
     hosted_service.unique_id = "id" + std::to_string(id);
     hosted_service.model_name = "openscreen-Model" + std::to_string(id);
@@ -179,8 +179,8 @@ class DiscoveryE2ETest : public testing::Test {
     OSP_DCHECK(dnssd_service_.get());
     OSP_DCHECK(publisher_.get());
 
-    std::vector<ServiceInfo> record_set{std::move(records)...};
-    for (ServiceInfo& record : record_set) {
+    std::vector<ReceiverInfo> record_set{std::move(records)...};
+    for (ReceiverInfo& record : record_set) {
       task_runner_->PostTask([this, r = std::move(record)]() {
         auto error = publisher_->UpdateRegistration(r);
         OSP_CHECK(error.ok()) << "\tFailed to update service instance '"
@@ -194,8 +194,8 @@ class DiscoveryE2ETest : public testing::Test {
     OSP_DCHECK(dnssd_service_.get());
     OSP_DCHECK(publisher_.get());
 
-    std::vector<ServiceInfo> record_set{std::move(records)...};
-    for (ServiceInfo& record : record_set) {
+    std::vector<ReceiverInfo> record_set{std::move(records)...};
+    for (ReceiverInfo& record : record_set) {
       task_runner_->PostTask([this, r = std::move(record)]() {
         auto error = publisher_->Register(r);
         OSP_CHECK(error.ok()) << "\tFailed to publish service instance '"
@@ -230,20 +230,20 @@ class DiscoveryE2ETest : public testing::Test {
         << "Could not find " << waiting_on << " service instances!";
   }
 
-  void CheckForClaimedIds(ServiceInfo service_info,
+  void CheckForClaimedIds(ReceiverInfo receiver_info,
                           std::atomic_bool* has_been_seen) {
     OSP_DCHECK(dnssd_service_.get());
     task_runner_->PostTask(
-        [this, info = std::move(service_info), has_been_seen]() mutable {
+        [this, info = std::move(receiver_info), has_been_seen]() mutable {
           CheckForClaimedIds(std::move(info), has_been_seen, 0);
         });
   }
 
-  void CheckForPublishedService(ServiceInfo service_info,
+  void CheckForPublishedService(ReceiverInfo receiver_info,
                                 std::atomic_bool* has_been_seen) {
     OSP_DCHECK(dnssd_service_.get());
     task_runner_->PostTask(
-        [this, info = std::move(service_info), has_been_seen]() mutable {
+        [this, info = std::move(receiver_info), has_been_seen]() mutable {
           CheckForPublishedService(std::move(info), has_been_seen, 0, true);
         });
   }
@@ -251,11 +251,11 @@ class DiscoveryE2ETest : public testing::Test {
   // TODO(issuetracker.google.com/159256503): Change this to use a polling
   // method to wait until the service disappears rather than immediately failing
   // if it exists, so waits throughout this file can be removed.
-  void CheckNotPublishedService(ServiceInfo service_info,
+  void CheckNotPublishedService(ReceiverInfo receiver_info,
                                 std::atomic_bool* has_been_seen) {
     OSP_DCHECK(dnssd_service_.get());
     task_runner_->PostTask(
-        [this, info = std::move(service_info), has_been_seen]() mutable {
+        [this, info = std::move(receiver_info), has_been_seen]() mutable {
           CheckForPublishedService(std::move(info), has_been_seen, 0, false);
         });
   }
@@ -266,37 +266,38 @@ class DiscoveryE2ETest : public testing::Test {
   std::unique_ptr<Publisher> publisher_;
 
  private:
-  void CheckForClaimedIds(ServiceInfo service_info,
+  void CheckForClaimedIds(ReceiverInfo receiver_info,
                           std::atomic_bool* has_been_seen,
                           int attempts) {
-    if (publisher_->IsInstanceIdClaimed(service_info.GetInstanceId())) {
+    if (publisher_->IsInstanceIdClaimed(receiver_info.GetInstanceId())) {
       // TODO(crbug.com/openscreen/110): Log the published service instance.
       *has_been_seen = true;
       return;
     }
 
     OSP_CHECK_LE(attempts++, kMaxCheckLoopIterations)
-        << "Service " << service_info.friendly_name << " publication failed.";
+        << "Service " << receiver_info.friendly_name << " publication failed.";
     task_runner_->PostTaskWithDelay(
-        [this, info = std::move(service_info), has_been_seen,
+        [this, info = std::move(receiver_info), has_been_seen,
          attempts]() mutable {
           CheckForClaimedIds(std::move(info), has_been_seen, attempts);
         },
         kCheckLoopSleepTime);
   }
 
-  void CheckForPublishedService(ServiceInfo service_info,
+  void CheckForPublishedService(ReceiverInfo receiver_info,
                                 std::atomic_bool* has_been_seen,
                                 int attempts,
                                 bool expect_to_be_present) {
-    if (!receiver_->IsServiceFound(service_info)) {
+    if (!receiver_->IsServiceFound(receiver_info)) {
       if (attempts++ > kMaxCheckLoopIterations) {
         OSP_CHECK(!expect_to_be_present)
-            << "Service " << service_info.friendly_name << " discovery failed.";
+            << "Service " << receiver_info.friendly_name
+            << " discovery failed.";
         return;
       }
       task_runner_->PostTaskWithDelay(
-          [this, info = std::move(service_info), has_been_seen, attempts,
+          [this, info = std::move(receiver_info), has_been_seen, attempts,
            expect_to_be_present]() mutable {
             CheckForPublishedService(std::move(info), has_been_seen, attempts,
                                      expect_to_be_present);
@@ -306,7 +307,8 @@ class DiscoveryE2ETest : public testing::Test {
       // TODO(crbug.com/openscreen/110): Log the discovered service instance.
       *has_been_seen = true;
     } else {
-      OSP_LOG_FATAL << "Found instance '" << service_info.friendly_name << "'!";
+      OSP_LOG_FATAL << "Found instance '" << receiver_info.friendly_name
+                    << "'!";
     }
   }
 };
diff --git a/cast/common/public/service_info.cc b/cast/common/public/receiver_info.cc
index 732688f8..8c8b0654 100644
--- a/cast/common/public/service_info.cc
+++ b/cast/common/public/receiver_info.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "cast/common/public/service_info.h"
+#include "cast/common/public/receiver_info.h"
 
 #include <cctype>
 #include <cinttypes>
@@ -35,7 +35,7 @@ const size_t kMaxDeviceModelSize = 20;
 // convention will be followed here. That being said, the Eureka receiver does
 // not use the instance ID in any way, so the specific calculation used should
 // not be important.
-std::string CalculateInstanceId(const ServiceInfo& info) {
+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
   // truncation.
@@ -71,7 +71,7 @@ std::string GetStringFromRecord(const discovery::DnsSdTxtRecord& txt,
 
 }  // namespace
 
-const std::string& ServiceInfo::GetInstanceId() const {
+const std::string& ReceiverInfo::GetInstanceId() const {
   if (instance_id_ == std::string("")) {
     instance_id_ = CalculateInstanceId(*this);
   }
@@ -79,7 +79,7 @@ const std::string& ServiceInfo::GetInstanceId() const {
   return instance_id_;
 }
 
-bool ServiceInfo::IsValid() const {
+bool ReceiverInfo::IsValid() const {
   return (
       discovery::IsInstanceValid(GetInstanceId()) && port != 0 &&
       !unique_id.empty() &&
@@ -98,7 +98,7 @@ bool ServiceInfo::IsValid() const {
                                                  friendly_name));
 }
 
-discovery::DnsSdInstance ServiceInfoToDnsSdInstance(const ServiceInfo& info) {
+discovery::DnsSdInstance ReceiverInfoToDnsSdInstance(const ReceiverInfo& info) {
   OSP_DCHECK(discovery::IsServiceValid(kCastV2ServiceId));
   OSP_DCHECK(discovery::IsDomainValid(kCastV2DomainId));
 
@@ -121,13 +121,13 @@ discovery::DnsSdInstance ServiceInfoToDnsSdInstance(const ServiceInfo& info) {
                                   kCastV2DomainId, std::move(txt), info.port);
 }
 
-ErrorOr<ServiceInfo> DnsSdInstanceEndpointToServiceInfo(
+ErrorOr<ReceiverInfo> DnsSdInstanceEndpointToReceiverInfo(
     const discovery::DnsSdInstanceEndpoint& endpoint) {
   if (endpoint.service_id() != kCastV2ServiceId) {
     return {Error::Code::kParameterInvalid, "Not a Cast device."};
   }
 
-  ServiceInfo record;
+  ReceiverInfo record;
   for (const IPAddress& address : endpoint.addresses()) {
     if (!record.v4_address && address.IsV4()) {
       record.v4_address = address;
diff --git a/cast/common/public/service_info.h b/cast/common/public/receiver_info.h
index 301ef99f..445797ef 100644
--- a/cast/common/public/service_info.h
+++ b/cast/common/public/receiver_info.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CAST_COMMON_PUBLIC_SERVICE_INFO_H_
-#define CAST_COMMON_PUBLIC_SERVICE_INFO_H_
+#ifndef CAST_COMMON_PUBLIC_RECEIVER_INFO_H_
+#define CAST_COMMON_PUBLIC_RECEIVER_INFO_H_
 
 #include <memory>
 #include <string>
@@ -53,14 +53,13 @@ constexpr uint64_t kIsDevModeEnabled = 1 << 4;
 
 constexpr uint64_t kNoCapabilities = 0;
 
-// This is the top-level service info class for CastV2. It describes a specific
+// This is the top-level receiver info class for CastV2. It describes a specific
 // service instance.
-// TODO(crbug.com/openscreen/112): Rename this to CastReceiverInfo or similar.
-struct ServiceInfo {
-  // returns the instance id associated with this ServiceInfo instance.
+struct ReceiverInfo {
+  // returns the instance id associated with this ReceiverInfo instance.
   const std::string& GetInstanceId() const;
 
-  // Returns whether all fields of this ServiceInfo are valid.
+  // Returns whether all fields of this ReceiverInfo are valid.
   bool IsValid() const;
 
   // Addresses for the service. Present if an address of this address type
@@ -98,7 +97,7 @@ struct ServiceInfo {
   mutable std::string instance_id_ = "";
 };
 
-inline bool operator==(const ServiceInfo& lhs, const ServiceInfo& rhs) {
+inline bool operator==(const ReceiverInfo& lhs, const ReceiverInfo& rhs) {
   return lhs.v4_address == rhs.v4_address && lhs.v6_address == rhs.v6_address &&
          lhs.port == rhs.port && lhs.unique_id == rhs.unique_id &&
          lhs.protocol_version == rhs.protocol_version &&
@@ -107,18 +106,19 @@ inline bool operator==(const ServiceInfo& lhs, const ServiceInfo& rhs) {
          lhs.friendly_name == rhs.friendly_name;
 }
 
-inline bool operator!=(const ServiceInfo& lhs, const ServiceInfo& rhs) {
+inline bool operator!=(const ReceiverInfo& lhs, const ReceiverInfo& rhs) {
   return !(lhs == rhs);
 }
 
 // Functions responsible for converting between CastV2 and DNS-SD
 // representations of a service instance.
-discovery::DnsSdInstance ServiceInfoToDnsSdInstance(const ServiceInfo& service);
+discovery::DnsSdInstance ReceiverInfoToDnsSdInstance(
+    const ReceiverInfo& service);
 
-ErrorOr<ServiceInfo> DnsSdInstanceEndpointToServiceInfo(
+ErrorOr<ReceiverInfo> DnsSdInstanceEndpointToReceiverInfo(
     const discovery::DnsSdInstanceEndpoint& endpoint);
 
 }  // namespace cast
 }  // namespace openscreen
 
-#endif  // CAST_COMMON_PUBLIC_SERVICE_INFO_H_
+#endif  // CAST_COMMON_PUBLIC_RECEIVER_INFO_H_
diff --git a/cast/common/public/service_info_unittest.cc b/cast/common/public/receiver_info_unittest.cc
index 08401a45..a7b16e2d 100644
--- a/cast/common/public/service_info_unittest.cc
+++ b/cast/common/public/receiver_info_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "cast/common/public/service_info.h"
+#include "cast/common/public/receiver_info.h"
 
 #include <cstdio>
 #include <sstream>
@@ -20,13 +20,13 @@ constexpr NetworkInterfaceIndex kNetworkInterface = 0;
 
 }
 
-TEST(ServiceInfoTests, ConvertValidFromDnsSd) {
+TEST(ReceiverInfoTests, ConvertValidFromDnsSd) {
   std::string instance = "InstanceId";
   discovery::DnsSdTxtRecord txt = CreateValidTxt();
   discovery::DnsSdInstanceEndpoint record(
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
-  ErrorOr<ServiceInfo> info = DnsSdInstanceEndpointToServiceInfo(record);
+  ErrorOr<ReceiverInfo> info = DnsSdInstanceEndpointToReceiverInfo(record);
   ASSERT_TRUE(info.is_value()) << info;
   EXPECT_EQ(info.value().unique_id, kTestUniqueId);
   EXPECT_TRUE(info.value().v4_address);
@@ -44,7 +44,7 @@ TEST(ServiceInfoTests, ConvertValidFromDnsSd) {
   record = discovery::DnsSdInstanceEndpoint(instance, kCastV2ServiceId,
                                             kCastV2DomainId, txt,
                                             kNetworkInterface, kEndpointV4);
-  info = DnsSdInstanceEndpointToServiceInfo(record);
+  info = DnsSdInstanceEndpointToReceiverInfo(record);
   ASSERT_TRUE(info.is_value());
   EXPECT_EQ(info.value().unique_id, kTestUniqueId);
   EXPECT_TRUE(info.value().v4_address);
@@ -60,7 +60,7 @@ TEST(ServiceInfoTests, ConvertValidFromDnsSd) {
   record = discovery::DnsSdInstanceEndpoint(instance, kCastV2ServiceId,
                                             kCastV2DomainId, txt,
                                             kNetworkInterface, kEndpointV6);
-  info = DnsSdInstanceEndpointToServiceInfo(record);
+  info = DnsSdInstanceEndpointToReceiverInfo(record);
   ASSERT_TRUE(info.is_value());
   EXPECT_EQ(info.value().unique_id, kTestUniqueId);
   EXPECT_FALSE(info.value().v4_address);
@@ -74,42 +74,42 @@ TEST(ServiceInfoTests, ConvertValidFromDnsSd) {
   EXPECT_EQ(info.value().friendly_name, kFriendlyName);
 }
 
-TEST(ServiceInfoTests, ConvertInvalidFromDnsSd) {
+TEST(ReceiverInfoTests, ConvertInvalidFromDnsSd) {
   std::string instance = "InstanceId";
   discovery::DnsSdTxtRecord txt = CreateValidTxt();
   txt.ClearValue(kUniqueIdKey);
   discovery::DnsSdInstanceEndpoint record(
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
-  EXPECT_TRUE(DnsSdInstanceEndpointToServiceInfo(record).is_error());
+  EXPECT_TRUE(DnsSdInstanceEndpointToReceiverInfo(record).is_error());
 
   txt = CreateValidTxt();
   txt.ClearValue(kVersionKey);
   record = discovery::DnsSdInstanceEndpoint(
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
-  EXPECT_TRUE(DnsSdInstanceEndpointToServiceInfo(record).is_error());
+  EXPECT_TRUE(DnsSdInstanceEndpointToReceiverInfo(record).is_error());
 
   txt = CreateValidTxt();
   txt.ClearValue(kCapabilitiesKey);
   record = discovery::DnsSdInstanceEndpoint(
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
-  EXPECT_TRUE(DnsSdInstanceEndpointToServiceInfo(record).is_error());
+  EXPECT_TRUE(DnsSdInstanceEndpointToReceiverInfo(record).is_error());
 
   txt = CreateValidTxt();
   txt.ClearValue(kStatusKey);
   record = discovery::DnsSdInstanceEndpoint(
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
-  EXPECT_TRUE(DnsSdInstanceEndpointToServiceInfo(record).is_error());
+  EXPECT_TRUE(DnsSdInstanceEndpointToReceiverInfo(record).is_error());
 
   txt = CreateValidTxt();
   txt.ClearValue(kFriendlyNameKey);
   record = discovery::DnsSdInstanceEndpoint(
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
-  EXPECT_TRUE(DnsSdInstanceEndpointToServiceInfo(record).is_error());
+  EXPECT_TRUE(DnsSdInstanceEndpointToReceiverInfo(record).is_error());
 
   txt = CreateValidTxt();
   txt.ClearValue(kModelNameKey);
@@ -117,11 +117,11 @@ TEST(ServiceInfoTests, ConvertInvalidFromDnsSd) {
       instance, kCastV2ServiceId, kCastV2DomainId, txt, kNetworkInterface,
       kEndpointV4, kEndpointV6);
   // Note: Model name is an optional field.
-  EXPECT_FALSE(DnsSdInstanceEndpointToServiceInfo(record).is_error());
+  EXPECT_FALSE(DnsSdInstanceEndpointToReceiverInfo(record).is_error());
 }
 
-TEST(ServiceInfoTests, ConvertValidToDnsSd) {
-  ServiceInfo info;
+TEST(ReceiverInfoTests, ConvertValidToDnsSd) {
+  ReceiverInfo info;
   info.v4_address = kAddressV4;
   info.v6_address = kAddressV6;
   info.port = kPort;
@@ -131,7 +131,7 @@ TEST(ServiceInfoTests, ConvertValidToDnsSd) {
   info.status = kStatusParsed;
   info.model_name = kModelName;
   info.friendly_name = kFriendlyName;
-  discovery::DnsSdInstance instance = ServiceInfoToDnsSdInstance(info);
+  discovery::DnsSdInstance instance = ReceiverInfoToDnsSdInstance(info);
   CompareTxtString(instance.txt(), kUniqueIdKey, kTestUniqueId);
   CompareTxtString(instance.txt(), kCapabilitiesKey, kCapabilitiesString);
   CompareTxtString(instance.txt(), kModelNameKey, kModelName);
@@ -140,7 +140,7 @@ TEST(ServiceInfoTests, ConvertValidToDnsSd) {
   CompareTxtInt(instance.txt(), kStatusKey, kStatus);
 }
 
-TEST(ServiceInfoTests, ParseServiceInfoFromRealTXT) {
+TEST(ReceiverInfoTests, ParseReceiverInfoFromRealTXT) {
   constexpr struct {
     const char* key;
     const char* value;
@@ -168,9 +168,9 @@ TEST(ServiceInfoTests, ParseServiceInfoFromRealTXT) {
       "InstanceId", kCastV2ServiceId, kCastV2DomainId, std::move(txt),
       kNetworkInterface, kEndpointV4, kEndpointV6);
 
-  const ErrorOr<ServiceInfo> result =
-      DnsSdInstanceEndpointToServiceInfo(record);
-  const ServiceInfo& info = result.value();
+  const ErrorOr<ReceiverInfo> result =
+      DnsSdInstanceEndpointToReceiverInfo(record);
+  const ReceiverInfo& info = result.value();
   EXPECT_EQ(info.unique_id, "4ef522244a5a877f35ddead7d98702e6");
   EXPECT_EQ(info.protocol_version, 5);
   EXPECT_TRUE(info.capabilities & (kHasVideoOutput | kHasAudioOutput));
diff --git a/cast/common/public/testing/discovery_utils.h b/cast/common/public/testing/discovery_utils.h
index b0d7d03b..6e805e74 100644
--- a/cast/common/public/testing/discovery_utils.h
+++ b/cast/common/public/testing/discovery_utils.h
@@ -7,7 +7,7 @@
 
 #include <string>
 
-#include "cast/common/public/service_info.h"
+#include "cast/common/public/receiver_info.h"
 #include "discovery/dnssd/public/dns_sd_txt_record.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"