mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-16 07:36:10 -04:00
Rename ShareTargetInfo to ShareSession.
PiperOrigin-RevId: 646238919
This commit is contained in:
Francis Tsui
committed by
Copybara-Service
Copybara-Service
parent
4a8d97ff5e
commit
d6e8d5f249
@@ -50,34 +50,33 @@ using ::nearby::sharing::service::proto::WifiCredentials;
|
||||
|
||||
} // namespace
|
||||
|
||||
IncomingShareTargetInfo::IncomingShareTargetInfo(
|
||||
IncomingShareSession::IncomingShareSession(
|
||||
std::string endpoint_id, const ShareTarget& share_target,
|
||||
std::function<void(const IncomingShareTargetInfo&, const TransferMetadata&)>
|
||||
std::function<void(const IncomingShareSession&, const TransferMetadata&)>
|
||||
transfer_update_callback)
|
||||
: ShareTargetInfo(std::move(endpoint_id), share_target),
|
||||
: ShareSession(std::move(endpoint_id), share_target),
|
||||
transfer_update_callback_(std::move(transfer_update_callback)) {}
|
||||
|
||||
IncomingShareTargetInfo::IncomingShareTargetInfo(IncomingShareTargetInfo&&) =
|
||||
IncomingShareSession::IncomingShareSession(IncomingShareSession&&) = default;
|
||||
|
||||
IncomingShareSession& IncomingShareSession::operator=(IncomingShareSession&&) =
|
||||
default;
|
||||
|
||||
IncomingShareTargetInfo& IncomingShareTargetInfo::operator=(
|
||||
IncomingShareTargetInfo&&) = default;
|
||||
IncomingShareSession::~IncomingShareSession() = default;
|
||||
|
||||
IncomingShareTargetInfo::~IncomingShareTargetInfo() = default;
|
||||
|
||||
void IncomingShareTargetInfo::InvokeTransferUpdateCallback(
|
||||
void IncomingShareSession::InvokeTransferUpdateCallback(
|
||||
const TransferMetadata& metadata) {
|
||||
transfer_update_callback_(*this, metadata);
|
||||
}
|
||||
|
||||
bool IncomingShareTargetInfo::OnNewConnection(NearbyConnection* connection) {
|
||||
bool IncomingShareSession::OnNewConnection(NearbyConnection* connection) {
|
||||
set_disconnect_status(
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptanceFailed);
|
||||
return true;
|
||||
}
|
||||
|
||||
std::optional<TransferMetadata::Status>
|
||||
IncomingShareTargetInfo::ProcessIntroduction(
|
||||
IncomingShareSession::ProcessIntroduction(
|
||||
const IntroductionFrame& introduction_frame) {
|
||||
int64_t file_size_sum = 0;
|
||||
AttachmentContainer& container = mutable_attachment_container();
|
||||
@@ -149,20 +148,20 @@ IncomingShareTargetInfo::ProcessIntroduction(
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
void IncomingShareTargetInfo::RegisterPayloadListener(
|
||||
Context* context,
|
||||
NearbyConnectionsManager& connections_manager,
|
||||
void IncomingShareSession::RegisterPayloadListener(
|
||||
Context* context, NearbyConnectionsManager& connections_manager,
|
||||
std::function<void(int64_t, TransferMetadata)> update_callback) {
|
||||
const absl::flat_hash_map<int64_t, int64_t>& payload_map =
|
||||
attachment_payload_map();
|
||||
set_payload_tracker(std::make_shared<PayloadTracker>(
|
||||
context, share_target().id, attachment_container(),
|
||||
payload_map, std::move(update_callback)));
|
||||
context, share_target().id, attachment_container(), payload_map,
|
||||
std::move(update_callback)));
|
||||
|
||||
// Register status listener for all payloads.
|
||||
for (auto it = payload_map.begin(); it != payload_map.end(); ++it) {
|
||||
NL_VLOG(1) << __func__ << ": Started listening for progress on payload: "
|
||||
<< it->second << " for attachment: " << it->first;
|
||||
NL_VLOG(1) << __func__
|
||||
<< ": Started listening for progress on payload: " << it->second
|
||||
<< " for attachment: " << it->first;
|
||||
|
||||
connections_manager.RegisterPayloadStatusListener(it->second,
|
||||
payload_tracker());
|
||||
@@ -172,7 +171,7 @@ void IncomingShareTargetInfo::RegisterPayloadListener(
|
||||
}
|
||||
}
|
||||
|
||||
bool IncomingShareTargetInfo::UpdateFilePayloadPaths(
|
||||
bool IncomingShareSession::UpdateFilePayloadPaths(
|
||||
const NearbyConnectionsManager& connections_manager) {
|
||||
AttachmentContainer& container = mutable_attachment_container();
|
||||
bool result = true;
|
||||
@@ -207,7 +206,7 @@ bool IncomingShareTargetInfo::UpdateFilePayloadPaths(
|
||||
return result;
|
||||
}
|
||||
|
||||
bool IncomingShareTargetInfo::UpdatePayloadContents(
|
||||
bool IncomingShareSession::UpdatePayloadContents(
|
||||
const NearbyConnectionsManager& connections_manager) {
|
||||
if (!UpdateFilePayloadPaths(connections_manager)) {
|
||||
return false;
|
||||
@@ -291,7 +290,7 @@ bool IncomingShareTargetInfo::UpdatePayloadContents(
|
||||
return true;
|
||||
}
|
||||
|
||||
bool IncomingShareTargetInfo::FinalizePayloads(
|
||||
bool IncomingShareSession::FinalizePayloads(
|
||||
const NearbyConnectionsManager& connections_manager) {
|
||||
if (!UpdatePayloadContents(connections_manager)) {
|
||||
mutable_attachment_container().ClearAttachments();
|
||||
@@ -300,8 +299,8 @@ bool IncomingShareTargetInfo::FinalizePayloads(
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector<std::filesystem::path>
|
||||
IncomingShareTargetInfo::GetPayloadFilePaths() const {
|
||||
std::vector<std::filesystem::path> IncomingShareSession::GetPayloadFilePaths()
|
||||
const {
|
||||
std::vector<std::filesystem::path> file_paths;
|
||||
const AttachmentContainer& container = attachment_container();
|
||||
const absl::flat_hash_map<int64_t, int64_t>& attachment_paylod_map =
|
||||
|
||||
@@ -26,22 +26,23 @@
|
||||
#include "sharing/nearby_connection.h"
|
||||
#include "sharing/nearby_connections_manager.h"
|
||||
#include "sharing/proto/wire_format.pb.h"
|
||||
#include "sharing/share_target.h"
|
||||
#include "sharing/share_session.h"
|
||||
#include "sharing/share_target.h"
|
||||
#include "sharing/transfer_metadata.h"
|
||||
|
||||
namespace nearby::sharing {
|
||||
|
||||
class IncomingShareTargetInfo : public ShareTargetInfo {
|
||||
// Class that represents a single incoming share session.
|
||||
// This class is thread-compatible.
|
||||
class IncomingShareSession : public ShareSession {
|
||||
public:
|
||||
IncomingShareTargetInfo(std::string endpoint_id,
|
||||
const ShareTarget& share_target,
|
||||
std::function<void(const IncomingShareTargetInfo&,
|
||||
const TransferMetadata&)>
|
||||
transfer_update_callback);
|
||||
IncomingShareTargetInfo(IncomingShareTargetInfo&&);
|
||||
IncomingShareTargetInfo& operator=(IncomingShareTargetInfo&&);
|
||||
~IncomingShareTargetInfo() override;
|
||||
IncomingShareSession(
|
||||
std::string endpoint_id, const ShareTarget& share_target,
|
||||
std::function<void(const IncomingShareSession&, const TransferMetadata&)>
|
||||
transfer_update_callback);
|
||||
IncomingShareSession(IncomingShareSession&&);
|
||||
IncomingShareSession& operator=(IncomingShareSession&&);
|
||||
~IncomingShareSession() override;
|
||||
|
||||
bool IsIncoming() const override { return true; }
|
||||
|
||||
@@ -57,8 +58,7 @@ class IncomingShareTargetInfo : public ShareTargetInfo {
|
||||
const NearbyConnectionsManager& connections_manager);
|
||||
|
||||
void RegisterPayloadListener(
|
||||
Context* context,
|
||||
NearbyConnectionsManager& connections_manager,
|
||||
Context* context, NearbyConnectionsManager& connections_manager,
|
||||
std::function<void(int64_t, TransferMetadata)> update_callback);
|
||||
|
||||
// Once transfer has completed, make payload content available in the
|
||||
@@ -78,7 +78,7 @@ class IncomingShareTargetInfo : public ShareTargetInfo {
|
||||
bool UpdatePayloadContents(
|
||||
const NearbyConnectionsManager& connections_manager);
|
||||
|
||||
std::function<void(const IncomingShareTargetInfo&, const TransferMetadata&)>
|
||||
std::function<void(const IncomingShareSession&, const TransferMetadata&)>
|
||||
transfer_update_callback_;
|
||||
};
|
||||
|
||||
|
||||
@@ -83,11 +83,11 @@ std::unique_ptr<Payload> CreateWifiCredentialsPayload(
|
||||
wifi_payload->id = payload_id;
|
||||
return wifi_payload;
|
||||
}
|
||||
class IncomingShareTargetInfoTest : public ::testing::Test {
|
||||
class IncomingShareSessionTest : public ::testing::Test {
|
||||
protected:
|
||||
IncomingShareTargetInfoTest()
|
||||
: info_(std::string(kEndpointId), share_target_,
|
||||
[](const IncomingShareTargetInfo&, const TransferMetadata&) {}) {
|
||||
IncomingShareSessionTest()
|
||||
: session_(std::string(kEndpointId), share_target_,
|
||||
[](const IncomingShareSession&, const TransferMetadata&) {}) {
|
||||
NL_CHECK(
|
||||
proto2::TextFormat::ParseFromString(R"pb(
|
||||
file_metadata {
|
||||
@@ -139,28 +139,28 @@ class IncomingShareTargetInfoTest : public ::testing::Test {
|
||||
}
|
||||
|
||||
ShareTarget share_target_;
|
||||
IncomingShareTargetInfo info_;
|
||||
IncomingShareSession session_;
|
||||
IntroductionFrame introduction_frame_;
|
||||
};
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionNoSupportedPayload) {
|
||||
TEST_F(IncomingShareSessionTest, ProcessIntroductionNoSupportedPayload) {
|
||||
IntroductionFrame frame;
|
||||
|
||||
EXPECT_THAT(info_.ProcessIntroduction(frame),
|
||||
EXPECT_THAT(session_.ProcessIntroduction(frame),
|
||||
Eq(TransferMetadata::Status::kUnsupportedAttachmentType));
|
||||
EXPECT_THAT(info_.attachment_container().HasAttachments(), IsFalse());
|
||||
EXPECT_THAT(session_.attachment_container().HasAttachments(), IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionEmptyFile) {
|
||||
TEST_F(IncomingShareSessionTest, ProcessIntroductionEmptyFile) {
|
||||
IntroductionFrame frame;
|
||||
frame.mutable_file_metadata();
|
||||
|
||||
EXPECT_THAT(info_.ProcessIntroduction(frame),
|
||||
EXPECT_THAT(session_.ProcessIntroduction(frame),
|
||||
Eq(TransferMetadata::Status::kUnsupportedAttachmentType));
|
||||
EXPECT_THAT(info_.attachment_container().HasAttachments(), IsFalse());
|
||||
EXPECT_THAT(session_.attachment_container().HasAttachments(), IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionFilesTooLarge) {
|
||||
TEST_F(IncomingShareSessionTest, ProcessIntroductionFilesTooLarge) {
|
||||
IntroductionFrame frame;
|
||||
FileMetadata file1;
|
||||
FileMetadata file2;
|
||||
@@ -169,21 +169,21 @@ TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionFilesTooLarge) {
|
||||
frame.mutable_file_metadata()->Add(std::move(file1));
|
||||
frame.mutable_file_metadata()->Add(std::move(file2));
|
||||
|
||||
EXPECT_THAT(info_.ProcessIntroduction(frame),
|
||||
EXPECT_THAT(session_.ProcessIntroduction(frame),
|
||||
Eq(TransferMetadata::Status::kNotEnoughSpace));
|
||||
EXPECT_THAT(info_.attachment_container().HasAttachments(), IsFalse());
|
||||
EXPECT_THAT(session_.attachment_container().HasAttachments(), IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionEmptyText) {
|
||||
TEST_F(IncomingShareSessionTest, ProcessIntroductionEmptyText) {
|
||||
IntroductionFrame frame;
|
||||
frame.mutable_text_metadata();
|
||||
|
||||
EXPECT_THAT(info_.ProcessIntroduction(frame),
|
||||
EXPECT_THAT(session_.ProcessIntroduction(frame),
|
||||
Eq(TransferMetadata::Status::kUnsupportedAttachmentType));
|
||||
EXPECT_THAT(info_.attachment_container().HasAttachments(), IsFalse());
|
||||
EXPECT_THAT(session_.attachment_container().HasAttachments(), IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionSuccess) {
|
||||
TEST_F(IncomingShareSessionTest, ProcessIntroductionSuccess) {
|
||||
FileMetadata filemeta1 = introduction_frame_.file_metadata(0);
|
||||
FileAttachment file1(filemeta1.id(), filemeta1.size(), filemeta1.name(),
|
||||
filemeta1.mime_type(), filemeta1.type(),
|
||||
@@ -207,30 +207,32 @@ TEST_F(IncomingShareTargetInfoTest, ProcessIntroductionSuccess) {
|
||||
WifiCredentialsAttachment wifi2(wifimeta2.id(), wifimeta2.ssid(),
|
||||
wifimeta2.security_type());
|
||||
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().HasAttachments(), IsTrue());
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments(),
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(session_.attachment_container().HasAttachments(), IsTrue());
|
||||
EXPECT_THAT(session_.attachment_container().GetFileAttachments(),
|
||||
UnorderedElementsAre(file1, file2));
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments(),
|
||||
EXPECT_THAT(session_.attachment_container().GetTextAttachments(),
|
||||
UnorderedElementsAre(text1, text2));
|
||||
EXPECT_THAT(info_.attachment_container().GetWifiCredentialsAttachments(),
|
||||
EXPECT_THAT(session_.attachment_container().GetWifiCredentialsAttachments(),
|
||||
UnorderedElementsAre(wifi1, wifi2));
|
||||
EXPECT_THAT(info_.attachment_payload_map().at(filemeta1.id()),
|
||||
EXPECT_THAT(session_.attachment_payload_map().at(filemeta1.id()),
|
||||
Eq(filemeta1.payload_id()));
|
||||
EXPECT_THAT(info_.attachment_payload_map().at(filemeta2.id()),
|
||||
EXPECT_THAT(session_.attachment_payload_map().at(filemeta2.id()),
|
||||
Eq(filemeta2.payload_id()));
|
||||
EXPECT_THAT(info_.attachment_payload_map().at(textmeta1.id()),
|
||||
EXPECT_THAT(session_.attachment_payload_map().at(textmeta1.id()),
|
||||
Eq(textmeta1.payload_id()));
|
||||
EXPECT_THAT(info_.attachment_payload_map().at(textmeta2.id()),
|
||||
EXPECT_THAT(session_.attachment_payload_map().at(textmeta2.id()),
|
||||
Eq(textmeta2.payload_id()));
|
||||
EXPECT_THAT(info_.attachment_payload_map().at(wifimeta1.id()),
|
||||
EXPECT_THAT(session_.attachment_payload_map().at(wifimeta1.id()),
|
||||
Eq(wifimeta1.payload_id()));
|
||||
EXPECT_THAT(info_.attachment_payload_map().at(wifimeta2.id()),
|
||||
EXPECT_THAT(session_.attachment_payload_map().at(wifimeta2.id()),
|
||||
Eq(wifimeta2.payload_id()));
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, UpdateFilePayloadPathsSuccess) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, UpdateFilePayloadPathsSuccess) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
std::filesystem::path file1_path = "/usr/tmp/file1";
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
@@ -242,15 +244,18 @@ TEST_F(IncomingShareTargetInfoTest, UpdateFilePayloadPathsSuccess) {
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id2, CreateFilePayload(payload_id2, file2_path));
|
||||
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(file1_path));
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(file2_path));
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(file1_path));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(file2_path));
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, UpdateFilePayloadPathsWrongType) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, UpdateFilePayloadPathsWrongType) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
@@ -261,11 +266,12 @@ TEST_F(IncomingShareTargetInfoTest, UpdateFilePayloadPathsWrongType) {
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id2, CreateFilePayload(payload_id2, file2_path));
|
||||
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, GetPayloadFilePaths) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, GetPayloadFilePaths) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
std::filesystem::path file1_path = "/usr/tmp/file1";
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
@@ -276,15 +282,17 @@ TEST_F(IncomingShareTargetInfoTest, GetPayloadFilePaths) {
|
||||
int64_t payload_id2 = introduction_frame_.file_metadata(1).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id2, CreateFilePayload(payload_id2, file2_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
|
||||
std::vector<std::filesystem::path> file_paths = info_.GetPayloadFilePaths();
|
||||
std::vector<std::filesystem::path> file_paths =
|
||||
session_.GetPayloadFilePaths();
|
||||
|
||||
EXPECT_THAT(file_paths, UnorderedElementsAre(file1_path, file2_path));
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsSuccess) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, FinalizePayloadsSuccess) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
std::filesystem::path file1_path = "/usr/tmp/file1";
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
@@ -295,7 +303,7 @@ TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsSuccess) {
|
||||
int64_t payload_id2 = introduction_frame_.file_metadata(1).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id2, CreateFilePayload(payload_id2, file2_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
|
||||
std::string text_content1 = "text1";
|
||||
int64_t text_payload_id1 = introduction_frame_.text_metadata(0).payload_id();
|
||||
@@ -319,40 +327,46 @@ TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsSuccess) {
|
||||
wifi_payload_id2,
|
||||
CreateWifiCredentialsPayload(wifi_payload_id2, "password2", true));
|
||||
|
||||
EXPECT_THAT(info_.FinalizePayloads(connections_manager), IsTrue());
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(file1_path));
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(file2_path));
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
Eq(text_content1));
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
Eq(text_content2));
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0].password(),
|
||||
EXPECT_THAT(session_.FinalizePayloads(connections_manager), IsTrue());
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(file1_path));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(file2_path));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
Eq(text_content1));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
Eq(text_content2));
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.password(),
|
||||
Eq("password1"));
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.password(),
|
||||
Eq("password2"));
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.is_hidden(),
|
||||
IsTrue());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsMissingFilePayloads) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, FinalizePayloadsMissingFilePayloads) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
std::filesystem::path file1_path = "/usr/tmp/file1";
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id1, CreateFilePayload(payload_id1, file1_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
|
||||
std::string text_content1 = "text1";
|
||||
int64_t text_payload_id1 = introduction_frame_.text_metadata(0).payload_id();
|
||||
@@ -376,48 +390,54 @@ TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsMissingFilePayloads) {
|
||||
wifi_payload_id2,
|
||||
CreateWifiCredentialsPayload(wifi_payload_id2, "password2", true));
|
||||
|
||||
EXPECT_THAT(info_.FinalizePayloads(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.FinalizePayloads(connections_manager), IsFalse());
|
||||
|
||||
// Verify that attachments are cleared out
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0].password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsMissingTextPayloads) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, FinalizePayloadsMissingTextPayloads) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
std::filesystem::path file1_path = "/usr/tmp/file1";
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id1, CreateFilePayload(payload_id1, file1_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
|
||||
std::filesystem::path file2_path = "/usr/tmp/file2";
|
||||
int64_t payload_id2 = introduction_frame_.file_metadata(1).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id2, CreateFilePayload(payload_id2, file2_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
|
||||
std::string text_content1 = "text1";
|
||||
int64_t text_payload_id1 = introduction_frame_.text_metadata(0).payload_id();
|
||||
@@ -436,48 +456,54 @@ TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsMissingTextPayloads) {
|
||||
wifi_payload_id2,
|
||||
CreateWifiCredentialsPayload(wifi_payload_id2, "password2", true));
|
||||
|
||||
EXPECT_THAT(info_.FinalizePayloads(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.FinalizePayloads(connections_manager), IsFalse());
|
||||
|
||||
// Verify that attachments are cleared out
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0].password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsMissingWifiPayloads) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, FinalizePayloadsMissingWifiPayloads) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
std::filesystem::path file1_path = "/usr/tmp/file1";
|
||||
int64_t payload_id1 = introduction_frame_.file_metadata(0).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id1, CreateFilePayload(payload_id1, file1_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsFalse());
|
||||
|
||||
std::filesystem::path file2_path = "/usr/tmp/file2";
|
||||
int64_t payload_id2 = introduction_frame_.file_metadata(1).payload_id();
|
||||
connections_manager.SetIncomingPayload(
|
||||
payload_id2, CreateFilePayload(payload_id2, file2_path));
|
||||
EXPECT_THAT(info_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
EXPECT_THAT(session_.UpdateFilePayloadPaths(connections_manager), IsTrue());
|
||||
|
||||
std::string text_content1 = "text1";
|
||||
int64_t text_payload_id1 = introduction_frame_.text_metadata(0).payload_id();
|
||||
@@ -495,47 +521,53 @@ TEST_F(IncomingShareTargetInfoTest, FinalizePayloadsMissingWifiPayloads) {
|
||||
wifi_payload_id1,
|
||||
CreateWifiCredentialsPayload(wifi_payload_id1, "password1", false));
|
||||
|
||||
EXPECT_THAT(info_.FinalizePayloads(connections_manager), IsFalse());
|
||||
EXPECT_THAT(session_.FinalizePayloads(connections_manager), IsFalse());
|
||||
|
||||
// Verify that attachments are cleared out
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[0].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetFileAttachments()[1].file_path(),
|
||||
Eq(std::nullopt));
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[0].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(
|
||||
session_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container().GetTextAttachments()[1].text_body(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0].password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[0]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.password(),
|
||||
IsEmpty());
|
||||
EXPECT_THAT(info_.attachment_container()
|
||||
EXPECT_THAT(session_.attachment_container()
|
||||
.GetWifiCredentialsAttachments()[1]
|
||||
.is_hidden(),
|
||||
IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(IncomingShareTargetInfoTest, RegisterPayloadListenerSuccess) {
|
||||
EXPECT_THAT(info_.ProcessIntroduction(introduction_frame_), Eq(std::nullopt));
|
||||
TEST_F(IncomingShareSessionTest, RegisterPayloadListenerSuccess) {
|
||||
EXPECT_THAT(session_.ProcessIntroduction(introduction_frame_),
|
||||
Eq(std::nullopt));
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
FakeContext context;
|
||||
|
||||
info_.RegisterPayloadListener(&context, connections_manager,
|
||||
[](int64_t, TransferMetadata) {});
|
||||
session_.RegisterPayloadListener(&context, connections_manager,
|
||||
[](int64_t, TransferMetadata) {});
|
||||
|
||||
for (auto it : info_.attachment_payload_map()) {
|
||||
for (auto it : session_.attachment_payload_map()) {
|
||||
EXPECT_THAT(
|
||||
connections_manager.GetRegisteredPayloadStatusListener(it.second)
|
||||
.lock(),
|
||||
Eq(info_.payload_tracker().lock()));
|
||||
Eq(session_.payload_tracker().lock()));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -88,7 +88,7 @@ class NearbyShareContactManager;
|
||||
namespace NearbySharingServiceUnitTests {
|
||||
class NearbySharingServiceImplTest_CreateShareTarget_Test;
|
||||
class NearbySharingServiceImplTest_RemoveIncomingPayloads_Test;
|
||||
};
|
||||
}; // namespace NearbySharingServiceUnitTests
|
||||
|
||||
// All methods should be called from the same sequence that created the service.
|
||||
class NearbySharingServiceImpl
|
||||
@@ -108,8 +108,8 @@ class NearbySharingServiceImpl
|
||||
|
||||
public:
|
||||
NearbySharingServiceImpl(
|
||||
std::unique_ptr<nearby::TaskRunner> service_thread,
|
||||
Context* context, nearby::sharing::api::SharingPlatform& sharing_platform,
|
||||
std::unique_ptr<nearby::TaskRunner> service_thread, Context* context,
|
||||
nearby::sharing::api::SharingPlatform& sharing_platform,
|
||||
NearbySharingDecoder* decoder,
|
||||
std::unique_ptr<NearbyConnectionsManager> nearby_connections_manager,
|
||||
nearby::analytics::EventLogger* event_logger = nullptr);
|
||||
@@ -315,33 +315,30 @@ class NearbySharingServiceImpl
|
||||
void OnTransferStarted(bool is_incoming);
|
||||
|
||||
void ReceivePayloads(
|
||||
IncomingShareTargetInfo& share_target_info,
|
||||
IncomingShareSession& session,
|
||||
std::function<void(StatusCodes status_codes)> status_codes_callback);
|
||||
StatusCodes SendPayloads(ShareTargetInfo& info);
|
||||
StatusCodes SendPayloads(ShareSession& session);
|
||||
|
||||
void OnOutgoingConnection(absl::Time connect_start_time,
|
||||
NearbyConnection* connection,
|
||||
OutgoingShareTargetInfo& info);
|
||||
void SendIntroduction(OutgoingShareTargetInfo& info,
|
||||
OutgoingShareSession& session);
|
||||
void SendIntroduction(OutgoingShareSession& session,
|
||||
std::optional<std::string> four_digit_token);
|
||||
|
||||
void CreatePayloads(
|
||||
OutgoingShareTargetInfo& info,
|
||||
std::function<void(OutgoingShareTargetInfo&, bool)> callback);
|
||||
OutgoingShareSession& session,
|
||||
std::function<void(OutgoingShareSession&, bool)> callback);
|
||||
void OnCreatePayloads(std::vector<uint8_t> endpoint_info,
|
||||
OutgoingShareTargetInfo& info, bool success);
|
||||
OutgoingShareSession& session, bool success);
|
||||
|
||||
void Fail(int64_t share_target_id, TransferMetadata::Status status);
|
||||
void OnIncomingAdvertisementDecoded(
|
||||
absl::string_view endpoint_id,
|
||||
const IncomingShareTargetInfo& share_target_info,
|
||||
absl::string_view endpoint_id, const IncomingShareSession& session,
|
||||
std::unique_ptr<Advertisement> advertisement);
|
||||
void OnIncomingTransferUpdate(
|
||||
const IncomingShareTargetInfo& share_target_info,
|
||||
const TransferMetadata& metadata);
|
||||
void OnOutgoingTransferUpdate(
|
||||
OutgoingShareTargetInfo& share_target_info,
|
||||
const TransferMetadata& metadata);
|
||||
void OnIncomingTransferUpdate(const IncomingShareSession& session,
|
||||
const TransferMetadata& metadata);
|
||||
void OnOutgoingTransferUpdate(OutgoingShareSession& session,
|
||||
const TransferMetadata& metadata);
|
||||
void CloseConnection(int64_t share_target_id);
|
||||
void OnIncomingDecryptedCertificate(
|
||||
absl::string_view endpoint_id, const Advertisement& advertisement,
|
||||
@@ -352,16 +349,15 @@ class NearbySharingServiceImpl
|
||||
PairedKeyVerificationRunner::PairedKeyVerificationResult result,
|
||||
::location::nearby::proto::sharing::OSType share_target_os_type);
|
||||
void OnOutgoingConnectionKeyVerificationDone(
|
||||
int64_t share_target_id,
|
||||
std::optional<std::string> four_digit_token,
|
||||
int64_t share_target_id, std::optional<std::string> four_digit_token,
|
||||
PairedKeyVerificationRunner::PairedKeyVerificationResult result,
|
||||
::location::nearby::proto::sharing::OSType share_target_os_type);
|
||||
void ReceiveIntroduction(const IncomingShareTargetInfo& info,
|
||||
void ReceiveIntroduction(const IncomingShareSession& session,
|
||||
std::optional<std::string> four_digit_token);
|
||||
void OnReceivedIntroduction(
|
||||
int64_t share_target_id, std::optional<std::string> four_digit_token,
|
||||
std::optional<nearby::sharing::service::proto::V1Frame> frame);
|
||||
void ReceiveConnectionResponse(ShareTargetInfo& info);
|
||||
void ReceiveConnectionResponse(ShareSession& session);
|
||||
void OnReceiveConnectionResponse(
|
||||
int64_t share_target_id,
|
||||
std::optional<nearby::sharing::service::proto::V1Frame> frame);
|
||||
@@ -384,32 +380,31 @@ class NearbySharingServiceImpl
|
||||
void Cleanup();
|
||||
|
||||
std::optional<ShareTarget> CreateShareTarget(
|
||||
absl::string_view endpoint_id,
|
||||
const Advertisement& advertisement,
|
||||
absl::string_view endpoint_id, const Advertisement& advertisement,
|
||||
const std::optional<NearbyShareDecryptedPublicCertificate>& certificate,
|
||||
bool is_incoming);
|
||||
|
||||
void OnPayloadTransferUpdate(int64_t share_target_id,
|
||||
TransferMetadata metadata);
|
||||
void RemoveIncomingPayloads(const IncomingShareTargetInfo& share_target_info);
|
||||
void RemoveIncomingPayloads(const IncomingShareSession& session);
|
||||
void Disconnect(int64_t share_target_id, TransferMetadata metadata);
|
||||
void OnDisconnectingConnectionTimeout(absl::string_view endpoint_id);
|
||||
|
||||
IncomingShareTargetInfo& CreateIncomingShareTargetInfo(
|
||||
IncomingShareSession& CreateIncomingShareSession(
|
||||
const ShareTarget& share_target, absl::string_view endpoint_id,
|
||||
std::optional<NearbyShareDecryptedPublicCertificate> certificate);
|
||||
OutgoingShareTargetInfo& CreateOutgoingShareTargetInfo(
|
||||
OutgoingShareSession& CreateOutgoingShareSession(
|
||||
const ShareTarget& share_target, absl::string_view endpoint_id,
|
||||
std::optional<NearbyShareDecryptedPublicCertificate> certificate);
|
||||
|
||||
ShareTargetInfo* GetShareTargetInfo(int64_t share_target_id);
|
||||
IncomingShareTargetInfo* GetIncomingShareTargetInfo(int64_t share_target_id);
|
||||
OutgoingShareTargetInfo* GetOutgoingShareTargetInfo(int64_t share_target_id);
|
||||
ShareSession* GetShareSession(int64_t share_target_id);
|
||||
IncomingShareSession* GetIncomingShareSession(int64_t share_target_id);
|
||||
OutgoingShareSession* GetOutgoingShareSession(int64_t share_target_id);
|
||||
|
||||
std::optional<std::vector<uint8_t>> GetBluetoothMacAddressForShareTarget(
|
||||
OutgoingShareTargetInfo& info);
|
||||
OutgoingShareSession& session);
|
||||
|
||||
void ClearOutgoingShareTargetInfoMap();
|
||||
void ClearOutgoingShareSessionMap();
|
||||
void UnregisterShareTarget(int64_t share_target_id);
|
||||
|
||||
void OnStartAdvertisingResult(bool used_device_name, Status status);
|
||||
@@ -421,7 +416,7 @@ class NearbySharingServiceImpl
|
||||
// reference could likely be invalidated by the owner during the multistep
|
||||
// cancellation process.
|
||||
void DoCancel(
|
||||
int64_t share_target_id,
|
||||
int64_t share_target_id,
|
||||
std::function<void(StatusCodes status_codes)> status_codes_callback,
|
||||
bool is_initiator_of_cancellation);
|
||||
|
||||
@@ -534,19 +529,19 @@ class NearbySharingServiceImpl
|
||||
// The most recent outgoing TransferMetadata and ShareTarget.
|
||||
std::optional<std::tuple<ShareTarget, AttachmentContainer, TransferMetadata>>
|
||||
last_outgoing_metadata_;
|
||||
// A map of ShareTarget id to IncomingShareTargetInfo. This lets us know which
|
||||
// A map of ShareTarget id to IncomingShareSession. This lets us know which
|
||||
// Nearby Connections endpoint and public certificate are related to the
|
||||
// incoming share target.
|
||||
absl::flat_hash_map<int64_t, IncomingShareTargetInfo>
|
||||
incoming_share_target_info_map_;
|
||||
absl::flat_hash_map<int64_t, IncomingShareSession>
|
||||
incoming_share_session_map_;
|
||||
// A map of endpoint id to ShareTarget, where each ShareTarget entry
|
||||
// directly corresponds to a OutgoingShareTargetInfo entry in
|
||||
// directly corresponds to a OutgoingShareSession entry in
|
||||
// outgoing_share_target_info_map_;
|
||||
absl::flat_hash_map<std::string, ShareTarget> outgoing_share_target_map_;
|
||||
// A map of ShareTarget id to OutgoingShareTargetInfo. This lets us know which
|
||||
// A map of ShareTarget id to OutgoingShareSession. This lets us know which
|
||||
// endpoint and public certificate are related to the outgoing share target.
|
||||
absl::flat_hash_map<int64_t, OutgoingShareTargetInfo>
|
||||
outgoing_share_target_info_map_;
|
||||
absl::flat_hash_map<int64_t, OutgoingShareSession>
|
||||
outgoing_share_session_map_;
|
||||
// For metrics. The IDs of ShareTargets that are cancelled while trying to
|
||||
// establish an outgoing connection.
|
||||
absl::flat_hash_set<int64_t> all_cancelled_share_target_ids_;
|
||||
|
||||
@@ -1036,8 +1036,7 @@ class NearbySharingServiceImplTest : public testing::Test {
|
||||
};
|
||||
|
||||
PayloadInfo AcceptAndSendPayload(
|
||||
MockTransferUpdateCallback& transfer_callback,
|
||||
int64_t share_target_id) {
|
||||
MockTransferUpdateCallback& transfer_callback, int64_t share_target_id) {
|
||||
PayloadInfo info = {};
|
||||
fake_nearby_connections_manager_->set_send_payload_callback(
|
||||
[&](std::unique_ptr<Payload> payload,
|
||||
@@ -1194,8 +1193,7 @@ class NearbySharingServiceImplTest : public testing::Test {
|
||||
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(1u, container.GetFileAttachments().size());
|
||||
for (const FileAttachment& file :
|
||||
container.GetFileAttachments()) {
|
||||
for (const FileAttachment& file : container.GetFileAttachments()) {
|
||||
EXPECT_TRUE(file.file_path());
|
||||
file_path = *file.file_path();
|
||||
}
|
||||
@@ -1377,13 +1375,9 @@ class TestObserver : public NearbySharingService::Observer {
|
||||
bluetooth_state_ = state;
|
||||
}
|
||||
|
||||
void OnWifiStatusChanged(AdapterState state) override {
|
||||
wifi_state_ = state;
|
||||
}
|
||||
void OnWifiStatusChanged(AdapterState state) override { wifi_state_ = state; }
|
||||
|
||||
void OnLanStatusChanged(AdapterState state) override {
|
||||
lan_state_ = state;
|
||||
}
|
||||
void OnLanStatusChanged(AdapterState state) override { lan_state_ = state; }
|
||||
|
||||
void OnShutdown() override {
|
||||
shutdown_called_ = true;
|
||||
@@ -2435,8 +2429,7 @@ TEST_F(NearbySharingServiceImplTest, UnregisterReceiveSurfaceNeverRegistered) {
|
||||
EXPECT_FALSE(fake_nearby_connections_manager_->IsAdvertising());
|
||||
}
|
||||
|
||||
TEST_F(NearbySharingServiceImplTest,
|
||||
IncomingConnectionClosedAfterShutdown) {
|
||||
TEST_F(NearbySharingServiceImplTest, IncomingConnectionClosedAfterShutdown) {
|
||||
fake_nearby_connections_manager_->SetRawAuthenticationToken(kEndpointId,
|
||||
GetToken());
|
||||
SetUpAdvertisementDecoder(GetValidV1EndpointInfo(),
|
||||
@@ -2474,21 +2467,19 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
SetVisibility(DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS);
|
||||
NiceMock<MockTransferUpdateCallback> callback;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingRemoteAcceptanceFailed,
|
||||
metadata.status());
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingRemoteAcceptanceFailed,
|
||||
metadata.status());
|
||||
}));
|
||||
|
||||
SetUpForegroundReceiveSurface(callback);
|
||||
EXPECT_CALL(*mock_app_info_, SetActiveFlag());
|
||||
service_->OnIncomingConnection(kEndpointId, GetValidV1EndpointInfo(),
|
||||
&connection_);
|
||||
sharing_service_task_runner_->PostTask([this]() {
|
||||
connection_.Close();
|
||||
});
|
||||
sharing_service_task_runner_->PostTask([this]() { connection_.Close(); });
|
||||
sharing_service_task_runner_->SyncWithTimeout(kTaskWaitTimeout);
|
||||
|
||||
// To avoid UAF in OnIncomingTransferUpdate().
|
||||
@@ -2534,21 +2525,21 @@ TEST_F(NearbySharingServiceImplTest, IncomingConnectionEmptyIntroductionFrame) {
|
||||
SetConnectionType(ConnectionType::kWifi);
|
||||
NiceMock<MockTransferUpdateCallback> callback;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kUnsupportedAttachmentType);
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_FALSE(container.HasAttachments());
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kUnsupportedAttachmentType);
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_FALSE(container.HasAttachments());
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
}));
|
||||
|
||||
SetUpKeyVerification(/*is_incoming=*/true,
|
||||
service::proto::PairedKeyResultFrame::SUCCESS);
|
||||
@@ -2582,23 +2573,23 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
NiceMock<MockTransferUpdateCallback> callback;
|
||||
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingLocalConfirmation,
|
||||
metadata.status());
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_FALSE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_FALSE(share_target.image_url);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_EQ(share_target.device_id, kEndpointId);
|
||||
EXPECT_FALSE(share_target.full_name);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingLocalConfirmation,
|
||||
metadata.status());
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_FALSE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_FALSE(share_target.image_url);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_EQ(share_target.device_id, kEndpointId);
|
||||
EXPECT_FALSE(share_target.full_name);
|
||||
}));
|
||||
|
||||
SetUpKeyVerification(/*is_incoming=*/true,
|
||||
service::proto::PairedKeyResultFrame::SUCCESS);
|
||||
@@ -2640,17 +2631,15 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
SetUpIncomingConnection(callback);
|
||||
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kUnexpectedDisconnection);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kUnexpectedDisconnection);
|
||||
}));
|
||||
|
||||
sharing_service_task_runner_->PostTask([this]() {
|
||||
connection_.Close();
|
||||
});
|
||||
sharing_service_task_runner_->PostTask([this]() { connection_.Close(); });
|
||||
sharing_service_task_runner_->SyncWithTimeout(kTaskWaitTimeout);
|
||||
|
||||
// To avoid UAF in OnIncomingTransferUpdate().
|
||||
@@ -2827,27 +2816,27 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
NiceMock<MockTransferUpdateCallback> callback;
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke([¬ification](
|
||||
const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingLocalConfirmation,
|
||||
metadata.status());
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
.WillOnce(
|
||||
testing::Invoke([¬ification](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingLocalConfirmation,
|
||||
metadata.status());
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
|
||||
EXPECT_FALSE(metadata.token().has_value());
|
||||
notification.Notify();
|
||||
}));
|
||||
EXPECT_FALSE(metadata.token().has_value());
|
||||
notification.Notify();
|
||||
}));
|
||||
|
||||
SetUpKeyVerification(/*is_incoming=*/true, PairedKeyResultFrame::SUCCESS);
|
||||
SetUpForegroundReceiveSurface(callback);
|
||||
@@ -2924,13 +2913,13 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptance);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptance);
|
||||
}));
|
||||
|
||||
service_->Accept(
|
||||
share_target_id, [&](NearbySharingServiceImpl::StatusCodes status_code) {
|
||||
@@ -2981,18 +2970,18 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
|
||||
absl::Notification success_notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kIncompletePayloads);
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
const FileAttachment& file = container.GetFileAttachments()[0];
|
||||
EXPECT_FALSE(file.file_path());
|
||||
success_notification.Notify();
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kIncompletePayloads);
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
const FileAttachment& file = container.GetFileAttachments()[0];
|
||||
EXPECT_FALSE(file.file_path());
|
||||
success_notification.Notify();
|
||||
}));
|
||||
|
||||
sharing_service_task_runner_->PostTask([this]() {
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener> listener =
|
||||
@@ -3030,13 +3019,13 @@ TEST_F(NearbySharingServiceImplTest, AcceptValidShareTargetPayloadFailed) {
|
||||
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptance);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptance);
|
||||
}));
|
||||
|
||||
service_->Accept(
|
||||
share_target_id, [&](NearbySharingServiceImpl::StatusCodes status_code) {
|
||||
@@ -3048,17 +3037,17 @@ TEST_F(NearbySharingServiceImplTest, AcceptValidShareTargetPayloadFailed) {
|
||||
|
||||
absl::Notification failure_notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kFailed);
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
const FileAttachment& file = container.GetFileAttachments()[0];
|
||||
EXPECT_FALSE(file.file_path());
|
||||
failure_notification.Notify();
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kFailed);
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
const FileAttachment& file = container.GetFileAttachments()[0];
|
||||
EXPECT_FALSE(file.file_path());
|
||||
failure_notification.Notify();
|
||||
}));
|
||||
|
||||
sharing_service_task_runner_->PostTask([this]() {
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener> listener =
|
||||
@@ -3097,13 +3086,13 @@ TEST_F(NearbySharingServiceImplTest, AcceptValidShareTargetPayloadCancelled) {
|
||||
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptance);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingRemoteAcceptance);
|
||||
}));
|
||||
|
||||
service_->Accept(
|
||||
share_target_id, [&](NearbySharingServiceImpl::StatusCodes status_code) {
|
||||
@@ -3115,17 +3104,17 @@ TEST_F(NearbySharingServiceImplTest, AcceptValidShareTargetPayloadCancelled) {
|
||||
|
||||
absl::Notification failure_notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kCancelled);
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
const FileAttachment& file = container.GetFileAttachments()[0];
|
||||
EXPECT_FALSE(file.file_path());
|
||||
failure_notification.Notify();
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kCancelled);
|
||||
ASSERT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
const FileAttachment& file = container.GetFileAttachments()[0];
|
||||
EXPECT_FALSE(file.file_path());
|
||||
failure_notification.Notify();
|
||||
}));
|
||||
|
||||
sharing_service_task_runner_->PostTask([this]() {
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener> listener =
|
||||
@@ -3175,12 +3164,12 @@ TEST_F(NearbySharingServiceImplTest, RejectValidShareTarget) {
|
||||
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kRejected);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_TRUE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kRejected);
|
||||
}));
|
||||
|
||||
service_->Reject(
|
||||
share_target_id, [&](NearbySharingServiceImpl::StatusCodes status_code) {
|
||||
@@ -3216,25 +3205,25 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
NiceMock<MockTransferUpdateCallback> callback;
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingLocalConfirmation);
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
EXPECT_EQ(metadata.token(), kFourDigitToken);
|
||||
notification.Notify();
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(metadata.status(),
|
||||
TransferMetadata::Status::kAwaitingLocalConfirmation);
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
EXPECT_EQ(metadata.token(), kFourDigitToken);
|
||||
notification.Notify();
|
||||
}));
|
||||
|
||||
SetUpKeyVerification(/*is_incoming=*/true, PairedKeyResultFrame::UNABLE);
|
||||
SetUpForegroundReceiveSurface(callback);
|
||||
@@ -3269,26 +3258,26 @@ TEST_F(NearbySharingServiceImplTest,
|
||||
NiceMock<MockTransferUpdateCallback> callback;
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(callback, OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingLocalConfirmation,
|
||||
metadata.status());
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_FALSE(metadata.is_final_status());
|
||||
EXPECT_EQ(TransferMetadata::Status::kAwaitingLocalConfirmation,
|
||||
metadata.status());
|
||||
EXPECT_TRUE(share_target.is_incoming);
|
||||
EXPECT_TRUE(share_target.is_known);
|
||||
EXPECT_TRUE(container.HasAttachments());
|
||||
EXPECT_EQ(container.GetTextAttachments().size(), 3u);
|
||||
EXPECT_EQ(container.GetFileAttachments().size(), 1u);
|
||||
EXPECT_EQ(share_target.device_name, kDeviceName);
|
||||
EXPECT_EQ(share_target.type, kDeviceType);
|
||||
EXPECT_TRUE(share_target.device_id);
|
||||
EXPECT_NE(share_target.device_id, kEndpointId);
|
||||
EXPECT_EQ(share_target.full_name, kTestMetadataFullName);
|
||||
|
||||
EXPECT_EQ(kFourDigitToken, metadata.token());
|
||||
notification.Notify();
|
||||
}));
|
||||
EXPECT_EQ(kFourDigitToken, metadata.token());
|
||||
notification.Notify();
|
||||
}));
|
||||
|
||||
SetUpKeyVerification(/*is_incoming=*/true, PairedKeyResultFrame::UNABLE);
|
||||
|
||||
@@ -3756,9 +3745,7 @@ TEST_F(NearbySharingServiceImplTest, SendTextSuccessClosedConnection) {
|
||||
fake_nearby_connections_manager_->connection_endpoint_info(kEndpointId));
|
||||
|
||||
// Call disconnect on the connection early before the timeout has passed.
|
||||
sharing_service_task_runner_->PostTask([this]() {
|
||||
connection_.Close();
|
||||
});
|
||||
sharing_service_task_runner_->PostTask([this]() { connection_.Close(); });
|
||||
|
||||
// Expect that we haven't called disconnect again as the endpoint is already
|
||||
// disconnected.
|
||||
@@ -3856,7 +3843,7 @@ TEST_F(NearbySharingServiceImplTest, SendWifiCredentialsSuccess) {
|
||||
EXPECT_CALL(*mock_app_info_, SetActiveFlag());
|
||||
|
||||
EXPECT_EQ(SendAttachments(target_id, CreateWifiCredentialAttachments(
|
||||
"GoogleGuest", "password")),
|
||||
"GoogleGuest", "password")),
|
||||
NearbySharingServiceImpl::StatusCodes::kOk);
|
||||
EXPECT_TRUE(
|
||||
introduction_notification.WaitForNotificationWithTimeout(kWaitTimeout));
|
||||
@@ -3926,12 +3913,12 @@ TEST_F(NearbySharingServiceImplTest, CancelSenderInitiator) {
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(transfer_callback,
|
||||
OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_EQ(share_target.id, target_id);
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kCancelled);
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_EQ(share_target.id, target_id);
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kCancelled);
|
||||
}));
|
||||
EXPECT_FALSE(
|
||||
fake_nearby_connections_manager_->WasPayloadCanceled(info.payload_id));
|
||||
// The initiator of the cancellation explicitly calls Cancel().
|
||||
@@ -3969,13 +3956,13 @@ TEST_F(NearbySharingServiceImplTest, CancelSenderNoninitiator) {
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(transfer_callback,
|
||||
OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_EQ(share_target.id, target_id);
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kCancelled);
|
||||
notification.Notify();
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_EQ(share_target.id, target_id);
|
||||
EXPECT_EQ(metadata.status(), TransferMetadata::Status::kCancelled);
|
||||
notification.Notify();
|
||||
}));
|
||||
EXPECT_FALSE(
|
||||
fake_nearby_connections_manager_->WasPayloadCanceled(info.payload_id));
|
||||
// The non-initiator of the cancellation processes a cancellation frame from
|
||||
@@ -4038,13 +4025,13 @@ TEST_F(NearbySharingServiceImplTest, CancelReceiverNoninitiator) {
|
||||
absl::Notification notification;
|
||||
EXPECT_CALL(transfer_callback,
|
||||
OnTransferUpdate(testing::_, testing::_, testing::_))
|
||||
.WillOnce(testing::Invoke(
|
||||
[&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container, TransferMetadata metadata) {
|
||||
EXPECT_EQ(target_id, share_target.id);
|
||||
EXPECT_EQ(TransferMetadata::Status::kCancelled, metadata.status());
|
||||
notification.Notify();
|
||||
}));
|
||||
.WillOnce(testing::Invoke([&](const ShareTarget& share_target,
|
||||
const AttachmentContainer& container,
|
||||
TransferMetadata metadata) {
|
||||
EXPECT_EQ(target_id, share_target.id);
|
||||
EXPECT_EQ(TransferMetadata::Status::kCancelled, metadata.status());
|
||||
notification.Notify();
|
||||
}));
|
||||
EXPECT_FALSE(
|
||||
fake_nearby_connections_manager_->WasPayloadCanceled(kFilePayloadId));
|
||||
// The non-initiator of the cancellation processes a cancellation frame from
|
||||
@@ -5105,10 +5092,10 @@ TEST_F(NearbySharingServiceImplTest, RemoveIncomingPayloads) {
|
||||
UnorderedElementsAre("test1.txt", "test2.txt"));
|
||||
ShareTarget share_target;
|
||||
share_target.is_incoming = true;
|
||||
IncomingShareTargetInfo share_target_info(
|
||||
IncomingShareSession session(
|
||||
"endpoint_id", share_target,
|
||||
[](const IncomingShareTargetInfo&, const TransferMetadata&) {});
|
||||
service_->RemoveIncomingPayloads(share_target_info);
|
||||
[](const IncomingShareSession&, const TransferMetadata&) {});
|
||||
service_->RemoveIncomingPayloads(session);
|
||||
EXPECT_EQ(
|
||||
fake_nearby_connections_manager_->GetUnknownFilePathsToDeleteForTesting()
|
||||
.size(),
|
||||
|
||||
@@ -47,27 +47,27 @@ using ::nearby::sharing::service::proto::IntroductionFrame;
|
||||
using ::nearby::sharing::service::proto::ProgressUpdateFrame;
|
||||
using ::nearby::sharing::service::proto::V1Frame;
|
||||
|
||||
OutgoingShareTargetInfo::OutgoingShareTargetInfo(
|
||||
OutgoingShareSession::OutgoingShareSession(
|
||||
std::string endpoint_id, const ShareTarget& share_target,
|
||||
std::function<void(OutgoingShareTargetInfo&, const TransferMetadata&)>
|
||||
std::function<void(OutgoingShareSession&, const TransferMetadata&)>
|
||||
transfer_update_callback)
|
||||
: ShareTargetInfo(std::move(endpoint_id), share_target),
|
||||
: ShareSession(std::move(endpoint_id), share_target),
|
||||
transfer_update_callback_(std::move(transfer_update_callback)) {}
|
||||
|
||||
OutgoingShareTargetInfo::OutgoingShareTargetInfo(OutgoingShareTargetInfo&&) =
|
||||
OutgoingShareSession::OutgoingShareSession(OutgoingShareSession&&) =
|
||||
default;
|
||||
|
||||
OutgoingShareTargetInfo& OutgoingShareTargetInfo::operator=(
|
||||
OutgoingShareTargetInfo&&) = default;
|
||||
OutgoingShareSession& OutgoingShareSession::operator=(
|
||||
OutgoingShareSession&&) = default;
|
||||
|
||||
OutgoingShareTargetInfo::~OutgoingShareTargetInfo() = default;
|
||||
OutgoingShareSession::~OutgoingShareSession() = default;
|
||||
|
||||
void OutgoingShareTargetInfo::InvokeTransferUpdateCallback(
|
||||
void OutgoingShareSession::InvokeTransferUpdateCallback(
|
||||
const TransferMetadata& metadata) {
|
||||
transfer_update_callback_(*this, metadata);
|
||||
}
|
||||
|
||||
bool OutgoingShareTargetInfo::OnNewConnection(NearbyConnection* connection) {
|
||||
bool OutgoingShareSession::OnNewConnection(NearbyConnection* connection) {
|
||||
if (!connection) {
|
||||
NL_LOG(WARNING) << __func__
|
||||
<< ": Failed to initiate connection to share target "
|
||||
@@ -85,7 +85,7 @@ bool OutgoingShareTargetInfo::OnNewConnection(NearbyConnection* connection) {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector<std::filesystem::path> OutgoingShareTargetInfo::GetFilePaths()
|
||||
std::vector<std::filesystem::path> OutgoingShareSession::GetFilePaths()
|
||||
const {
|
||||
std::vector<std::filesystem::path> file_paths;
|
||||
file_paths.reserve(attachment_container().GetFileAttachments().size());
|
||||
@@ -98,7 +98,7 @@ std::vector<std::filesystem::path> OutgoingShareTargetInfo::GetFilePaths()
|
||||
return file_paths;
|
||||
}
|
||||
|
||||
void OutgoingShareTargetInfo::CreateTextPayloads() {
|
||||
void OutgoingShareSession::CreateTextPayloads() {
|
||||
const std::vector<TextAttachment> attachments =
|
||||
attachment_container().GetTextAttachments();
|
||||
if (attachments.empty()) {
|
||||
@@ -114,7 +114,7 @@ void OutgoingShareTargetInfo::CreateTextPayloads() {
|
||||
}
|
||||
}
|
||||
|
||||
void OutgoingShareTargetInfo::CreateWifiCredentialsPayloads() {
|
||||
void OutgoingShareSession::CreateWifiCredentialsPayloads() {
|
||||
const std::vector<WifiCredentialsAttachment> attachments =
|
||||
attachment_container().GetWifiCredentialsAttachments();
|
||||
if (attachments.empty()) {
|
||||
@@ -136,7 +136,7 @@ void OutgoingShareTargetInfo::CreateWifiCredentialsPayloads() {
|
||||
}
|
||||
}
|
||||
|
||||
bool OutgoingShareTargetInfo::CreateFilePayloads(
|
||||
bool OutgoingShareSession::CreateFilePayloads(
|
||||
const std::vector<NearbyFileHandler::FileInfo>& files) {
|
||||
AttachmentContainer& container = mutable_attachment_container();
|
||||
if (files.size() != container.GetFileAttachments().size()) {
|
||||
@@ -162,7 +162,7 @@ bool OutgoingShareTargetInfo::CreateFilePayloads(
|
||||
return true;
|
||||
}
|
||||
|
||||
bool OutgoingShareTargetInfo::FillIntroductionFrame(
|
||||
bool OutgoingShareSession::FillIntroductionFrame(
|
||||
IntroductionFrame* introduction) const {
|
||||
const AttachmentContainer& container = attachment_container();
|
||||
if (!container.HasAttachments()) {
|
||||
@@ -218,7 +218,7 @@ bool OutgoingShareTargetInfo::FillIntroductionFrame(
|
||||
return true;
|
||||
}
|
||||
|
||||
void OutgoingShareTargetInfo::SendAllPayloads(
|
||||
void OutgoingShareSession::SendAllPayloads(
|
||||
Context* context, NearbyConnectionsManager& connection_manager,
|
||||
std::function<void(int64_t, TransferMetadata)> update_callback) {
|
||||
set_payload_tracker(std::make_unique<PayloadTracker>(
|
||||
@@ -234,7 +234,7 @@ void OutgoingShareTargetInfo::SendAllPayloads(
|
||||
}
|
||||
}
|
||||
|
||||
void OutgoingShareTargetInfo::InitSendPayload(
|
||||
void OutgoingShareSession::InitSendPayload(
|
||||
Context* context, NearbyConnectionsManager& connection_manager,
|
||||
std::function<void(int64_t, TransferMetadata)> update_callback) {
|
||||
set_payload_tracker(std::make_unique<PayloadTracker>(
|
||||
@@ -242,7 +242,7 @@ void OutgoingShareTargetInfo::InitSendPayload(
|
||||
attachment_payload_map(), std::move(update_callback)));
|
||||
}
|
||||
|
||||
void OutgoingShareTargetInfo::SendNextPayload(
|
||||
void OutgoingShareSession::SendNextPayload(
|
||||
NearbyConnectionsManager& connection_manager) {
|
||||
std::optional<Payload> payload = ExtractNextPayload();
|
||||
if (payload.has_value()) {
|
||||
@@ -254,7 +254,7 @@ void OutgoingShareTargetInfo::SendNextPayload(
|
||||
}
|
||||
}
|
||||
|
||||
void OutgoingShareTargetInfo::WriteProgressUpdateFrame(
|
||||
void OutgoingShareSession::WriteProgressUpdateFrame(
|
||||
std::optional<bool> start_transfer, std::optional<float> progress) {
|
||||
NL_LOG(INFO) << __func__ << ": Writing progress update frame. start_transfer="
|
||||
<< (start_transfer.has_value() ? *start_transfer : false)
|
||||
@@ -274,7 +274,7 @@ void OutgoingShareTargetInfo::WriteProgressUpdateFrame(
|
||||
WriteFrame(frame);
|
||||
}
|
||||
|
||||
bool OutgoingShareTargetInfo::WriteIntroductionFrame() {
|
||||
bool OutgoingShareSession::WriteIntroductionFrame() {
|
||||
Frame frame;
|
||||
frame.set_version(Frame::V1);
|
||||
V1Frame* v1_frame = frame.mutable_v1();
|
||||
@@ -289,15 +289,15 @@ bool OutgoingShareTargetInfo::WriteIntroductionFrame() {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector<Payload> OutgoingShareTargetInfo::ExtractTextPayloads() {
|
||||
std::vector<Payload> OutgoingShareSession::ExtractTextPayloads() {
|
||||
return std::move(text_payloads_);
|
||||
}
|
||||
|
||||
std::vector<Payload> OutgoingShareTargetInfo::ExtractFilePayloads() {
|
||||
std::vector<Payload> OutgoingShareSession::ExtractFilePayloads() {
|
||||
return std::move(file_payloads_);
|
||||
}
|
||||
|
||||
std::optional<Payload> OutgoingShareTargetInfo::ExtractNextPayload() {
|
||||
std::optional<Payload> OutgoingShareSession::ExtractNextPayload() {
|
||||
if (!text_payloads_.empty()) {
|
||||
Payload payload = text_payloads_.back();
|
||||
text_payloads_.pop_back();
|
||||
|
||||
@@ -34,17 +34,17 @@
|
||||
|
||||
namespace nearby::sharing {
|
||||
|
||||
// A description of the outgoing connection to a remote device.
|
||||
class OutgoingShareTargetInfo : public ShareTargetInfo {
|
||||
// Class that represents a single outgoing share session.
|
||||
// This class is thread-compatible.
|
||||
class OutgoingShareSession : public ShareSession {
|
||||
public:
|
||||
OutgoingShareTargetInfo(std::string endpoint_id,
|
||||
const ShareTarget& share_target,
|
||||
std::function<void(OutgoingShareTargetInfo&,
|
||||
const TransferMetadata&)>
|
||||
transfer_update_callback);
|
||||
OutgoingShareTargetInfo(OutgoingShareTargetInfo&&);
|
||||
OutgoingShareTargetInfo& operator=(OutgoingShareTargetInfo&&);
|
||||
~OutgoingShareTargetInfo() override;
|
||||
OutgoingShareSession(
|
||||
std::string endpoint_id, const ShareTarget& share_target,
|
||||
std::function<void(OutgoingShareSession&, const TransferMetadata&)>
|
||||
transfer_update_callback);
|
||||
OutgoingShareSession(OutgoingShareSession&&);
|
||||
OutgoingShareSession& operator=(OutgoingShareSession&&);
|
||||
~OutgoingShareSession() override;
|
||||
|
||||
bool IsIncoming() const override { return false; }
|
||||
|
||||
@@ -90,8 +90,8 @@ class OutgoingShareTargetInfo : public ShareTargetInfo {
|
||||
// Create a payload status listener to send status change to
|
||||
// |update_callback|.
|
||||
void InitSendPayload(
|
||||
Context* context, NearbyConnectionsManager& connection_manager,
|
||||
std::function<void(int64_t, TransferMetadata)> update_callback);
|
||||
Context* context, NearbyConnectionsManager& connection_manager,
|
||||
std::function<void(int64_t, TransferMetadata)> update_callback);
|
||||
// Send the next payload to NearbyConnectionManager.
|
||||
void SendNextPayload(NearbyConnectionsManager& connection_manager);
|
||||
|
||||
@@ -104,7 +104,6 @@ class OutgoingShareTargetInfo : public ShareTargetInfo {
|
||||
void InvokeTransferUpdateCallback(const TransferMetadata& metadata) override;
|
||||
bool OnNewConnection(NearbyConnection* connection) override;
|
||||
|
||||
|
||||
private:
|
||||
std::vector<Payload> ExtractTextPayloads();
|
||||
std::vector<Payload> ExtractFilePayloads();
|
||||
@@ -119,7 +118,7 @@ class OutgoingShareTargetInfo : public ShareTargetInfo {
|
||||
std::vector<Payload> file_payloads_;
|
||||
std::vector<Payload> wifi_credentials_payloads_;
|
||||
Status connection_layer_status_;
|
||||
std::function<void(OutgoingShareTargetInfo&, const TransferMetadata&)>
|
||||
std::function<void(OutgoingShareSession&, const TransferMetadata&)>
|
||||
transfer_update_callback_;
|
||||
};
|
||||
|
||||
|
||||
@@ -47,6 +47,7 @@ using ::nearby::sharing::service::proto::IntroductionFrame;
|
||||
using ::nearby::sharing::service::proto::ProgressUpdateFrame;
|
||||
using ::nearby::sharing::service::proto::V1Frame;
|
||||
using ::nearby::sharing::service::proto::WifiCredentials;
|
||||
using ::testing::_;
|
||||
using ::testing::Eq;
|
||||
using ::testing::Invoke;
|
||||
using ::testing::IsEmpty;
|
||||
@@ -54,15 +55,14 @@ using ::testing::IsFalse;
|
||||
using ::testing::IsTrue;
|
||||
using ::testing::MockFunction;
|
||||
using ::testing::SizeIs;
|
||||
using ::testing::_;
|
||||
|
||||
constexpr absl::string_view kEndpointId = "ABCD";
|
||||
|
||||
class OutgoingShareTargetInfoTest : public ::testing::Test {
|
||||
class OutgoingShareSessionTest : public ::testing::Test {
|
||||
public:
|
||||
OutgoingShareTargetInfoTest()
|
||||
: info_(std::string(kEndpointId), share_target_,
|
||||
[](OutgoingShareTargetInfo&, const TransferMetadata&) {}),
|
||||
OutgoingShareSessionTest()
|
||||
: session_(std::string(kEndpointId), share_target_,
|
||||
[](OutgoingShareSession&, const TransferMetadata&) {}),
|
||||
text1_(nearby::sharing::service::proto::TextMetadata::URL,
|
||||
"A bit of text body", "Some text title", "text/html"),
|
||||
text2_(nearby::sharing::service::proto::TextMetadata::ADDRESS,
|
||||
@@ -77,12 +77,12 @@ class OutgoingShareTargetInfoTest : public ::testing::Test {
|
||||
std::vector<TextAttachment>{text1_, text2_},
|
||||
std::vector<FileAttachment>{file1_},
|
||||
std::vector<WifiCredentialsAttachment>{wifi1_});
|
||||
info_.SetAttachmentContainer(std::move(container));
|
||||
session_.SetAttachmentContainer(std::move(container));
|
||||
}
|
||||
|
||||
protected:
|
||||
ShareTarget share_target_;
|
||||
OutgoingShareTargetInfo info_;
|
||||
OutgoingShareSession session_;
|
||||
TextAttachment text1_;
|
||||
TextAttachment text2_;
|
||||
FileAttachment file1_;
|
||||
@@ -90,36 +90,36 @@ class OutgoingShareTargetInfoTest : public ::testing::Test {
|
||||
WifiCredentialsAttachment wifi1_;
|
||||
};
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, GetFilePaths) {
|
||||
OutgoingShareTargetInfo info(
|
||||
TEST_F(OutgoingShareSessionTest, GetFilePaths) {
|
||||
OutgoingShareSession session(
|
||||
std::string(kEndpointId), share_target_,
|
||||
[](OutgoingShareTargetInfo&, const TransferMetadata&) {});
|
||||
[](OutgoingShareSession&, const TransferMetadata&) {});
|
||||
AttachmentContainer container(std::vector<TextAttachment>{},
|
||||
std::vector<FileAttachment>{file1_, file2_},
|
||||
std::vector<WifiCredentialsAttachment>{});
|
||||
info.SetAttachmentContainer(std::move(container));
|
||||
session.SetAttachmentContainer(std::move(container));
|
||||
|
||||
auto file_paths = info.GetFilePaths();
|
||||
auto file_paths = session.GetFilePaths();
|
||||
|
||||
ASSERT_THAT(file_paths, SizeIs(2));
|
||||
EXPECT_THAT(file_paths[0], Eq(file1_.file_path()));
|
||||
EXPECT_THAT(file_paths[1], Eq(file2_.file_path()));
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateTextPayloadsWithNoTextAttachments) {
|
||||
OutgoingShareTargetInfo info(
|
||||
TEST_F(OutgoingShareSessionTest, CreateTextPayloadsWithNoTextAttachments) {
|
||||
OutgoingShareSession session(
|
||||
std::string(kEndpointId), share_target_,
|
||||
[](OutgoingShareTargetInfo&, const TransferMetadata&) {});
|
||||
info.CreateTextPayloads();
|
||||
const std::vector<Payload>& payloads = info.text_payloads();
|
||||
[](OutgoingShareSession&, const TransferMetadata&) {});
|
||||
session.CreateTextPayloads();
|
||||
const std::vector<Payload>& payloads = session.text_payloads();
|
||||
|
||||
EXPECT_THAT(payloads, IsEmpty());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateTextPayloads) {
|
||||
info_.CreateTextPayloads();
|
||||
const std::vector<Payload>& payloads = info_.text_payloads();
|
||||
auto& attachment_payload_map = info_.attachment_payload_map();
|
||||
TEST_F(OutgoingShareSessionTest, CreateTextPayloads) {
|
||||
session_.CreateTextPayloads();
|
||||
const std::vector<Payload>& payloads = session_.text_payloads();
|
||||
auto& attachment_payload_map = session_.attachment_payload_map();
|
||||
|
||||
ASSERT_THAT(payloads, SizeIs(2));
|
||||
EXPECT_THAT(payloads[0].content.type, Eq(PayloadContent::Type::kBytes));
|
||||
@@ -138,37 +138,37 @@ TEST_F(OutgoingShareTargetInfoTest, CreateTextPayloads) {
|
||||
EXPECT_THAT(attachment_payload_map.at(text2_.id()), Eq(payloads[1].id));
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateFilePayloadsWithNoFileAttachments) {
|
||||
OutgoingShareTargetInfo info(
|
||||
TEST_F(OutgoingShareSessionTest, CreateFilePayloadsWithNoFileAttachments) {
|
||||
OutgoingShareSession session(
|
||||
std::string(kEndpointId), share_target_,
|
||||
[](OutgoingShareTargetInfo&, const TransferMetadata&) {});
|
||||
[](OutgoingShareSession&, const TransferMetadata&) {});
|
||||
|
||||
EXPECT_THAT(
|
||||
info.CreateFilePayloads(std::vector<NearbyFileHandler::FileInfo>()),
|
||||
session.CreateFilePayloads(std::vector<NearbyFileHandler::FileInfo>()),
|
||||
IsTrue());
|
||||
const std::vector<Payload>& payloads = info.file_payloads();
|
||||
const std::vector<Payload>& payloads = session.file_payloads();
|
||||
|
||||
EXPECT_THAT(payloads, IsEmpty());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateFilePayloadsWithWrongFileInfo) {
|
||||
TEST_F(OutgoingShareSessionTest, CreateFilePayloadsWithWrongFileInfo) {
|
||||
EXPECT_THAT(
|
||||
info_.CreateFilePayloads(std::vector<NearbyFileHandler::FileInfo>()),
|
||||
session_.CreateFilePayloads(std::vector<NearbyFileHandler::FileInfo>()),
|
||||
IsFalse());
|
||||
const std::vector<Payload>& payloads = info_.file_payloads();
|
||||
const std::vector<Payload>& payloads = session_.file_payloads();
|
||||
|
||||
EXPECT_THAT(payloads, IsEmpty());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateFilePayloads) {
|
||||
TEST_F(OutgoingShareSessionTest, CreateFilePayloads) {
|
||||
std::vector<NearbyFileHandler::FileInfo> file_infos;
|
||||
file_infos.push_back({
|
||||
.size = 12355L,
|
||||
.file_path = file1_.file_path().value(),
|
||||
});
|
||||
info_.CreateFilePayloads(file_infos);
|
||||
const std::vector<Payload>& payloads = info_.file_payloads();
|
||||
auto& attachment_payload_map = info_.attachment_payload_map();
|
||||
session_.CreateFilePayloads(file_infos);
|
||||
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));
|
||||
@@ -182,24 +182,24 @@ TEST_F(OutgoingShareTargetInfoTest, CreateFilePayloads) {
|
||||
ASSERT_THAT(attachment_payload_map.contains(file1_.id()), IsTrue());
|
||||
EXPECT_THAT(attachment_payload_map.at(file1_.id()), Eq(payloads[0].id));
|
||||
|
||||
EXPECT_THAT(info_.attachment_container().GetFileAttachments()[0].size(),
|
||||
EXPECT_THAT(session_.attachment_container().GetFileAttachments()[0].size(),
|
||||
Eq(12355L));
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateWifiPayloadsWithNoWifiAttachments) {
|
||||
OutgoingShareTargetInfo info(
|
||||
TEST_F(OutgoingShareSessionTest, CreateWifiPayloadsWithNoWifiAttachments) {
|
||||
OutgoingShareSession session(
|
||||
std::string(kEndpointId), share_target_,
|
||||
[](OutgoingShareTargetInfo&, const TransferMetadata&) {});
|
||||
info.CreateWifiCredentialsPayloads();
|
||||
const std::vector<Payload>& payloads = info.file_payloads();
|
||||
[](OutgoingShareSession&, const TransferMetadata&) {});
|
||||
session.CreateWifiCredentialsPayloads();
|
||||
const std::vector<Payload>& payloads = session.file_payloads();
|
||||
|
||||
EXPECT_THAT(payloads, IsEmpty());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, CreateWifiCredentialsPayloads) {
|
||||
info_.CreateWifiCredentialsPayloads();
|
||||
const std::vector<Payload>& payloads = info_.wifi_credentials_payloads();
|
||||
auto& attachment_payload_map = info_.attachment_payload_map();
|
||||
TEST_F(OutgoingShareSessionTest, CreateWifiCredentialsPayloads) {
|
||||
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));
|
||||
@@ -216,23 +216,23 @@ TEST_F(OutgoingShareTargetInfoTest, CreateWifiCredentialsPayloads) {
|
||||
EXPECT_THAT(attachment_payload_map.at(wifi1_.id()), Eq(payloads[0].id));
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, WriteIntroductionFrameWithoutPayloads) {
|
||||
EXPECT_THAT(info_.WriteIntroductionFrame(), IsFalse());
|
||||
TEST_F(OutgoingShareSessionTest, WriteIntroductionFrameWithoutPayloads) {
|
||||
EXPECT_THAT(session_.WriteIntroductionFrame(), IsFalse());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, WriteIntroductionFrameSuccess) {
|
||||
TEST_F(OutgoingShareSessionTest, WriteIntroductionFrameSuccess) {
|
||||
FakeNearbyConnection connection;
|
||||
info_.OnConnected(absl::Now(), &connection);
|
||||
session_.OnConnected(absl::Now(), &connection);
|
||||
std::vector<NearbyFileHandler::FileInfo> file_infos;
|
||||
file_infos.push_back({
|
||||
.size = 12355L,
|
||||
.file_path = file1_.file_path().value(),
|
||||
});
|
||||
info_.CreateFilePayloads(file_infos);
|
||||
info_.CreateTextPayloads();
|
||||
info_.CreateWifiCredentialsPayloads();
|
||||
session_.CreateFilePayloads(file_infos);
|
||||
session_.CreateTextPayloads();
|
||||
session_.CreateWifiCredentialsPayloads();
|
||||
|
||||
EXPECT_THAT(info_.WriteIntroductionFrame(), IsTrue());
|
||||
EXPECT_THAT(session_.WriteIntroductionFrame(), IsTrue());
|
||||
|
||||
std::vector<uint8_t> frame_data = connection.GetWrittenData();
|
||||
Frame frame;
|
||||
@@ -242,7 +242,7 @@ TEST_F(OutgoingShareTargetInfoTest, WriteIntroductionFrameSuccess) {
|
||||
ASSERT_THAT(frame.v1().type(), Eq(V1Frame::INTRODUCTION));
|
||||
const IntroductionFrame& intro_frame = frame.v1().introduction();
|
||||
EXPECT_THAT(intro_frame.start_transfer(), IsTrue());
|
||||
const std::vector<Payload>& text_payloads = info_.text_payloads();
|
||||
const std::vector<Payload>& text_payloads = session_.text_payloads();
|
||||
ASSERT_THAT(intro_frame.text_metadata_size(), Eq(2));
|
||||
EXPECT_THAT(intro_frame.text_metadata(0).id(), Eq(text1_.id()));
|
||||
EXPECT_THAT(intro_frame.text_metadata(0).text_title(),
|
||||
@@ -260,7 +260,7 @@ TEST_F(OutgoingShareTargetInfoTest, WriteIntroductionFrameSuccess) {
|
||||
EXPECT_THAT(intro_frame.text_metadata(1).payload_id(),
|
||||
Eq(text_payloads[1].id));
|
||||
|
||||
const std::vector<Payload>& file_payloads = info_.file_payloads();
|
||||
const std::vector<Payload>& file_payloads = session_.file_payloads();
|
||||
ASSERT_THAT(intro_frame.file_metadata_size(), Eq(1));
|
||||
EXPECT_THAT(intro_frame.file_metadata(0).id(), Eq(file1_.id()));
|
||||
// File attachment size has been updated by CreateFilePayloads().
|
||||
@@ -271,7 +271,8 @@ TEST_F(OutgoingShareTargetInfoTest, WriteIntroductionFrameSuccess) {
|
||||
EXPECT_THAT(intro_frame.file_metadata(0).type(), Eq(file1_.type()));
|
||||
EXPECT_THAT(intro_frame.file_metadata(0).mime_type(), Eq(file1_.mime_type()));
|
||||
|
||||
const std::vector<Payload>& wifi_payloads = info_.wifi_credentials_payloads();
|
||||
const std::vector<Payload>& wifi_payloads =
|
||||
session_.wifi_credentials_payloads();
|
||||
ASSERT_THAT(intro_frame.wifi_credentials_metadata_size(), Eq(1));
|
||||
EXPECT_THAT(intro_frame.wifi_credentials_metadata(0).id(), Eq(wifi1_.id()));
|
||||
EXPECT_THAT(intro_frame.wifi_credentials_metadata(0).ssid(),
|
||||
@@ -282,15 +283,15 @@ TEST_F(OutgoingShareTargetInfoTest, WriteIntroductionFrameSuccess) {
|
||||
Eq(wifi_payloads[0].id));
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, SendAllPayloads) {
|
||||
TEST_F(OutgoingShareSessionTest, SendAllPayloads) {
|
||||
std::vector<NearbyFileHandler::FileInfo> file_infos;
|
||||
file_infos.push_back({
|
||||
.size = 12355L,
|
||||
.file_path = file1_.file_path().value(),
|
||||
});
|
||||
info_.CreateFilePayloads(file_infos);
|
||||
info_.CreateTextPayloads();
|
||||
info_.CreateWifiCredentialsPayloads();
|
||||
session_.CreateFilePayloads(file_infos);
|
||||
session_.CreateTextPayloads();
|
||||
session_.CreateWifiCredentialsPayloads();
|
||||
MockFunction<void(int64_t, TransferMetadata)> transfer_metadata_callback;
|
||||
MockFunction<void(
|
||||
std::unique_ptr<Payload>,
|
||||
@@ -302,37 +303,40 @@ TEST_F(OutgoingShareTargetInfoTest, SendAllPayloads) {
|
||||
send_payload_callback.AsStdFunction());
|
||||
EXPECT_CALL(send_payload_callback, Call(_, _))
|
||||
.WillOnce(Invoke(
|
||||
[this](std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = info_.attachment_payload_map().at(file1_.id());
|
||||
[this](
|
||||
std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = session_.attachment_payload_map().at(file1_.id());
|
||||
}))
|
||||
.WillOnce(Invoke(
|
||||
[this](std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = info_.attachment_payload_map().at(text1_.id());
|
||||
[this](
|
||||
std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = session_.attachment_payload_map().at(text1_.id());
|
||||
}))
|
||||
.WillOnce(Invoke(
|
||||
[this](std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = info_.attachment_payload_map().at(text2_.id());
|
||||
[this](
|
||||
std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = session_.attachment_payload_map().at(text2_.id());
|
||||
}));
|
||||
|
||||
info_.SendAllPayloads(&context, connections_manager,
|
||||
transfer_metadata_callback.AsStdFunction());
|
||||
session_.SendAllPayloads(&context, connections_manager,
|
||||
transfer_metadata_callback.AsStdFunction());
|
||||
|
||||
auto payload_listener = info_.payload_tracker().lock();
|
||||
auto payload_listener = session_.payload_tracker().lock();
|
||||
EXPECT_THAT(payload_listener, IsTrue());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, InitSendPayload) {
|
||||
TEST_F(OutgoingShareSessionTest, InitSendPayload) {
|
||||
std::vector<NearbyFileHandler::FileInfo> file_infos;
|
||||
file_infos.push_back({
|
||||
.size = 12355L,
|
||||
.file_path = file1_.file_path().value(),
|
||||
});
|
||||
info_.CreateFilePayloads(file_infos);
|
||||
info_.CreateTextPayloads();
|
||||
info_.CreateWifiCredentialsPayloads();
|
||||
session_.CreateFilePayloads(file_infos);
|
||||
session_.CreateTextPayloads();
|
||||
session_.CreateWifiCredentialsPayloads();
|
||||
MockFunction<void(int64_t, TransferMetadata)> transfer_metadata_callback;
|
||||
MockFunction<void(
|
||||
std::unique_ptr<Payload>,
|
||||
@@ -343,22 +347,22 @@ TEST_F(OutgoingShareTargetInfoTest, InitSendPayload) {
|
||||
connections_manager.set_send_payload_callback(
|
||||
send_payload_callback.AsStdFunction());
|
||||
|
||||
info_.InitSendPayload(&context, connections_manager,
|
||||
transfer_metadata_callback.AsStdFunction());
|
||||
session_.InitSendPayload(&context, connections_manager,
|
||||
transfer_metadata_callback.AsStdFunction());
|
||||
|
||||
auto payload_listener = info_.payload_tracker().lock();
|
||||
auto payload_listener = session_.payload_tracker().lock();
|
||||
EXPECT_THAT(payload_listener, IsTrue());
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, SendNextPayload) {
|
||||
TEST_F(OutgoingShareSessionTest, SendNextPayload) {
|
||||
std::vector<NearbyFileHandler::FileInfo> file_infos;
|
||||
file_infos.push_back({
|
||||
.size = 12355L,
|
||||
.file_path = file1_.file_path().value(),
|
||||
});
|
||||
info_.CreateFilePayloads(file_infos);
|
||||
info_.CreateTextPayloads();
|
||||
info_.CreateWifiCredentialsPayloads();
|
||||
session_.CreateFilePayloads(file_infos);
|
||||
session_.CreateTextPayloads();
|
||||
session_.CreateWifiCredentialsPayloads();
|
||||
MockFunction<void(int64_t, TransferMetadata)> transfer_metadata_callback;
|
||||
MockFunction<void(
|
||||
std::unique_ptr<Payload>,
|
||||
@@ -369,39 +373,42 @@ TEST_F(OutgoingShareTargetInfoTest, SendNextPayload) {
|
||||
connections_manager.set_send_payload_callback(
|
||||
send_payload_callback.AsStdFunction());
|
||||
|
||||
info_.InitSendPayload(&context, connections_manager,
|
||||
transfer_metadata_callback.AsStdFunction());
|
||||
session_.InitSendPayload(&context, connections_manager,
|
||||
transfer_metadata_callback.AsStdFunction());
|
||||
|
||||
EXPECT_CALL(send_payload_callback, Call(_, _))
|
||||
.WillOnce(Invoke(
|
||||
[this](std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = info_.attachment_payload_map().at(file1_.id());
|
||||
[this](
|
||||
std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = session_.attachment_payload_map().at(file1_.id());
|
||||
}));
|
||||
info_.SendNextPayload(connections_manager);
|
||||
session_.SendNextPayload(connections_manager);
|
||||
|
||||
EXPECT_CALL(send_payload_callback, Call(_, _))
|
||||
.WillOnce(Invoke(
|
||||
[this](std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = info_.attachment_payload_map().at(text1_.id());
|
||||
[this](
|
||||
std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = session_.attachment_payload_map().at(text1_.id());
|
||||
}));
|
||||
info_.SendNextPayload(connections_manager);
|
||||
session_.SendNextPayload(connections_manager);
|
||||
|
||||
EXPECT_CALL(send_payload_callback, Call(_, _))
|
||||
.WillOnce(Invoke(
|
||||
[this](std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = info_.attachment_payload_map().at(text2_.id());
|
||||
[this](
|
||||
std::unique_ptr<Payload> payload,
|
||||
std::weak_ptr<NearbyConnectionsManager::PayloadStatusListener>) {
|
||||
payload->id = session_.attachment_payload_map().at(text2_.id());
|
||||
}));
|
||||
info_.SendNextPayload(connections_manager);
|
||||
session_.SendNextPayload(connections_manager);
|
||||
}
|
||||
|
||||
TEST_F(OutgoingShareTargetInfoTest, WriteInProgressUpdateFrameSuccess) {
|
||||
TEST_F(OutgoingShareSessionTest, WriteInProgressUpdateFrameSuccess) {
|
||||
FakeNearbyConnection connection;
|
||||
info_.OnConnected(absl::Now(), &connection);
|
||||
session_.OnConnected(absl::Now(), &connection);
|
||||
|
||||
info_.WriteProgressUpdateFrame(true, 0.5);
|
||||
session_.WriteProgressUpdateFrame(true, 0.5);
|
||||
|
||||
std::vector<uint8_t> frame_data = connection.GetWrittenData();
|
||||
Frame frame;
|
||||
|
||||
+23
-23
@@ -47,35 +47,34 @@ using ::nearby::sharing::service::proto::V1Frame;
|
||||
|
||||
} // namespace
|
||||
|
||||
ShareTargetInfo::ShareTargetInfo(
|
||||
std::string endpoint_id, const ShareTarget& share_target)
|
||||
ShareSession::ShareSession(std::string endpoint_id,
|
||||
const ShareTarget& share_target)
|
||||
: endpoint_id_(std::move(endpoint_id)),
|
||||
self_share_(share_target.for_self_share),
|
||||
share_target_(share_target) {}
|
||||
|
||||
ShareTargetInfo::ShareTargetInfo(ShareTargetInfo&&) = default;
|
||||
ShareSession::ShareSession(ShareSession&&) = default;
|
||||
|
||||
ShareTargetInfo& ShareTargetInfo::operator=(ShareTargetInfo&&) = default;
|
||||
ShareSession& ShareSession::operator=(ShareSession&&) = default;
|
||||
|
||||
ShareTargetInfo::~ShareTargetInfo() = default;
|
||||
ShareSession::~ShareSession() = default;
|
||||
|
||||
void ShareTargetInfo::UpdateTransferMetadata(
|
||||
void ShareSession::UpdateTransferMetadata(
|
||||
const TransferMetadata& transfer_metadata) {
|
||||
if (got_final_status_) {
|
||||
// If we already got a final status, we can ignore any subsequent final
|
||||
// statuses caused by race conditions.
|
||||
NL_VLOG(1)
|
||||
<< __func__ << ": Transfer update decorator swallowed "
|
||||
<< "status update because a final status was already received: "
|
||||
<< share_target_.id << ": "
|
||||
<< TransferMetadata::StatusToString(transfer_metadata.status());
|
||||
NL_VLOG(1) << __func__ << ": Transfer update decorator swallowed "
|
||||
<< "status update because a final status was already received: "
|
||||
<< share_target_.id << ": "
|
||||
<< TransferMetadata::StatusToString(transfer_metadata.status());
|
||||
return;
|
||||
}
|
||||
got_final_status_ = transfer_metadata.is_final_status();
|
||||
InvokeTransferUpdateCallback(transfer_metadata);
|
||||
}
|
||||
|
||||
void ShareTargetInfo::set_disconnect_status(
|
||||
void ShareSession::set_disconnect_status(
|
||||
TransferMetadata::Status disconnect_status) {
|
||||
disconnect_status_ = disconnect_status;
|
||||
if (disconnect_status_ != TransferMetadata::Status::kUnknown &&
|
||||
@@ -85,8 +84,8 @@ void ShareTargetInfo::set_disconnect_status(
|
||||
}
|
||||
}
|
||||
|
||||
bool ShareTargetInfo::OnConnected(absl::Time connect_start_time,
|
||||
NearbyConnection* connection) {
|
||||
bool ShareSession::OnConnected(absl::Time connect_start_time,
|
||||
NearbyConnection* connection) {
|
||||
if (!OnNewConnection(connection)) {
|
||||
return false;
|
||||
}
|
||||
@@ -95,7 +94,7 @@ bool ShareTargetInfo::OnConnected(absl::Time connect_start_time,
|
||||
return true;
|
||||
}
|
||||
|
||||
void ShareTargetInfo::RunPairedKeyVerification(
|
||||
void ShareSession::RunPairedKeyVerification(
|
||||
Context* context, NearbySharingDecoder* decoder, OSType os_type,
|
||||
const PairedKeyVerificationRunner::VisibilityHistory& visibility_history,
|
||||
NearbyShareCertificateManager* certificate_manager,
|
||||
@@ -123,7 +122,7 @@ void ShareTargetInfo::RunPairedKeyVerification(
|
||||
key_verification_runner_->Run(std::move(callback));
|
||||
}
|
||||
|
||||
void ShareTargetInfo::OnDisconnect() {
|
||||
void ShareSession::OnDisconnect() {
|
||||
if (disconnect_status_ != TransferMetadata::Status::kUnknown) {
|
||||
UpdateTransferMetadata(
|
||||
TransferMetadataBuilder().set_status(disconnect_status_).build());
|
||||
@@ -131,21 +130,22 @@ void ShareTargetInfo::OnDisconnect() {
|
||||
connection_ = nullptr;
|
||||
}
|
||||
|
||||
void ShareTargetInfo::SetAttachmentPayloadId(int64_t attachment_id,
|
||||
int64_t payload_id) {
|
||||
void ShareSession::SetAttachmentPayloadId(int64_t attachment_id,
|
||||
int64_t payload_id) {
|
||||
attachment_payload_map_[attachment_id] = payload_id;
|
||||
}
|
||||
|
||||
void ShareTargetInfo::CancelPayloads(
|
||||
void ShareSession::CancelPayloads(
|
||||
NearbyConnectionsManager& connections_manager) {
|
||||
for (const auto& [attachment_id, payload_id] : attachment_payload_map_) {
|
||||
connections_manager.Cancel(payload_id);
|
||||
}
|
||||
}
|
||||
|
||||
void ShareTargetInfo::WriteFrame(const Frame& frame) {
|
||||
void ShareSession::WriteFrame(const Frame& frame) {
|
||||
if (connection_ == nullptr) {
|
||||
NL_LOG(WARNING) << __func__ << ": Failed to write response frame, due to "
|
||||
NL_LOG(WARNING) << __func__
|
||||
<< ": Failed to write response frame, due to "
|
||||
"no connection established.";
|
||||
return;
|
||||
}
|
||||
@@ -155,7 +155,7 @@ void ShareTargetInfo::WriteFrame(const Frame& frame) {
|
||||
connection_->Write(std::move(data));
|
||||
}
|
||||
|
||||
void ShareTargetInfo::WriteResponseFrame(
|
||||
void ShareSession::WriteResponseFrame(
|
||||
ConnectionResponseFrame::Status response_status) {
|
||||
Frame frame;
|
||||
frame.set_version(Frame::V1);
|
||||
@@ -166,7 +166,7 @@ void ShareTargetInfo::WriteResponseFrame(
|
||||
WriteFrame(frame);
|
||||
}
|
||||
|
||||
void ShareTargetInfo::WriteCancelFrame() {
|
||||
void ShareSession::WriteCancelFrame() {
|
||||
NL_LOG(INFO) << __func__ << ": Writing cancel frame.";
|
||||
|
||||
Frame frame;
|
||||
|
||||
@@ -42,14 +42,14 @@
|
||||
|
||||
namespace nearby::sharing {
|
||||
|
||||
// Additional information about the connection to a remote device.
|
||||
class ShareTargetInfo {
|
||||
// Class that represents a single share session.
|
||||
// This class is thread-compatible.
|
||||
class ShareSession {
|
||||
public:
|
||||
ShareTargetInfo(
|
||||
std::string endpoint_id, const ShareTarget& share_target);
|
||||
ShareTargetInfo(ShareTargetInfo&&);
|
||||
ShareTargetInfo& operator=(ShareTargetInfo&&);
|
||||
virtual ~ShareTargetInfo();
|
||||
ShareSession(std::string endpoint_id, const ShareTarget& share_target);
|
||||
ShareSession(ShareSession&&);
|
||||
ShareSession& operator=(ShareSession&&);
|
||||
virtual ~ShareSession();
|
||||
|
||||
virtual bool IsIncoming() const = 0;
|
||||
std::string endpoint_id() const { return endpoint_id_; }
|
||||
@@ -132,8 +132,7 @@ class ShareTargetInfo {
|
||||
|
||||
void CancelPayloads(NearbyConnectionsManager& connections_manager);
|
||||
|
||||
const absl::flat_hash_map<int64_t, int64_t>& attachment_payload_map()
|
||||
const {
|
||||
const absl::flat_hash_map<int64_t, int64_t>& attachment_payload_map() const {
|
||||
return attachment_payload_map_;
|
||||
}
|
||||
|
||||
|
||||
@@ -40,19 +40,17 @@ namespace nearby::sharing {
|
||||
namespace {
|
||||
|
||||
using ::location::nearby::proto::sharing::OSType;
|
||||
using ::nearby::sharing::service::proto::Frame;
|
||||
using ::nearby::sharing::service::proto::ConnectionResponseFrame;
|
||||
using ::nearby::sharing::service::proto::Frame;
|
||||
using ::nearby::sharing::service::proto::V1Frame;
|
||||
|
||||
constexpr absl::string_view kEndpointId = "12345";
|
||||
|
||||
// A test class which makes ShareTargetInfo testable since the class is
|
||||
// abstract.
|
||||
class TestShareTargetInfo : public ShareTargetInfo {
|
||||
// A test class which makes ShareSession testable since the class is abstract.
|
||||
class TestShareSession : public ShareSession {
|
||||
public:
|
||||
TestShareTargetInfo(
|
||||
std::string endpoint_id, const ShareTarget& share_target)
|
||||
: ShareTargetInfo(std::move(endpoint_id), share_target),
|
||||
TestShareSession(std::string endpoint_id, const ShareTarget& share_target)
|
||||
: ShareSession(std::move(endpoint_id), share_target),
|
||||
is_incoming_(share_target.is_incoming) {}
|
||||
|
||||
bool IsIncoming() const override { return is_incoming_; }
|
||||
@@ -68,12 +66,11 @@ class TestShareTargetInfo : public ShareTargetInfo {
|
||||
}
|
||||
|
||||
void SetAttachmentPayloadId(int64_t attachment_id, int64_t payload_id) {
|
||||
ShareTargetInfo::SetAttachmentPayloadId(attachment_id, payload_id);
|
||||
ShareSession::SetAttachmentPayloadId(attachment_id, payload_id);
|
||||
}
|
||||
|
||||
protected:
|
||||
void InvokeTransferUpdateCallback(
|
||||
const TransferMetadata& metadata) override {
|
||||
void InvokeTransferUpdateCallback(const TransferMetadata& metadata) override {
|
||||
++transfer_update_count_;
|
||||
last_transfer_metadata_ = metadata;
|
||||
}
|
||||
@@ -91,68 +88,68 @@ class TestShareTargetInfo : public ShareTargetInfo {
|
||||
bool on_new_connection_result_ = true;
|
||||
};
|
||||
|
||||
TEST(ShareTargetInfoTest, UpdateTransferMetadata) {
|
||||
TEST(ShareSessionTest, UpdateTransferMetadata) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
|
||||
info.UpdateTransferMetadata(
|
||||
session.UpdateTransferMetadata(
|
||||
TransferMetadataBuilder()
|
||||
.set_status(TransferMetadata::Status::kInProgress)
|
||||
.build());
|
||||
info.UpdateTransferMetadata(
|
||||
session.UpdateTransferMetadata(
|
||||
TransferMetadataBuilder()
|
||||
.set_status(TransferMetadata::Status::kInProgress)
|
||||
.build());
|
||||
|
||||
EXPECT_EQ(info.TransferUpdateCount(), 2);
|
||||
EXPECT_EQ(session.TransferUpdateCount(), 2);
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, UpdateTransferMetadataAfterFinalStatus) {
|
||||
TEST(ShareSessionTest, UpdateTransferMetadataAfterFinalStatus) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
|
||||
info.UpdateTransferMetadata(
|
||||
session.UpdateTransferMetadata(
|
||||
TransferMetadataBuilder()
|
||||
.set_status(TransferMetadata::Status::kComplete)
|
||||
.build());
|
||||
info.UpdateTransferMetadata(
|
||||
session.UpdateTransferMetadata(
|
||||
TransferMetadataBuilder()
|
||||
.set_status(TransferMetadata::Status::kInProgress)
|
||||
.build());
|
||||
|
||||
EXPECT_EQ(info.TransferUpdateCount(), 1);
|
||||
EXPECT_EQ(session.TransferUpdateCount(), 1);
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, SetDisconnectStatus) {
|
||||
TEST(ShareSessionTest, SetDisconnectStatus) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
|
||||
info.set_disconnect_status(TransferMetadata::Status::kCancelled);
|
||||
EXPECT_EQ(info.disconnect_status(), TransferMetadata::Status::kCancelled);
|
||||
session.set_disconnect_status(TransferMetadata::Status::kCancelled);
|
||||
EXPECT_EQ(session.disconnect_status(), TransferMetadata::Status::kCancelled);
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, OnConnectedFails) {
|
||||
TEST(ShareSessionTest, OnConnectedFails) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
info.SetOnNewConnectionResult(false);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
session.SetOnNewConnectionResult(false);
|
||||
|
||||
EXPECT_FALSE(info.OnConnected(absl::Now(), nullptr));
|
||||
EXPECT_FALSE(session.OnConnected(absl::Now(), nullptr));
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, OnConnectedSucceeds) {
|
||||
TEST(ShareSessionTest, OnConnectedSucceeds) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
FakeNearbyConnection connection;
|
||||
info.SetOnNewConnectionResult(true);
|
||||
session.SetOnNewConnectionResult(true);
|
||||
absl::Time connect_start_time = absl::Now();
|
||||
FakeContext context;
|
||||
|
||||
EXPECT_TRUE(info.OnConnected(connect_start_time, &connection));
|
||||
EXPECT_EQ(info.connection_start_time(), connect_start_time);
|
||||
EXPECT_EQ(info.connection(), &connection);
|
||||
EXPECT_TRUE(session.OnConnected(connect_start_time, &connection));
|
||||
EXPECT_EQ(session.connection_start_time(), connect_start_time);
|
||||
EXPECT_EQ(session.connection(), &connection);
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, IncomingRunPairedKeyVerificationSuccess) {
|
||||
TEST(ShareSessionTest, IncomingRunPairedKeyVerificationSuccess) {
|
||||
FakeContext context;
|
||||
NearbySharingDecoderImpl nearby_sharing_decoder;
|
||||
FakeNearbyShareCertificateManager certificate_manager;
|
||||
@@ -161,14 +158,14 @@ TEST(ShareTargetInfoTest, IncomingRunPairedKeyVerificationSuccess) {
|
||||
std::vector<uint8_t>{0, 1, 2, 3, 4, 5};
|
||||
ShareTarget share_target;
|
||||
share_target.is_incoming = true;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
info.SetOnNewConnectionResult(true);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
session.SetOnNewConnectionResult(true);
|
||||
absl::Time connect_start_time = absl::Now();
|
||||
EXPECT_TRUE(info.OnConnected(connect_start_time, &connection));
|
||||
EXPECT_TRUE(session.OnConnected(connect_start_time, &connection));
|
||||
absl::Notification notification;
|
||||
PairedKeyVerificationRunner::PairedKeyVerificationResult verification_result;
|
||||
|
||||
info.RunPairedKeyVerification(
|
||||
session.RunPairedKeyVerification(
|
||||
&context, &nearby_sharing_decoder, OSType::WINDOWS,
|
||||
{
|
||||
.visibility = proto::DeviceVisibility::DEVICE_VISIBILITY_EVERYONE,
|
||||
@@ -193,9 +190,8 @@ TEST(ShareTargetInfoTest, IncomingRunPairedKeyVerificationSuccess) {
|
||||
->mutable_paired_key_encryption()
|
||||
->set_signed_data("signed_data");
|
||||
std::string in_encryption_buffer = in_encryption_frame.SerializeAsString();
|
||||
connection.AppendReadableData(
|
||||
std::vector<uint8_t>(in_encryption_buffer.begin(),
|
||||
in_encryption_buffer.end()));
|
||||
connection.AppendReadableData(std::vector<uint8_t>(
|
||||
in_encryption_buffer.begin(), in_encryption_buffer.end()));
|
||||
// Receive PairedKeyResultFrame from remote device.
|
||||
nearby::sharing::service::proto::Frame in_result_frame;
|
||||
in_result_frame.set_version(nearby::sharing::service::proto::Frame::V1);
|
||||
@@ -220,41 +216,41 @@ TEST(ShareTargetInfoTest, IncomingRunPairedKeyVerificationSuccess) {
|
||||
PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable);
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, OnDisconnect) {
|
||||
TEST(ShareSessionTest, OnDisconnect) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
info.set_disconnect_status(TransferMetadata::Status::kCancelled);
|
||||
EXPECT_EQ(info.disconnect_status(), TransferMetadata::Status::kCancelled);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
session.set_disconnect_status(TransferMetadata::Status::kCancelled);
|
||||
EXPECT_EQ(session.disconnect_status(), TransferMetadata::Status::kCancelled);
|
||||
|
||||
info.OnDisconnect();
|
||||
session.OnDisconnect();
|
||||
|
||||
EXPECT_EQ(info.TransferUpdateCount(), 1);
|
||||
ASSERT_TRUE(info.LastTransferMetadata().has_value());
|
||||
EXPECT_EQ(info.LastTransferMetadata()->status(),
|
||||
EXPECT_EQ(session.TransferUpdateCount(), 1);
|
||||
ASSERT_TRUE(session.LastTransferMetadata().has_value());
|
||||
EXPECT_EQ(session.LastTransferMetadata()->status(),
|
||||
TransferMetadata::Status::kCancelled);
|
||||
EXPECT_TRUE(info.LastTransferMetadata()->is_final_status());
|
||||
EXPECT_TRUE(session.LastTransferMetadata()->is_final_status());
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, CancelPayloads) {
|
||||
TEST(ShareSessionTest, CancelPayloads) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
info.SetAttachmentPayloadId(1, 2);
|
||||
info.SetAttachmentPayloadId(3, 4);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
session.SetAttachmentPayloadId(1, 2);
|
||||
session.SetAttachmentPayloadId(3, 4);
|
||||
|
||||
FakeNearbyConnectionsManager connections_manager;
|
||||
info.CancelPayloads(connections_manager);
|
||||
session.CancelPayloads(connections_manager);
|
||||
|
||||
EXPECT_TRUE(connections_manager.WasPayloadCanceled(2));
|
||||
EXPECT_TRUE(connections_manager.WasPayloadCanceled(4));
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, WriteResponseFrame) {
|
||||
TEST(ShareSessionTest, WriteResponseFrame) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
FakeNearbyConnection connection;
|
||||
EXPECT_TRUE(info.OnConnected(absl::Now(), &connection));
|
||||
EXPECT_TRUE(session.OnConnected(absl::Now(), &connection));
|
||||
|
||||
info.WriteResponseFrame(ConnectionResponseFrame::REJECT);
|
||||
session.WriteResponseFrame(ConnectionResponseFrame::REJECT);
|
||||
|
||||
std::vector<uint8_t> frame_data = connection.GetWrittenData();
|
||||
Frame frame;
|
||||
@@ -265,13 +261,13 @@ TEST(ShareTargetInfoTest, WriteResponseFrame) {
|
||||
ConnectionResponseFrame::REJECT);
|
||||
}
|
||||
|
||||
TEST(ShareTargetInfoTest, WriteCancelFrame) {
|
||||
TEST(ShareSessionTest, WriteCancelFrame) {
|
||||
ShareTarget share_target;
|
||||
TestShareTargetInfo info(std::string(kEndpointId), share_target);
|
||||
TestShareSession session(std::string(kEndpointId), share_target);
|
||||
FakeNearbyConnection connection;
|
||||
EXPECT_TRUE(info.OnConnected(absl::Now(), &connection));
|
||||
EXPECT_TRUE(session.OnConnected(absl::Now(), &connection));
|
||||
|
||||
info.WriteCancelFrame();
|
||||
session.WriteCancelFrame();
|
||||
|
||||
std::vector<uint8_t> frame_data = connection.GetWrittenData();
|
||||
Frame frame;
|
||||
|
||||
Reference in New Issue
Block a user