Skip to content

GitLab

T
tangled
Commit c316b873 authored by Fabrice de Gans-Riberi's avatar Fabrice de Gans-Riberi Committed by Commit Bot
Browse files
Options

Revert "[fuchsia] Add unittests for message_port.cc, fix flow control bug." 

This reverts commit e9a3e3ec.

Reason for revert: Broke Cast Streaming in CastRunner
Bug: 1134815

Original change's description:
> [fuchsia] Add unittests for message_port.cc, fix flow control bug.
>
> Adds unit tests which verify propagation of messages and channel
> events through FIDL/Blink and Blink/FIDL adapter layers.
>
> Fixes a FIDL flow control bug and adds a regression test for it.
>
> Add test main.cc for tests which depend on an active Mojo instance.
>
> Bug: 1117518
> Bug: 1126571
> Change-Id: Ied814298b82f9e5eef1e99b158b45bfdd9d1fd8e
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2422476
> Reviewed-by: Ken Rockot <rockot@google.com>
> Reviewed-by: Sharon Yang <yangsharon@chromium.org>
> Reviewed-by: David Dorwin <ddorwin@chromium.org>
> Commit-Queue: Kevin Marshall <kmarshall@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#810858}

TBR=ddorwin@chromium.org,rockot@google.com,kmarshall@chromium.org,jochen@chromium.org,yangsharon@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 1117518
Bug: 1126571
Change-Id: I9b3079ecf0ed21cb6dfd0c467e20ed8dfbb78f50
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2447098Reviewed-by: default avatarFabrice de Gans-Riberi <fdegans@chromium.org>
Commit-Queue: Fabrice de Gans-Riberi <fdegans@chromium.org>
Cr-Commit-Position: refs/heads/master@{#813470}
parent 91fe0475
Hide whitespace changes
Inline Side-by-side
Showing with 3 additions and 280 deletions
fuchsia/base/BUILD.gn
View file @ c316b873
......@@ -123,19 +123,16 @@ test("cr_fuchsia_base_unittests") {
"legacymetrics_client_unittest.cc",
"legacymetrics_histogram_flattener_unittest.cc",
"legacymetrics_user_event_recorder_unittest.cc",
"message_port_unittest.cc",
"run_all_unittests.cc",
]
deps = [
":legacymetrics",
":message_port",
":modular",
":test_support",
"//base",
"//base:testfidl",
"//base/test:run_all_unittests",
"//base/test:test_support",
"//components/version_info",
"//mojo/core/embedder",
"//testing/gtest",
"//third_party/fuchsia-sdk/sdk/pkg/sys_cpp",
"//third_party/fuchsia-sdk/sdk/pkg/sys_inspect_cpp",
......
fuchsia/base/DEPS
View file @ c316b873
include_rules = [
"+components/version_info",
"+mojo/core/embedder",
"+mojo/public",
"+third_party/blink/public/common/messaging",
"+third_party/blink/public/mojom/messaging",
......
fuchsia/base/message_port.cc
View file @ c316b873
......@@ -190,7 +190,6 @@ class FidlMessagePortClientAdapter : public MessagePortAdapter {
return;
}
OnDeliverMessageToFidlComplete();
DeliverMessageToFidl();
}
......@@ -203,6 +202,8 @@ class FidlMessagePortClientAdapter : public MessagePortAdapter {
port_->PostMessage(
std::move(*message),
fit::bind_member(this, &FidlMessagePortClientAdapter::OnMessagePosted));
OnDeliverMessageToFidlComplete();
}
fuchsia::web::MessagePortPtr port_;
......
fuchsia/base/message_port_unittest.cc deleted 100644 → 0
View file @ 91fe0475
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <lib/fidl/cpp/binding.h>
#include "base/barrier_closure.h"
#include "base/logging.h"
#include "base/run_loop.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/task_environment.h"
#include "fuchsia/base/frame_test_util.h"
#include "fuchsia/base/mem_buffer_util.h"
#include "fuchsia/base/message_port.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cr_fuchsia {
namespace {
using WebMessage = fuchsia::web::WebMessage;
class MessagePortTest : public testing::Test {
public:
MessagePortTest() = default;
~MessagePortTest() override = default;
base::test::SingleThreadTaskEnvironment task_environment_{
base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
};
class TestFidlMessageReceiver {
public:
explicit TestFidlMessageReceiver(fuchsia::web::MessagePortPtr message_port)
: port_(std::move(message_port)) {
port_.set_error_handler([this](zx_status_t status) {
ASSERT_EQ(ZX_ERR_PEER_CLOSED, status);
std::move(on_error_).Run();
});
ReadNextMessage();
}
~TestFidlMessageReceiver() = default;
TestFidlMessageReceiver(const TestFidlMessageReceiver&) = delete;
TestFidlMessageReceiver& operator=(const TestFidlMessageReceiver&) = delete;
// Spins a runloop until the message buffer contains at least |num_messages|.
// Returns immediately if the buffer already has the requisite number.
void RunUntilMessageCountEquals(size_t num_messages) {
if (messages_.size() >= num_messages)
return;
base::RunLoop run_loop;
on_message_ = base::BarrierClosure(num_messages - messages_.size(),
run_loop.QuitClosure());
run_loop.Run();
}
// Spins a runloop until the underlying FIDL WebMessagePort is disconnected.
void RunUntilError() {
base::RunLoop run_loop;
on_error_ = run_loop.QuitClosure();
run_loop.Run();
}
std::vector<WebMessage>& messages() { return messages_; }
private:
void ReadNextMessage() {
port_->ReceiveMessage([this](WebMessage message) {
messages_.push_back(std::move(message));
on_message_.Run();
ReadNextMessage();
});
}
std::vector<WebMessage> messages_;
base::RepeatingClosure on_message_;
base::OnceClosure on_error_;
fuchsia::web::MessagePortPtr port_;
};
// Sends data through adapted MessagePort, exercising the following:
// * Sending via FIDL
// * Receiving via Blink
// * Sending via Blink
// * Receiving via FIDL
TEST_F(MessagePortTest, Roundtrip) {
fuchsia::web::MessagePortPtr fidl_port;
blink::WebMessagePort blink_port =
cr_fuchsia::BlinkMessagePortFromFidl(fidl_port.NewRequest());
TestFidlMessageReceiver receiver(
cr_fuchsia::FidlMessagePortFromBlink(std::move(blink_port)).Bind());
const std::vector<std::string> messages = {"foo", "bar", "baz"};
for (const auto& message : messages) {
WebMessage fidl_message;
fidl_message.set_data(cr_fuchsia::MemBufferFromString(message, "test"));
fidl_port->PostMessage(std::move(fidl_message),
[](fuchsia::web::MessagePort_PostMessage_Result) {});
}
receiver.RunUntilMessageCountEquals(messages.size());
for (size_t i = 0; i < messages.size(); ++i) {
std::string data;
ASSERT_TRUE(
cr_fuchsia::StringFromMemBuffer(receiver.messages()[i].data(), &data));
EXPECT_EQ(data, messages[i]);
}
fidl_port.Unbind();
receiver.RunUntilError();
}
// Transfers message ports over message channels through multiple layers of
// recursion.
TEST_F(MessagePortTest, RoundtripWithPorts) {
constexpr int kNestingLevel = 5;
fuchsia::web::MessagePortPtr fidl_port;
for (int i = 0; i < kNestingLevel; ++i) {
blink::WebMessagePort blink_port =
cr_fuchsia::BlinkMessagePortFromFidl(fidl_port.NewRequest());
TestFidlMessageReceiver receiver(
cr_fuchsia::FidlMessagePortFromBlink(std::move(blink_port)).Bind());
fuchsia::web::MessagePortPtr transferred_port;
constexpr char kData[] = "lore";
fidl_port->PostMessage(cr_fuchsia::CreateWebMessageWithMessagePortRequest(
transferred_port.NewRequest(),
cr_fuchsia::MemBufferFromString(kData, "test")),
[](fuchsia::web::MessagePort_PostMessage_Result) {});
receiver.RunUntilMessageCountEquals(1);
std::string data;
ASSERT_TRUE(
cr_fuchsia::StringFromMemBuffer(receiver.messages()[0].data(), &data));
EXPECT_EQ(data, kData);
// Drop the previous MessagePort, verify that the channel error was
// propagated correctly, and select the newest MessagePort
// for the next roundtrip iteration.
fidl_port = std::move(transferred_port);
receiver.RunUntilError();
}
}
class NullReceiver : public blink::WebMessagePort::MessageReceiver {
bool OnMessage(blink::WebMessagePort::Message message) override {
NOTREACHED();
return false;
}
void OnPipeError() override { NOTREACHED(); }
};
// Counts PostMessage calls from a FIDL client, with pause and resume methods to
// manage channel backpressure.
class TestFidlMessagePortCountingSink : public fuchsia::web::MessagePort {
public:
TestFidlMessagePortCountingSink() : binding_(this) {}
~TestFidlMessagePortCountingSink() override = default;
TestFidlMessagePortCountingSink(const TestFidlMessagePortCountingSink&) =
delete;
TestFidlMessagePortCountingSink& operator=(
const TestFidlMessagePortCountingSink&) = delete;
fidl::InterfaceHandle<fuchsia::web::MessagePort> GetClient() {
return binding_.NewBinding();
}
// Stops acknowledging calls to PostMessage until ResumeAck() is invoked.
void PauseAck() { pause_ack_ = true; }
// Resumes acknowledging PostMessage calls.
void ResumeAck() {
DCHECK(pause_ack_);
pause_ack_ = false;
if (post_message_callback_)
AckPostMessage();
}
// Spins a runloop until the message buffer contains at least |num_messages|.
// Returns immediately if the buffer already has that number of messages.
void RunUntilMessageCountEquals(size_t num_messages) {
if (message_count_ >= num_messages)
return;
base::RunLoop run_loop;
on_message_ = base::BarrierClosure(num_messages - message_count_,
run_loop.QuitClosure());
run_loop.Run();
}
size_t message_count() const { return message_count_; }
private:
void AckPostMessage() {
ASSERT_TRUE(post_message_callback_);
DCHECK(!pause_ack_);
fuchsia::web::MessagePort_PostMessage_Result result;
result.set_response(fuchsia::web::MessagePort_PostMessage_Response());
(*post_message_callback_)(std::move(result));
post_message_callback_ = {};
}
void PostMessage(fuchsia::web::WebMessage message,
PostMessageCallback callback) override {
++message_count_;
post_message_callback_ = std::move(callback);
if (!pause_ack_)
AckPostMessage();
if (on_message_)
on_message_->Run();
}
void ReceiveMessage(ReceiveMessageCallback callback) override {}
size_t message_count_ = 0;
bool pause_ack_ = false;
base::Optional<base::RepeatingClosure> on_message_;
fidl::Binding<fuchsia::web::MessagePort> binding_;
base::Optional<PostMessageCallback> post_message_callback_;
};
// Sends a burst of five messages over Blink (which doesn't use a flow
// controlled interface), and verify that the adapter respects FIDL flow
// control.
TEST_F(MessagePortTest, BlinkMessageBurstForClientAdapter) {
TestFidlMessagePortCountingSink fidl_sink;
blink::WebMessagePort blink_port =
cr_fuchsia::BlinkMessagePortFromFidl(fidl_sink.GetClient());
fidl_sink.PauseAck();
NullReceiver blink_receiver;
blink_port.SetReceiver(&blink_receiver, base::ThreadTaskRunnerHandle::Get());
for (int i = 0; i < 5; ++i) {
blink::WebMessagePort::Message blink_message(base::UTF8ToUTF16("test"));
ASSERT_TRUE(blink_port.PostMessage(std::move(blink_message)));
}
base::RunLoop().RunUntilIdle();
EXPECT_EQ(fidl_sink.message_count(), 1u);
fidl_sink.ResumeAck();
fidl_sink.RunUntilMessageCountEquals(5u);
}
} // namespace
} // namespace cr_fuchsia
fuchsia/base/run_all_unittests.cc deleted 100644 → 0
View file @ 91fe0475
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/bind.h"
#include "base/test/launcher/unit_test_launcher.h"
#include "base/test/test_suite.h"
#include "mojo/core/embedder/embedder.h"
int main(int argc, char** argv) {
base::TestSuite test_suite(argc, argv);
// Initialize Mojo so that Blink Mojo types can be used.
// TODO(crbug.com/1126571): Remove after MessagePort abstraction lands.
mojo::core::Init();
return base::LaunchUnitTests(
argc, argv,
base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment