Refactor Attachment processing.

PiperOrigin-RevId: 846789473

sharing/BUILD

@@ -221,6 +221,7 @@ cc_library(
         ":attachments",
         ":connection_types",
         ":incoming_frame_reader",
+        ":nearby_sharing_util",
         ":paired_key_verification_runner",
         ":thread_timer",
         ":transfer_metadata",
@@ -287,6 +288,25 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "nearby_sharing_util",
+    srcs = ["nearby_sharing_util.cc"],
+    hdrs = ["nearby_sharing_util.h"],
+    deps = [
+        ":types",
+        "//internal/base:file_path",
+        "//internal/platform:types",
+        "//proto:sharing_enums_cc_proto",
+        "//sharing/certificates",
+        "//sharing/common:enum",
+        "//sharing/internal/base",
+        "//sharing/internal/public:logging",
+        "@com_google_absl//absl/hash",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:string_view",
+    ],
+)
+
 cc_library(
     name = "nearby_sharing_service",
     srcs = [
@@ -300,7 +320,6 @@ cc_library(
         "nearby_sharing_service_factory.cc",
         "nearby_sharing_service_impl.cc",
         "nearby_sharing_settings.cc",
-        "nearby_sharing_util.cc",
         "service_observers.cc",
         "service_observers.h",
         "transfer_manager.cc",
@@ -319,7 +338,6 @@ cc_library(
         "nearby_sharing_service_factory.h",
         "nearby_sharing_service_impl.h",
         "nearby_sharing_settings.h",
-        "nearby_sharing_util.h",
         "payload_listener.h",
         "share_target_discovered_callback.h",
         "transfer_manager.h",
@@ -341,6 +359,7 @@ cc_library(
         ":incoming_frame_reader",
         ":nearby_connection_impl",
         ":nearby_sharing_decoder",
+        ":nearby_sharing_util",
         ":outgoing_targets_manager",
         ":paired_key_verification_runner",
         ":share_session",
@@ -386,7 +405,6 @@ cc_library(
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/functional:bind_front",
-        "@com_google_absl//absl/hash",
         "@com_google_absl//absl/meta:type_traits",
         "@com_google_absl//absl/random",
         "@com_google_absl//absl/status:statusor",

sharing/nearby_sharing_service_impl.cc

@@ -204,6 +204,30 @@ std::string GenerateDeviceId() {
   return id;
 }
 
+std::string ReceiveSurfaceStateToString(
+    NearbySharingService::ReceiveSurfaceState state) {
+  switch (state) {
+    case NearbySharingService::ReceiveSurfaceState::kForeground:
+      return "FOREGROUND";
+    case NearbySharingService::ReceiveSurfaceState::kBackground:
+      return "BACKGROUND";
+    case NearbySharingService::ReceiveSurfaceState::kUnknown:
+      return "UNKNOWN";
+  }
+}
+
+std::string SendSurfaceStateToString(
+    NearbySharingService::SendSurfaceState state) {
+  switch (state) {
+    case NearbySharingService::SendSurfaceState::kForeground:
+      return "FOREGROUND";
+    case NearbySharingService::SendSurfaceState::kBackground:
+      return "BACKGROUND";
+    case NearbySharingService::SendSurfaceState::kUnknown:
+      return "UNKNOWN";
+  }
+}
+
 }  // namespace
 
 NearbySharingServiceImpl::NearbySharingServiceImpl(
@@ -726,16 +750,10 @@ void NearbySharingServiceImpl::SendAttachments(
           return;
         }
 
-        session->InitiateSendAttachments(std::move(attachment_container));
-
         app_info_->SetActiveFlag();
 
-        if (!CreatePayloads(*session)) {
-          session->UpdateTransferMetadata(
-              TransferMetadataBuilder()
-                  .set_status(TransferMetadata::Status::kMediaUnavailable)
-                  .build());
-        } else {
+        if (session->InitiateSendAttachments(
+                std::move(attachment_container))) {
           OutgoingSessionConnect(*session, std::move(*endpoint_info));
         }
         std::move(status_codes_callback)(StatusCodes::kOk);
@@ -747,19 +765,11 @@ void NearbySharingServiceImpl::OutgoingSessionConnect(
   OnTransferStarted(/*is_incoming=*/false);
   is_connecting_ = true;
   InvalidateSendSurfaceState();
-  // Send process initialized successfully, from now on status updated
-  // will be sent out via OnOutgoingTransferUpdate().
-  session.UpdateTransferMetadata(
-      TransferMetadataBuilder()
-          .set_status(TransferMetadata::Status::kConnecting)
-          .build());
 
-  std::optional<std::vector<uint8_t>> bluetooth_mac_address =
-      GetBluetoothMacAddressForShareTarget(session);
   int64_t share_target_id = session.share_target().id;
   session.Connect(
-      std::move(endpoint_info), std::move(bluetooth_mac_address),
-      settings_->GetDataUsage(), GetDisableWifiHotspotState(),
+      std::move(endpoint_info), settings_->GetDataUsage(),
+      GetDisableWifiHotspotState(),
       absl::bind_front(&NearbySharingServiceImpl::OnOutgoingConnection, this,
                        share_target_id));
 }
@@ -2185,40 +2195,6 @@ void NearbySharingServiceImpl::OnOutgoingConnection(
   }
 }
 
-bool NearbySharingServiceImpl::CreatePayloads(OutgoingShareSession& session) {
-  bool has_payloads = !session.text_payloads().empty() ||
-                      !session.file_payloads().empty() ||
-                      !session.wifi_credentials_payloads().empty();
-  if (has_payloads) {
-    // We may have already created the payloads in the case of retry.
-    // Retry is not implemented. So this is an error case.
-    LOG(WARNING)
-        << __func__
-        << ": Failed to send attachments.  Unexpected payloads already exist.";
-    return false;
-  }
-  session.CreateTextPayloads();
-  session.CreateWifiCredentialsPayloads();
-  bool success = session.CreateFilePayloads();
-  if (success) {
-    has_payloads = !session.text_payloads().empty() ||
-                   !session.file_payloads().empty() ||
-                   !session.wifi_credentials_payloads().empty();
-    if (!has_payloads) {
-      success = false;
-    }
-  }
-  if (!success) {
-    LOG(WARNING) << __func__
-                 << ": Failed to send file to remote ShareTarget. Failed to "
-                    "create payloads.";
-    return false;
-  }
-  // Log analytics event of describing attachments.
-  analytics_recorder_.NewDescribeAttachments(session.attachment_container());
-  return true;
-}
-
 void NearbySharingServiceImpl::Fail(IncomingShareSession& session,
                                     TransferMetadata::Status status) {
   RunOnNearbySharingServiceThreadDelayed(
@@ -2897,20 +2873,6 @@ IncomingShareSession* NearbySharingServiceImpl::GetIncomingShareSession(
   return &it->second;
 }
 
-std::optional<std::vector<uint8_t>>
-NearbySharingServiceImpl::GetBluetoothMacAddressForShareTarget(
-    OutgoingShareSession& session) {
-  const std::optional<NearbyShareDecryptedPublicCertificate>& certificate =
-      session.certificate();
-  if (!certificate) {
-    LOG(ERROR) << __func__ << ": No decrypted public certificate found for "
-               << "share target id: " << session.share_target().id;
-    return std::nullopt;
-  }
-
-  return GetBluetoothMacAddressFromCertificate(*certificate);
-}
-
 void NearbySharingServiceImpl::UnregisterShareTarget(int64_t share_target_id) {
   LOG(INFO) << __func__ << ": Unregister share target " << share_target_id;
 

sharing/nearby_sharing_service_impl.h

@@ -287,7 +287,6 @@ class NearbySharingServiceImpl
                             absl::string_view endpoint_id,
                             NearbyConnection* connection, Status status);
 
-  bool CreatePayloads(OutgoingShareSession& session);
   void OutgoingSessionConnect(OutgoingShareSession& session,
                               std::vector<uint8_t> endpoint_info);
 
@@ -345,9 +344,6 @@ class NearbySharingServiceImpl
   ShareSession* GetShareSession(int64_t share_target_id);
   IncomingShareSession* GetIncomingShareSession(int64_t share_target_id);
 
-  std::optional<std::vector<uint8_t>> GetBluetoothMacAddressForShareTarget(
-      OutgoingShareSession& session);
-
   void UnregisterShareTarget(int64_t share_target_id);
 
   void OnStartAdvertisingResult(bool used_device_name, Status status);

sharing/nearby_sharing_util.cc

@@ -33,34 +33,9 @@
 #include "sharing/common/nearby_share_enums.h"
 #include "sharing/internal/base/encode.h"
 #include "sharing/internal/public/logging.h"
-#include "sharing/nearby_sharing_service.h"
 
 namespace nearby::sharing {
 
-std::string ReceiveSurfaceStateToString(
-    NearbySharingService::ReceiveSurfaceState state) {
-  switch (state) {
-    case NearbySharingService::ReceiveSurfaceState::kForeground:
-      return "FOREGROUND";
-    case NearbySharingService::ReceiveSurfaceState::kBackground:
-      return "BACKGROUND";
-    case NearbySharingService::ReceiveSurfaceState::kUnknown:
-      return "UNKNOWN";
-  }
-}
-
-std::string SendSurfaceStateToString(
-    NearbySharingService::SendSurfaceState state) {
-  switch (state) {
-    case NearbySharingService::SendSurfaceState::kForeground:
-      return "FOREGROUND";
-    case NearbySharingService::SendSurfaceState::kBackground:
-      return "BACKGROUND";
-    case NearbySharingService::SendSurfaceState::kUnknown:
-      return "UNKNOWN";
-  }
-}
-
 std::string PowerLevelToString(PowerLevel level) {
   switch (level) {
     case PowerLevel::kLowPower:

sharing/nearby_sharing_util.h

@@ -27,7 +27,6 @@
 #include "sharing/advertisement.h"
 #include "sharing/certificates/nearby_share_decrypted_public_certificate.h"
 #include "sharing/common/nearby_share_enums.h"
-#include "sharing/nearby_sharing_service.h"
 
 namespace nearby::sharing {
 
@@ -48,12 +47,6 @@ std::optional<std::string> GetDeviceName(
     const Advertisement& advertisement,
     const std::optional<NearbyShareDecryptedPublicCertificate>& certificate);
 
-std::string ReceiveSurfaceStateToString(
-    NearbySharingService::ReceiveSurfaceState state);
-
-std::string SendSurfaceStateToString(
-    NearbySharingService::SendSurfaceState state);
-
 std::string PowerLevelToString(PowerLevel level);
 
 // Return the most stable device identifier with the following priority:

sharing/outgoing_share_session.cc

@@ -39,6 +39,7 @@
 #include "sharing/nearby_connection.h"
 #include "sharing/nearby_connections_manager.h"
 #include "sharing/nearby_connections_types.h"
+#include "sharing/nearby_sharing_util.h"
 #include "sharing/paired_key_verification_runner.h"
 #include "sharing/payload_tracker.h"
 #include "sharing/share_session.h"
@@ -109,6 +110,19 @@ ConnectionLayerStatus ConvertToConnectionLayerStatus(Status status) {
   }
 }
 
+std::optional<std::vector<uint8_t>> GetBluetoothMacAddressForShareTarget(
+    OutgoingShareSession& session) {
+  const std::optional<NearbyShareDecryptedPublicCertificate>& certificate =
+      session.certificate();
+  if (!certificate) {
+    LOG(ERROR) << __func__ << ": No decrypted public certificate found for "
+               << "share target id: " << session.share_target().id;
+    return std::nullopt;
+  }
+
+  return GetBluetoothMacAddressFromCertificate(*certificate);
+}
+
 }  // namespace
 
 OutgoingShareSession::OutgoingShareSession(
@@ -134,7 +148,7 @@ void OutgoingShareSession::InvokeTransferUpdateCallback(
   transfer_update_callback_(*this, metadata);
 }
 
-void OutgoingShareSession::InitiateSendAttachments(
+bool OutgoingShareSession::InitiateSendAttachments(
     std::unique_ptr<AttachmentContainer> attachment_container) {
   SetAttachmentContainer(std::move(*attachment_container));
   is_connecting_ = true;
@@ -147,6 +161,31 @@ void OutgoingShareSession::InitiateSendAttachments(
                                     /*transfer_position=*/1,
                                     /*concurrent_connections=*/1,
                                     share_target());
+  text_payloads_.clear();
+  wifi_credentials_payloads_.clear();
+  file_payloads_.clear();
+  CreateTextPayloads();
+  CreateWifiCredentialsPayloads();
+  bool success = CreateFilePayloads();
+  // Log analytics event of describing attachments.
+  analytics_recorder().NewDescribeAttachments(this->attachment_container());
+  if (success) {
+    if (text_payloads_.empty() && wifi_credentials_payloads_.empty() &&
+        file_payloads_.empty()) {
+      // Fails in no payloads created.
+      success = false;
+    }
+  }
+  if (!success) {
+    LOG(WARNING) << __func__
+                 << ": Failed to send file to remote ShareTarget. Failed to "
+                    "create payloads.";
+    UpdateTransferMetadata(
+        TransferMetadataBuilder()
+            .set_status(TransferMetadata::Status::kMediaUnavailable)
+            .build());
+  }
+  return success;
 }
 
 bool OutgoingShareSession::ProcessKeyVerificationResult(
@@ -169,7 +208,6 @@ void OutgoingShareSession::CreateTextPayloads() {
   if (attachments.empty()) {
     return;
   }
-  text_payloads_.clear();
   text_payloads_.reserve(attachments.size());
   for (const TextAttachment& attachment : attachments) {
     absl::string_view body = attachment.text_body();
@@ -185,7 +223,6 @@ void OutgoingShareSession::CreateWifiCredentialsPayloads() {
   if (attachments.empty()) {
     return;
   }
-  wifi_credentials_payloads_.clear();
   wifi_credentials_payloads_.reserve(attachments.size());
   for (const WifiCredentialsAttachment& attachment : attachments) {
     nearby::sharing::service::proto::WifiCredentials wifi_credentials;
@@ -206,7 +243,6 @@ bool OutgoingShareSession::CreateFilePayloads() {
     return true;
   }
   AttachmentContainer& container = mutable_attachment_container();
-  file_payloads_.clear();
   file_payloads_.reserve(container.GetFileAttachments().size());
 
   for (int i = 0; i < container.GetFileAttachments().size(); ++i) {
@@ -506,15 +542,20 @@ bool OutgoingShareSession::UpdateSessionForDedup(
 
 void OutgoingShareSession::Connect(
     std::vector<uint8_t> endpoint_info,
-    std::optional<std::vector<uint8_t>> bluetooth_mac_address,
     DataUsage data_usage, bool disable_wifi_hotspot,
     std::function<void(absl::string_view endpoint_id,
                        NearbyConnection* connection, Status status)>
         callback) {
+  // Send process initialized successfully, from now on status updated
+  // will be sent out via TransferUpdates.
+  UpdateTransferMetadata(TransferMetadataBuilder()
+                             .set_status(TransferMetadata::Status::kConnecting)
+                             .build());
   connection_start_time_ = clock().Now();
   connections_manager().Connect(
-      std::move(endpoint_info), endpoint_id(), std::move(bluetooth_mac_address),
-      data_usage, GetTransportType(disable_wifi_hotspot), std::move(callback));
+      std::move(endpoint_info), endpoint_id(),
+      GetBluetoothMacAddressForShareTarget(*this), data_usage,
+      GetTransportType(disable_wifi_hotspot), std::move(callback));
 }
 
 bool OutgoingShareSession::OnConnectResult(NearbyConnection* connection,

sharing/outgoing_share_session.h

@@ -67,27 +67,15 @@ class OutgoingShareSession : public ShareSession {
     obfuscated_gaia_id_ = std::move(obfuscated_gaia_id);
   }
 
-  const std::vector<Payload>& text_payloads() const { return text_payloads_; }
-
-  const std::vector<Payload>& wifi_credentials_payloads() const {
-    return wifi_credentials_payloads_;
-  }
-
-  const std::vector<Payload>& file_payloads() const { return file_payloads_; }
-
-  void InitiateSendAttachments(
+  // Returns true if the attachments are valid and payloads are created
+  // successfully.
+  bool InitiateSendAttachments(
       std::unique_ptr<AttachmentContainer> attachment_container);
 
   bool ProcessKeyVerificationResult(
       PairedKeyVerificationRunner::PairedKeyVerificationResult result,
       location::nearby::proto::sharing::OSType share_target_os_type);
 
-  void CreateTextPayloads();
-  void CreateWifiCredentialsPayloads();
-  // Create file payloads and update the file size of all file attachments.
-  // Returns true if all file payloads are created successfully.
-  bool CreateFilePayloads();
-
   // Returns true if the introduction frame is written successfully.
   // `timeout_callback` is called if accept is not received from both sender and
   // receiver within the timeout.
@@ -143,7 +131,6 @@ class OutgoingShareSession : public ShareSession {
   // Establish a connection to the remote device identified by `endpoint_info`.
   // `callback` is called when with the connection establishment status..
   void Connect(std::vector<uint8_t> endpoint_info,
-               std::optional<std::vector<uint8_t>> bluetooth_mac_address,
                nearby::sharing::proto::DataUsage data_usage,
                bool disable_wifi_hotspot,
                std::function<void(absl::string_view endpoint_id,
@@ -167,6 +154,14 @@ class OutgoingShareSession : public ShareSession {
     return IsConnected() || is_connecting_;
   }
 
+  const std::vector<Payload>& text_payloads() const { return text_payloads_; }
+
+  const std::vector<Payload>& wifi_credentials_payloads() const {
+    return wifi_credentials_payloads_;
+  }
+
+  const std::vector<Payload>& file_payloads() const { return file_payloads_; }
+
  protected:
   void InvokeTransferUpdateCallback(const TransferMetadata& metadata) override;
   void OnConnectionDisconnected() override;
@@ -179,6 +174,12 @@ class OutgoingShareSession : public ShareSession {
   bool FillIntroductionFrame(
       nearby::sharing::service::proto::IntroductionFrame* introduction) const;
 
+  void CreateTextPayloads();
+  void CreateWifiCredentialsPayloads();
+  // Create file payloads and update the file size of all file attachments.
+  // Returns true if all file payloads are created successfully.
+  bool CreateFilePayloads();
+
   std::optional<std::string> obfuscated_gaia_id_;
   // All payloads are in the same order as the attachments in the share target.
   std::vector<Payload> text_payloads_;

sharing/outgoing_share_session_test.cc

@@ -73,6 +73,7 @@ using ::nearby::sharing::service::proto::WifiCredentials;
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Eq;
+using ::testing::InSequence;
 using ::testing::IsEmpty;
 using ::testing::IsFalse;
 using ::testing::IsTrue;
@@ -85,9 +86,15 @@ using ::testing::proto::ProtoField;
 
 constexpr absl::string_view kEndpointId = "ABCD";
 constexpr absl::string_view kFile1Name = "someFileName.jpg";
-constexpr absl::string_view kFile2Name = "someFileName2.jpg";
 constexpr int kFile1Size = 1234;
-constexpr int kFile2Size = 5678;
+
+void CreateTempFile(absl::string_view file_name, int file_size) {
+  FilePath file_path =
+      Files::GetTemporaryDirectory().append(FilePath(file_name));
+  std::ofstream file_stream(file_path.GetPath());
+  file_stream << std::string(file_size, 'a');
+  file_stream.close();
+}
 
 class OutgoingShareSessionTest : public ::testing::Test {
  public:
@@ -102,24 +109,11 @@ class OutgoingShareSessionTest : public ::testing::Test {
         file1_(Files::GetTemporaryDirectory().append(FilePath(kFile1Name)),
                /*mime_type=*/"",
                /*parent_folder=*/"/usr/local/parent"),
-        file2_(Files::GetTemporaryDirectory().append(FilePath(kFile2Name)),
-               /*mime_type=*/"",
-               /*parent_folder=*/"/usr/local/parent2"),
         wifi1_(
             "GoogleGuest",
             nearby::sharing::service::proto::WifiCredentialsMetadata::WPA_PSK,
             "somepassword", /*is_hidden=*/true) {
-    // Create temp file attachments
-    FilePath file1_path =
-        Files::GetTemporaryDirectory().append(FilePath(kFile1Name));
-    FilePath file2_path =
-        Files::GetTemporaryDirectory().append(FilePath(kFile2Name));
-    std::ofstream file1_stream(file1_path.GetPath());
-    file1_stream << std::string(kFile1Size, 'a');
-    file1_stream.close();
-    std::ofstream file2_stream(file2_path.GetPath());
-    file2_stream << std::string(kFile2Size, 'b');
-    file2_stream.close();
+    CreateTempFile(kFile1Name, kFile1Size);
   }
 
   std::unique_ptr<AttachmentContainer> CreateDefaultAttachmentContainer() {
@@ -130,13 +124,18 @@ class OutgoingShareSessionTest : public ::testing::Test {
         .Build();
   }
 
-  void InitSendAttachments(
+  bool InitSendAttachments(
       std::unique_ptr<AttachmentContainer> attachment_container) {
+    InSequence seq;
     EXPECT_CALL(mock_event_logger_,
                 Log(Matcher<const SharingLog&>(
                     AllOf((HasCategory(EventCategory::SENDING_EVENT),
                            HasEventType(EventType::SEND_START))))));
-    session_.InitiateSendAttachments(std::move(attachment_container));
+    EXPECT_CALL(mock_event_logger_,
+                Log(Matcher<const SharingLog&>(
+                    AllOf((HasCategory(EventCategory::SENDING_EVENT),
+                           HasEventType(EventType::DESCRIBE_ATTACHMENTS))))));
+    return session_.InitiateSendAttachments(std::move(attachment_container));
   }
 
   void ConnectionSuccess(NearbyConnection* connection) {
@@ -145,7 +144,10 @@ class OutgoingShareSessionTest : public ::testing::Test {
                     AllOf((HasCategory(EventCategory::SENDING_EVENT),
                            HasEventType(EventType::ESTABLISH_CONNECTION))))));
     connections_manager_.set_nearby_connection(connection);
-    session_.Connect({}, {}, proto::DataUsage::ONLINE_DATA_USAGE,
+    EXPECT_CALL(transfer_metadata_callback_,
+                Call(_, AllOf(HasStatus(TransferMetadata::Status::kConnecting),
+                              Not(IsFinalStatus()))));
+    session_.Connect(/*endpoint_info=*/{}, proto::DataUsage::ONLINE_DATA_USAGE,
                      /*disable_wifi_hotspot=*/false,
                      [](absl::string_view endpoint_id,
                         NearbyConnection* connection, Status status) {});
@@ -168,132 +170,108 @@ class OutgoingShareSessionTest : public ::testing::Test {
   TextAttachment text1_;
   TextAttachment text2_;
   FileAttachment file1_;
-  FileAttachment file2_;
   WifiCredentialsAttachment wifi1_;
 };
 
-TEST_F(OutgoingShareSessionTest, CreateTextPayloadsWithNoTextAttachments) {
-  OutgoingShareSession session(
-      &fake_clock_, fake_task_runner_, &connections_manager_,
-      analytics_recorder_, std::string(kEndpointId), share_target_,
-      [](OutgoingShareSession&, const TransferMetadata&) {});
-  session.CreateTextPayloads();
-  const std::vector<Payload>& payloads = session.text_payloads();
+TEST_F(OutgoingShareSessionTest, InitiateSendAttachmentsWithNoAttachments) {
+  EXPECT_CALL(
+      transfer_metadata_callback_,
+      Call(_, AllOf(HasStatus(TransferMetadata::Status::kMediaUnavailable),
+                    IsFinalStatus())));
 
-  EXPECT_THAT(payloads, IsEmpty());
+  EXPECT_THAT(
+      InitSendAttachments(AttachmentContainer::Builder({}, {}, {}).Build()),
+      IsFalse());
+
+  EXPECT_THAT(session_.text_payloads(), IsEmpty());
+  EXPECT_THAT(session_.wifi_credentials_payloads(), IsEmpty());
+  EXPECT_THAT(session_.file_payloads(), IsEmpty());
 }
 
-TEST_F(OutgoingShareSessionTest, CreateTextPayloads) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
-  session_.CreateTextPayloads();
-  const std::vector<Payload>& payloads = session_.text_payloads();
-  auto& attachment_payload_map = session_.attachment_payload_map();
+TEST_F(OutgoingShareSessionTest, InitiateSendAttachmentsSuccess) {
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
 
-  ASSERT_THAT(payloads, SizeIs(2));
-  EXPECT_THAT(payloads[0].content.type, Eq(PayloadContent::Type::kBytes));
-  EXPECT_THAT(payloads[1].content.type, Eq(PayloadContent::Type::kBytes));
-  EXPECT_THAT(payloads[0].content.bytes_payload.bytes,
+  const std::vector<Payload>& text_payloads = session_.text_payloads();
+  ASSERT_THAT(text_payloads, SizeIs(2));
+  EXPECT_THAT(text_payloads[0].content.type, Eq(PayloadContent::Type::kBytes));
+  EXPECT_THAT(text_payloads[1].content.type, Eq(PayloadContent::Type::kBytes));
+  EXPECT_THAT(text_payloads[0].content.bytes_payload.bytes,
               Eq(std::vector<uint8_t>(text1_.text_body().begin(),
                                       text1_.text_body().end())));
-  EXPECT_THAT(payloads[1].content.bytes_payload.bytes,
+  EXPECT_THAT(text_payloads[1].content.bytes_payload.bytes,
               Eq(std::vector<uint8_t>(text2_.text_body().begin(),
                                       text2_.text_body().end())));
 
-  ASSERT_THAT(attachment_payload_map, SizeIs(2));
-  ASSERT_THAT(attachment_payload_map.contains(text1_.id()), IsTrue());
-  EXPECT_THAT(attachment_payload_map.at(text1_.id()), Eq(payloads[0].id));
-  ASSERT_THAT(attachment_payload_map.contains(text2_.id()), IsTrue());
-  EXPECT_THAT(attachment_payload_map.at(text2_.id()), Eq(payloads[1].id));
-}
+  const std::vector<Payload>& wifi_payloads =
+      session_.wifi_credentials_payloads();
 
-TEST_F(OutgoingShareSessionTest, CreateFilePayloadsWithNoFileAttachments) {
-  OutgoingShareSession session(
-      &fake_clock_, fake_task_runner_, &connections_manager_,
-      analytics_recorder_, std::string(kEndpointId), share_target_,
-      [](OutgoingShareSession&, const TransferMetadata&) {});
-
-  EXPECT_THAT(session.CreateFilePayloads(), IsTrue());
-  const std::vector<Payload>& payloads = session.file_payloads();
-
-  EXPECT_THAT(payloads, IsEmpty());
-}
-
-TEST_F(OutgoingShareSessionTest,
-       CreateFilePayloadsWithNonexistentFileAttachment) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
-  // Remove attachment file1.
-  Files::RemoveFile(
-      Files::GetTemporaryDirectory().append(FilePath(kFile1Name)));
-  EXPECT_THAT(session_.CreateFilePayloads(), IsFalse());
-  const std::vector<Payload>& payloads = session_.file_payloads();
-
-  EXPECT_THAT(payloads, IsEmpty());
-}
-
-TEST_F(OutgoingShareSessionTest, CreateFilePayloads) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
-  session_.CreateFilePayloads();
-  const std::vector<Payload>& payloads = session_.file_payloads();
-  auto& attachment_payload_map = session_.attachment_payload_map();
-
-  ASSERT_THAT(payloads, SizeIs(1));
-  EXPECT_THAT(payloads[0].content.type, Eq(PayloadContent::Type::kFile));
-  EXPECT_THAT(payloads[0].content.file_payload.parent_folder,
-              Eq(file1_.parent_folder()));
-  EXPECT_THAT(payloads[0].content.file_payload.file_path,
-              Eq(file1_.file_path()));
-
-  EXPECT_THAT(attachment_payload_map, SizeIs(1));
-  ASSERT_THAT(attachment_payload_map.contains(file1_.id()), IsTrue());
-  EXPECT_THAT(attachment_payload_map.at(file1_.id()), Eq(payloads[0].id));
-
-  EXPECT_THAT(session_.attachment_container().GetFileAttachments()[0].size(),
-              Eq(kFile1Size));
-}
-
-TEST_F(OutgoingShareSessionTest, CreateWifiPayloadsWithNoWifiAttachments) {
-  OutgoingShareSession session(
-      &fake_clock_, fake_task_runner_, &connections_manager_,
-      analytics_recorder_, std::string(kEndpointId), share_target_,
-      [](OutgoingShareSession&, const TransferMetadata&) {});
-  session.CreateWifiCredentialsPayloads();
-  const std::vector<Payload>& payloads = session.file_payloads();
-
-  EXPECT_THAT(payloads, IsEmpty());
-}
-
-TEST_F(OutgoingShareSessionTest, CreateWifiCredentialsPayloads) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
-  session_.CreateWifiCredentialsPayloads();
-  const std::vector<Payload>& payloads = session_.wifi_credentials_payloads();
-  auto& attachment_payload_map = session_.attachment_payload_map();
-
-  ASSERT_THAT(payloads, SizeIs(1));
-  EXPECT_THAT(payloads[0].content.type, Eq(PayloadContent::Type::kBytes));
+  ASSERT_THAT(wifi_payloads, SizeIs(1));
+  EXPECT_THAT(wifi_payloads[0].content.type, Eq(PayloadContent::Type::kBytes));
   WifiCredentials wifi_credentials;
   EXPECT_THAT(wifi_credentials.ParseFromArray(
-                  payloads[0].content.bytes_payload.bytes.data(),
-                  payloads[0].content.bytes_payload.bytes.size()),
+                  wifi_payloads[0].content.bytes_payload.bytes.data(),
+                  wifi_payloads[0].content.bytes_payload.bytes.size()),
               IsTrue());
   EXPECT_THAT(wifi_credentials.password(), Eq(wifi1_.password()));
   EXPECT_THAT(wifi_credentials.has_hidden_ssid(), Eq(wifi1_.is_hidden()));
 
-  ASSERT_THAT(attachment_payload_map, SizeIs(1));
+  const std::vector<Payload>& file_payloads = session_.file_payloads();
+  ASSERT_THAT(file_payloads, SizeIs(1));
+  EXPECT_THAT(file_payloads[0].content.type, Eq(PayloadContent::Type::kFile));
+  EXPECT_THAT(file_payloads[0].content.file_payload.parent_folder,
+              Eq(file1_.parent_folder()));
+  EXPECT_THAT(file_payloads[0].content.file_payload.file_path,
+              Eq(file1_.file_path()));
+
+
+  EXPECT_THAT(session_.attachment_container().GetFileAttachments()[0].size(),
+              Eq(kFile1Size));
+
+  auto& attachment_payload_map = session_.attachment_payload_map();
+
+  ASSERT_THAT(attachment_payload_map, SizeIs(4));
+  ASSERT_THAT(attachment_payload_map.contains(text1_.id()), IsTrue());
+  EXPECT_THAT(attachment_payload_map.at(text1_.id()), Eq(text_payloads[0].id));
+  ASSERT_THAT(attachment_payload_map.contains(text2_.id()), IsTrue());
+  EXPECT_THAT(attachment_payload_map.at(text2_.id()), Eq(text_payloads[1].id));
   ASSERT_THAT(attachment_payload_map.contains(wifi1_.id()), IsTrue());
-  EXPECT_THAT(attachment_payload_map.at(wifi1_.id()), Eq(payloads[0].id));
+  EXPECT_THAT(attachment_payload_map.at(wifi1_.id()), Eq(wifi_payloads[0].id));
+  ASSERT_THAT(attachment_payload_map.contains(file1_.id()), IsTrue());
+  EXPECT_THAT(attachment_payload_map.at(file1_.id()), Eq(file_payloads[0].id));
+}
+
+TEST_F(OutgoingShareSessionTest,
+       InitiateSendAttachmentsWithNonexistentFileAttachment) {
+  // Remove attachment file1.
+  Files::RemoveFile(
+      Files::GetTemporaryDirectory().append(FilePath(kFile1Name)));
+  EXPECT_CALL(
+      transfer_metadata_callback_,
+      Call(_, AllOf(HasStatus(TransferMetadata::Status::kMediaUnavailable),
+                    IsFinalStatus())));
+
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsFalse());
+  const std::vector<Payload>& payloads = session_.file_payloads();
+
+  EXPECT_THAT(payloads, IsEmpty());
 }
 
 TEST_F(OutgoingShareSessionTest, ConnectNoDisableWifiHotspot) {
   std::vector<uint8_t> endpoint_info = {1, 2, 3, 4};
-  std::vector<uint8_t> bluetooth_mac_address = {5, 6, 7, 8};
-  file1_.set_size(1000000);  // 1MB
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  // Set file size to 1MB.
+  CreateTempFile(kFile1Name, 1000000);
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   NearbyConnectionImpl nearby_connection(device_info_);
   connections_manager_.set_nearby_connection(&nearby_connection);
 
+  EXPECT_CALL(transfer_metadata_callback_,
+              Call(_, AllOf(HasStatus(TransferMetadata::Status::kConnecting),
+                            Not(IsFinalStatus()))));
   session_.Connect(
-      endpoint_info, bluetooth_mac_address,
-      nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
+      endpoint_info, nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
       /*disable_wifi_hotspot=*/false,
       [&nearby_connection](absl::string_view endpoint_id,
                            NearbyConnection* connection, Status status) {
@@ -313,15 +291,18 @@ TEST_F(OutgoingShareSessionTest, ConnectNoDisableWifiHotspot) {
 
 TEST_F(OutgoingShareSessionTest, ConnectDisableWifiHotspot) {
   std::vector<uint8_t> endpoint_info = {1, 2, 3, 4};
-  std::vector<uint8_t> bluetooth_mac_address = {5, 6, 7, 8};
-  file1_.set_size(1000000);  // 1MB
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  // Set file size to 1MB.
+  CreateTempFile(kFile1Name, 1000000);
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   NearbyConnectionImpl nearby_connection(device_info_);
   connections_manager_.set_nearby_connection(&nearby_connection);
 
+  EXPECT_CALL(transfer_metadata_callback_,
+              Call(_, AllOf(HasStatus(TransferMetadata::Status::kConnecting),
+                            Not(IsFinalStatus()))));
   session_.Connect(
-      endpoint_info, bluetooth_mac_address,
-      nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
+      endpoint_info, nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
       /*disable_wifi_hotspot=*/true,
       [&nearby_connection](absl::string_view endpoint_id,
                            NearbyConnection* connection, Status status) {
@@ -340,15 +321,17 @@ TEST_F(OutgoingShareSessionTest, ConnectDisableWifiHotspot) {
 }
 
 TEST_F(OutgoingShareSessionTest, OnConnectResultSuccessLogsSessionDuration) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   session_.set_session_id(1234);
   std::vector<uint8_t> endpoint_info = {1, 2, 3, 4};
-  std::vector<uint8_t> bluetooth_mac_address = {5, 6, 7, 8};
   NearbyConnectionImpl nearby_connection(device_info_);
   connections_manager_.set_nearby_connection(&nearby_connection);
+  EXPECT_CALL(transfer_metadata_callback_,
+              Call(_, AllOf(HasStatus(TransferMetadata::Status::kConnecting),
+                            Not(IsFinalStatus()))));
   session_.Connect(
-      endpoint_info, bluetooth_mac_address,
-      nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
+      endpoint_info, nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
       /*disable_wifi_hotspot=*/false,
       [&nearby_connection](absl::string_view endpoint_id,
                            NearbyConnection* connection, Status status) {
@@ -371,11 +354,14 @@ TEST_F(OutgoingShareSessionTest, OnConnectResultSuccessLogsSessionDuration) {
 }
 
 TEST_F(OutgoingShareSessionTest, OnConnectResultFailureLogsSessionDuration) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   session_.set_session_id(1234);
   std::vector<uint8_t> endpoint_info = {1, 2, 3, 4};
-  std::vector<uint8_t> bluetooth_mac_address = {5, 6, 7, 8};
-  session_.Connect(endpoint_info, bluetooth_mac_address,
+  EXPECT_CALL(transfer_metadata_callback_,
+              Call(_, AllOf(HasStatus(TransferMetadata::Status::kConnecting),
+                            Not(IsFinalStatus()))));
+  session_.Connect(endpoint_info,
                    nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
                    /*disable_wifi_hotspot=*/false,
                    [](absl::string_view endpoint_id,
@@ -399,19 +385,12 @@ TEST_F(OutgoingShareSessionTest, OnConnectResultFailureLogsSessionDuration) {
       IsFalse());
 }
 
-TEST_F(OutgoingShareSessionTest, SendIntroductionWithoutPayloads) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
-  EXPECT_THAT(session_.SendIntroduction([]() {}), IsFalse());
-}
-
 TEST_F(OutgoingShareSessionTest, SendIntroductionSuccess) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   session_.set_session_id(1234);
   NearbyConnectionImpl connection(device_info_);
   ConnectionSuccess(&connection);
-  session_.CreateFilePayloads();
-  session_.CreateTextPayloads();
-  session_.CreateWifiCredentialsPayloads();
   EXPECT_CALL(mock_event_logger_,
               Log(Matcher<const SharingLog&>(AllOf(
                   (HasCategory(EventCategory::SENDING_EVENT),
@@ -481,11 +460,10 @@ TEST_F(OutgoingShareSessionTest, SendIntroductionTimeout) {
                                    std::vector<FileAttachment>{},
                                    std::vector<WifiCredentialsAttachment>{})
           .Build();
-  InitSendAttachments(std::move(container));
+  EXPECT_THAT(InitSendAttachments(std::move(container)), IsTrue());
   session_.set_session_id(1234);
   NearbyConnectionImpl connection(device_info_);
   ConnectionSuccess(&connection);
-  session_.CreateTextPayloads();
   EXPECT_CALL(mock_event_logger_,
               Log(Matcher<const SharingLog&>(AllOf(
                   (HasCategory(EventCategory::SENDING_EVENT),
@@ -509,11 +487,10 @@ TEST_F(OutgoingShareSessionTest, SendIntroductionTimeoutCancelled) {
                                    std::vector<FileAttachment>{},
                                    std::vector<WifiCredentialsAttachment>{})
           .Build();
-  InitSendAttachments(std::move(container));
+  EXPECT_THAT(InitSendAttachments(std::move(container)), IsTrue());
   session_.set_session_id(1234);
   NearbyConnectionImpl connection(device_info_);
   ConnectionSuccess(&connection);
-  session_.CreateTextPayloads();
   EXPECT_CALL(mock_event_logger_,
               Log(Matcher<const SharingLog&>(AllOf(
                   (HasCategory(EventCategory::SENDING_EVENT),
@@ -561,11 +538,10 @@ TEST_F(OutgoingShareSessionTest, AcceptTransferSuccess) {
                                    std::vector<FileAttachment>{},
                                    std::vector<WifiCredentialsAttachment>{})
           .Build();
-  InitSendAttachments(std::move(container));
+  EXPECT_THAT(InitSendAttachments(std::move(container)), IsTrue());
   session_.set_session_id(1234);
   NearbyConnectionImpl connection(device_info_);
   ConnectionSuccess(&connection);
-  session_.CreateTextPayloads();
   EXPECT_CALL(mock_event_logger_,
               Log(Matcher<const SharingLog&>(AllOf(
                   (HasCategory(EventCategory::SENDING_EVENT),
@@ -666,11 +642,9 @@ TEST_F(OutgoingShareSessionTest, HandleConnectionResponseAcceptResponse) {
 }
 
 TEST_F(OutgoingShareSessionTest, SendPayloads) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   session_.set_session_id(1234);
-  session_.CreateFilePayloads();
-  session_.CreateTextPayloads();
-  session_.CreateWifiCredentialsPayloads();
   MockFunction<void()> payload_transder_update_callback;
   StrictMock<MockFunction<void(
       std::unique_ptr<Payload>,
@@ -707,11 +681,9 @@ TEST_F(OutgoingShareSessionTest, SendPayloads) {
 }
 
 TEST_F(OutgoingShareSessionTest, SendPayloadsSetsAdvancedProtectionFlags) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   session_.set_session_id(1234);
-  session_.CreateFilePayloads();
-  session_.CreateTextPayloads();
-  session_.CreateWifiCredentialsPayloads();
   MockFunction<void()> payload_transder_update_callback;
   StrictMock<MockFunction<void(
       std::unique_ptr<Payload>,
@@ -750,11 +722,9 @@ TEST_F(OutgoingShareSessionTest, SendPayloadsSetsAdvancedProtectionFlags) {
 }
 
 TEST_F(OutgoingShareSessionTest, SendNextPayload) {
-  InitSendAttachments(CreateDefaultAttachmentContainer());
+  EXPECT_THAT(InitSendAttachments(CreateDefaultAttachmentContainer()),
+              IsTrue());
   session_.set_session_id(1234);
-  session_.CreateFilePayloads();
-  session_.CreateTextPayloads();
-  session_.CreateWifiCredentialsPayloads();
   MockFunction<void()> payload_transder_update_callback;
   StrictMock<MockFunction<void(
       std::unique_ptr<Payload>,
@@ -877,8 +847,10 @@ TEST_F(OutgoingShareSessionTest, DelayCompleteDisconnectTimeout) {
   NearbyConnectionImpl connection(device_info_);
   session_.set_session_id(1234);
   std::vector<uint8_t> endpoint_info = {1, 2, 3, 4};
-  std::vector<uint8_t> bluetooth_mac_address = {5, 6, 7, 8};
-  session_.Connect(endpoint_info, bluetooth_mac_address,
+  EXPECT_CALL(transfer_metadata_callback_,
+              Call(_, AllOf(HasStatus(TransferMetadata::Status::kConnecting),
+                            Not(IsFinalStatus()))));
+  session_.Connect(endpoint_info,
                    nearby::sharing::proto::DataUsage::ONLINE_DATA_USAGE,
                    /*disable_wifi_hotspot=*/false,
                    [&](absl::string_view endpoint_id,

sharing/outgoing_targets_manager_test.cc

@@ -22,18 +22,17 @@
 #include "protobuf-matchers/protocol-buffer-matchers.h"
 #include "gtest/gtest.h"
 #include "absl/strings/string_view.h"
-#include "internal/base/file_path.h"
 #include "internal/test/fake_clock.h"
 #include "internal/test/fake_device_info.h"
 #include "internal/test/fake_task_runner.h"
 #include "sharing/analytics/analytics_recorder.h"
 #include "sharing/attachment_container.h"
 #include "sharing/fake_nearby_connections_manager.h"
-#include "sharing/file_attachment.h"
 #include "sharing/nearby_connection_impl.h"
 #include "sharing/nearby_connections_types.h"
 #include "sharing/outgoing_share_session.h"
 #include "sharing/share_target.h"
+#include "sharing/text_attachment.h"
 #include "sharing/transfer_metadata.h"
 
 namespace nearby::sharing {
@@ -214,9 +213,12 @@ TEST_F(OutgoingTargetsManagerTest, onShareTargetLostConnectingNotClosed) {
       outgoing_targets_manager_.GetOutgoingShareSession(kShareTargetId);
   ASSERT_NE(session, nullptr);
   // InitiateSendAttachments is called when session starts connecting.
-  session->InitiateSendAttachments(AttachmentContainer::Builder()
-    .AddFileAttachment(FileAttachment(FilePath{""}))
-    .Build());
+  session->InitiateSendAttachments(
+      AttachmentContainer::Builder()
+          .AddTextAttachment(TextAttachment(
+              nearby::sharing::service::proto::TextMetadata::ADDRESS,
+              "A bit of text body 2", "Some text title 2", "text/plain"))
+          .Build());
 
   outgoing_targets_manager_.OnShareTargetLost(std::string(kEndpointId),
                                               Seconds(10));