diff --git a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/BUILD.gn b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/BUILD.gn index 6c297103d43..719029b6325 100644 --- a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/BUILD.gn +++ b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/BUILD.gn @@ -20,24 +20,6 @@ source_set("client_wrapper") { [ "//flutter/shell/platform/common/cpp:relative_flutter_library_headers" ] } -# Temporary test for the legacy EncodableValue implementation. Remove once the -# legacy version is removed. -source_set("client_wrapper_legacy_encodable_value") { - sources = core_cpp_client_wrapper_sources - public = core_cpp_client_wrapper_includes + - core_cpp_client_wrapper_internal_headers - - deps = [ "//flutter/shell/platform/common/cpp:common_cpp_library_headers" ] - - configs += - [ "//flutter/shell/platform/common/cpp:desktop_library_implementation" ] - - defines = [ "USE_LEGACY_ENCODABLE_VALUE" ] - - public_configs = - [ "//flutter/shell/platform/common/cpp:relative_flutter_library_headers" ] -} - source_set("client_wrapper_library_stubs") { sources = [ "testing/stub_flutter_api.cc", @@ -75,9 +57,6 @@ executable("client_wrapper_unittests") { ":client_wrapper", ":client_wrapper_fixtures", ":client_wrapper_library_stubs", - - # Build the legacy version as well as a sanity check. - ":client_wrapper_unittests_legacy_encodable_value", "//flutter/testing", # TODO(chunhtai): Consider refactoring flutter_root/testing so that there's a testing @@ -88,31 +67,3 @@ executable("client_wrapper_unittests") { defines = [ "FLUTTER_DESKTOP_LIBRARY" ] } - -# Ensures that the legacy EncodableValue codepath still compiles. -executable("client_wrapper_unittests_legacy_encodable_value") { - testonly = true - - sources = [ - "encodable_value_unittests.cc", - "standard_message_codec_unittests.cc", - "testing/test_codec_extensions.h", - ] - - deps = [ - ":client_wrapper_fixtures", - ":client_wrapper_legacy_encodable_value", - ":client_wrapper_library_stubs", - "//flutter/testing", - - # TODO(chunhtai): Consider refactoring flutter_root/testing so that there's a testing - # target that doesn't require a Dart runtime to be linked in. - # https://github.com/flutter/flutter/issues/41414. - "//third_party/dart/runtime:libdart_jit", - ] - - defines = [ - "FLUTTER_DESKTOP_LIBRARY", - "USE_LEGACY_ENCODABLE_VALUE", - ] -} diff --git a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/encodable_value_unittests.cc b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/encodable_value_unittests.cc index 5fa72a4ac2d..45a62183127 100644 --- a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/encodable_value_unittests.cc +++ b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/encodable_value_unittests.cc @@ -16,8 +16,6 @@ TEST(EncodableValueTest, Null) { value.IsNull(); } -#ifndef USE_LEGACY_ENCODABLE_VALUE - TEST(EncodableValueTest, Bool) { EncodableValue value(false); @@ -283,6 +281,4 @@ TEST(EncodableValueTest, DeepCopy) { EXPECT_EQ(std::get(innermost_map[EncodableValue("a")]), "b"); } -#endif // !LEGACY_ENCODABLE_VALUE - } // namespace flutter diff --git a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/include/flutter/encodable_value.h b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/include/flutter/encodable_value.h index 0b021292d0f..d2803613eda 100644 --- a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/include/flutter/encodable_value.h +++ b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/include/flutter/encodable_value.h @@ -35,13 +35,6 @@ namespace flutter { static_assert(sizeof(double) == 8, "EncodableValue requires a 64-bit double"); -// Defining USE_LEGACY_ENCODABLE_VALUE will use the original EncodableValue -// implementation. This is a temporary measure to minimize the impact of the -// breaking change; it will be removed in the future. If you set this, you -// should update your code as soon as possible to use the new std::variant -// version, or it will break when the legacy version is removed. -#ifndef USE_LEGACY_ENCODABLE_VALUE - // A container for arbitrary types in EncodableValue. // // This is used in conjunction with StandardCodecExtension to allow using other @@ -204,558 +197,6 @@ class EncodableValue : public internal::EncodableValueVariant { } }; -#else - -class EncodableValue; -// Convenience type aliases for list and map EncodableValue types. -using EncodableList = std::vector; -using EncodableMap = std::map; - -// An object that can contain any value or collection type supported by -// Flutter's standard method codec. -// -// For details, see: -// https://api.flutter.dev/flutter/services/StandardMessageCodec-class.html -// -// As an example, the following Dart structure: -// { -// 'flag': true, -// 'name': 'Thing', -// 'values': [1, 2.0, 4], -// } -// would correspond to: -// EncodableValue(EncodableMap{ -// {EncodableValue("flag"), EncodableValue(true)}, -// {EncodableValue("name"), EncodableValue("Thing")}, -// {EncodableValue("values"), EncodableValue(EncodableList{ -// EncodableValue(1), -// EncodableValue(2.0), -// EncodableValue(4), -// })}, -// }) -class EncodableValue { - public: - // Possible types for an EncodableValue to reperesent. - enum class Type { - kNull, // A null value. - kBool, // A boolean value. - kInt, // A 32-bit integer. - kLong, // A 64-bit integer. - kDouble, // A 64-bit floating point number. - kString, // A string. - kByteList, // A list of bytes. - kIntList, // A list of 32-bit integers. - kLongList, // A list of 64-bit integers. - kDoubleList, // A list of 64-bit floating point numbers. - kList, // A list of EncodableValues. - kMap, // A mapping from EncodableValues to EncodableValues. - }; - - // Creates an instance representing a null value. - EncodableValue() {} - - // Creates an instance representing a bool value. - explicit EncodableValue(bool value) : bool_(value), type_(Type::kBool) {} - - // Creates an instance representing a 32-bit integer value. - explicit EncodableValue(int32_t value) : int_(value), type_(Type::kInt) {} - - // Creates an instance representing a 64-bit integer value. - explicit EncodableValue(int64_t value) : long_(value), type_(Type::kLong) {} - - // Creates an instance representing a 64-bit floating point value. - explicit EncodableValue(double value) - : double_(value), type_(Type::kDouble) {} - - // Creates an instance representing a string value. - explicit EncodableValue(const char* value) - : string_(new std::string(value)), type_(Type::kString) {} - - // Creates an instance representing a string value. - explicit EncodableValue(const std::string& value) - : string_(new std::string(value)), type_(Type::kString) {} - - // Creates an instance representing a list of bytes. - explicit EncodableValue(std::vector list) - : byte_list_(new std::vector(std::move(list))), - type_(Type::kByteList) {} - - // Creates an instance representing a list of 32-bit integers. - explicit EncodableValue(std::vector list) - : int_list_(new std::vector(std::move(list))), - type_(Type::kIntList) {} - - // Creates an instance representing a list of 64-bit integers. - explicit EncodableValue(std::vector list) - : long_list_(new std::vector(std::move(list))), - type_(Type::kLongList) {} - - // Creates an instance representing a list of 64-bit floating point values. - explicit EncodableValue(std::vector list) - : double_list_(new std::vector(std::move(list))), - type_(Type::kDoubleList) {} - - // Creates an instance representing a list of EncodableValues. - explicit EncodableValue(EncodableList list) - : list_(new EncodableList(std::move(list))), type_(Type::kList) {} - - // Creates an instance representing a map from EncodableValues to - // EncodableValues. - explicit EncodableValue(EncodableMap map) - : map_(new EncodableMap(std::move(map))), type_(Type::kMap) {} - - // Convience constructor for creating default value of the given type. - // - // Collections types will be empty, numeric types will be 0, strings will be - // empty, and booleans will be false. For non-collection types, prefer using - // the value-based constructor with an explicit value for clarity. - explicit EncodableValue(Type type) : type_(type) { - switch (type_) { - case Type::kNull: - break; - case Type::kBool: - bool_ = false; - break; - case Type::kInt: - int_ = 0; - break; - case Type::kLong: - long_ = 0; - break; - case Type::kDouble: - double_ = 0.0; - break; - case Type::kString: - string_ = new std::string(); - break; - case Type::kByteList: - byte_list_ = new std::vector(); - break; - case Type::kIntList: - int_list_ = new std::vector(); - break; - case Type::kLongList: - long_list_ = new std::vector(); - break; - case Type::kDoubleList: - double_list_ = new std::vector(); - break; - case Type::kList: - list_ = new std::vector(); - break; - case Type::kMap: - map_ = new std::map(); - break; - } - } - - ~EncodableValue() { DestroyValue(); } - - EncodableValue(const EncodableValue& other) { - DestroyValue(); - - type_ = other.type_; - switch (type_) { - case Type::kNull: - break; - case Type::kBool: - bool_ = other.bool_; - break; - case Type::kInt: - int_ = other.int_; - break; - case Type::kLong: - long_ = other.long_; - break; - case Type::kDouble: - double_ = other.double_; - break; - case Type::kString: - string_ = new std::string(*other.string_); - break; - case Type::kByteList: - byte_list_ = new std::vector(*other.byte_list_); - break; - case Type::kIntList: - int_list_ = new std::vector(*other.int_list_); - break; - case Type::kLongList: - long_list_ = new std::vector(*other.long_list_); - break; - case Type::kDoubleList: - double_list_ = new std::vector(*other.double_list_); - break; - case Type::kList: - list_ = new std::vector(*other.list_); - break; - case Type::kMap: - map_ = new std::map(*other.map_); - break; - } - } - - EncodableValue(EncodableValue&& other) noexcept { *this = std::move(other); } - - EncodableValue& operator=(const EncodableValue& other) { - if (&other == this) { - return *this; - } - using std::swap; - EncodableValue temp(other); - swap(*this, temp); - return *this; - } - - EncodableValue& operator=(EncodableValue&& other) noexcept { - if (&other == this) { - return *this; - } - DestroyValue(); - - type_ = other.type_; - switch (type_) { - case Type::kNull: - break; - case Type::kBool: - bool_ = other.bool_; - break; - case Type::kInt: - int_ = other.int_; - break; - case Type::kLong: - long_ = other.long_; - break; - case Type::kDouble: - double_ = other.double_; - break; - case Type::kString: - string_ = other.string_; - break; - case Type::kByteList: - byte_list_ = other.byte_list_; - break; - case Type::kIntList: - int_list_ = other.int_list_; - break; - case Type::kLongList: - long_list_ = other.long_list_; - break; - case Type::kDoubleList: - double_list_ = other.double_list_; - break; - case Type::kList: - list_ = other.list_; - break; - case Type::kMap: - map_ = other.map_; - break; - } - // Ensure that destruction doesn't run on the source of the move. - other.type_ = Type::kNull; - return *this; - } - - // Allow assigning any value type that can be used for a constructor. - template - EncodableValue& operator=(const T& value) { - *this = EncodableValue(value); - return *this; - } - - // This operator exists only to provide a stable ordering for use as a - // std::map key. It does not attempt to provide useful ordering semantics. - // Notably: - // - Numeric values are not guaranteed any ordering across numeric types. - // E.g., 1 as a Long may sort after 100 as an Int. - // - Collection types use pointer equality, rather than value. This means that - // multiple collections with the same values will end up as separate keys - // in a map (consistent with default Dart Map behavior). - bool operator<(const EncodableValue& other) const { - if (type_ != other.type_) { - return type_ < other.type_; - } - switch (type_) { - case Type::kNull: - return false; - case Type::kBool: - return bool_ < other.bool_; - case Type::kInt: - return int_ < other.int_; - case Type::kLong: - return long_ < other.long_; - case Type::kDouble: - return double_ < other.double_; - case Type::kString: - return *string_ < *other.string_; - case Type::kByteList: - case Type::kIntList: - case Type::kLongList: - case Type::kDoubleList: - case Type::kList: - case Type::kMap: - return this < &other; - } - assert(false); - return false; - } - - // Returns the bool value this object represents. - // - // It is a programming error to call this unless IsBool() is true. - bool BoolValue() const { - assert(IsBool()); - return bool_; - } - - // Returns the 32-bit integer value this object represents. - // - // It is a programming error to call this unless IsInt() is true. - int32_t IntValue() const { - assert(IsInt()); - return int_; - } - - // Returns the 64-bit integer value this object represents. - // - // It is a programming error to call this unless IsLong() or IsInt() is true. - // - // Note that calling this function on an Int value is the only case where - // a *Value() function can be called without the corresponding Is*() being - // true. This is to simplify handling objects received from Flutter where the - // values may be larger than 32-bit, since they have the same type on the Dart - // side, but will be either 32-bit or 64-bit here depending on the value. - int64_t LongValue() const { - assert(IsLong() || IsInt()); - if (IsLong()) { - return long_; - } - return int_; - } - - // Returns the double value this object represents. - // - // It is a programming error to call this unless IsDouble() is true. - double DoubleValue() const { - assert(IsDouble()); - return double_; - } - - // Returns the string value this object represents. - // - // It is a programming error to call this unless IsString() is true. - const std::string& StringValue() const { - assert(IsString()); - return *string_; - } - - // Returns the byte list this object represents. - // - // It is a programming error to call this unless IsByteList() is true. - const std::vector& ByteListValue() const { - assert(IsByteList()); - return *byte_list_; - } - - // Returns the byte list this object represents. - // - // It is a programming error to call this unless IsByteList() is true. - std::vector& ByteListValue() { - assert(IsByteList()); - return *byte_list_; - } - - // Returns the 32-bit integer list this object represents. - // - // It is a programming error to call this unless IsIntList() is true. - const std::vector& IntListValue() const { - assert(IsIntList()); - return *int_list_; - } - - // Returns the 32-bit integer list this object represents. - // - // It is a programming error to call this unless IsIntList() is true. - std::vector& IntListValue() { - assert(IsIntList()); - return *int_list_; - } - - // Returns the 64-bit integer list this object represents. - // - // It is a programming error to call this unless IsLongList() is true. - const std::vector& LongListValue() const { - assert(IsLongList()); - return *long_list_; - } - - // Returns the 64-bit integer list this object represents. - // - // It is a programming error to call this unless IsLongList() is true. - std::vector& LongListValue() { - assert(IsLongList()); - return *long_list_; - } - - // Returns the double list this object represents. - // - // It is a programming error to call this unless IsDoubleList() is true. - const std::vector& DoubleListValue() const { - assert(IsDoubleList()); - return *double_list_; - } - - // Returns the double list this object represents. - // - // It is a programming error to call this unless IsDoubleList() is true. - std::vector& DoubleListValue() { - assert(IsDoubleList()); - return *double_list_; - } - - // Returns the list of EncodableValues this object represents. - // - // It is a programming error to call this unless IsList() is true. - const EncodableList& ListValue() const { - assert(IsList()); - return *list_; - } - - // Returns the list of EncodableValues this object represents. - // - // It is a programming error to call this unless IsList() is true. - EncodableList& ListValue() { - assert(IsList()); - return *list_; - } - - // Returns the map of EncodableValue : EncodableValue pairs this object - // represent. - // - // It is a programming error to call this unless IsMap() is true. - const EncodableMap& MapValue() const { - assert(IsMap()); - return *map_; - } - - // Returns the map of EncodableValue : EncodableValue pairs this object - // represent. - // - // It is a programming error to call this unless IsMap() is true. - EncodableMap& MapValue() { - assert(IsMap()); - return *map_; - } - - // Returns true if this represents a null value. - bool IsNull() const { return type_ == Type::kNull; } - - // Returns true if this represents a bool value. - bool IsBool() const { return type_ == Type::kBool; } - - // Returns true if this represents a 32-bit integer value. - bool IsInt() const { return type_ == Type::kInt; } - - // Returns true if this represents a 64-bit integer value. - bool IsLong() const { return type_ == Type::kLong; } - - // Returns true if this represents a double value. - bool IsDouble() const { return type_ == Type::kDouble; } - - // Returns true if this represents a string value. - bool IsString() const { return type_ == Type::kString; } - - // Returns true if this represents a list of bytes. - bool IsByteList() const { return type_ == Type::kByteList; } - - // Returns true if this represents a list of 32-bit integers. - bool IsIntList() const { return type_ == Type::kIntList; } - - // Returns true if this represents a list of 64-bit integers. - bool IsLongList() const { return type_ == Type::kLongList; } - - // Returns true if this represents a list of doubles. - bool IsDoubleList() const { return type_ == Type::kDoubleList; } - - // Returns true if this represents a list of EncodableValues. - bool IsList() const { return type_ == Type::kList; } - - // Returns true if this represents a map of EncodableValue : EncodableValue - // pairs. - bool IsMap() const { return type_ == Type::kMap; } - - // Returns the type this value represents. - // - // This is primarily intended for use with switch(); for individual checks, - // prefer an Is*() call. - Type type() const { return type_; } - - private: - // Performs any cleanup necessary for the active union value. This must be - // called before assigning a new value, and on object destruction. - // - // After calling this, type_ will alway be kNull. - void DestroyValue() { - switch (type_) { - case Type::kNull: - case Type::kBool: - case Type::kInt: - case Type::kLong: - case Type::kDouble: - break; - case Type::kString: - delete string_; - break; - case Type::kByteList: - delete byte_list_; - break; - case Type::kIntList: - delete int_list_; - break; - case Type::kLongList: - delete long_list_; - break; - case Type::kDoubleList: - delete double_list_; - break; - case Type::kList: - delete list_; - break; - case Type::kMap: - delete map_; - break; - } - - type_ = Type::kNull; - } - - // The anonymous union that stores the represented value. Accessing any of - // these entries other than the one that corresponds to the current value of - // |type_| has undefined behavior. - // - // Pointers are used for the non-POD types to avoid making the overall size - // of the union unnecessarily large. - // - // TODO: Replace this with std::variant once c++17 is available. - union { - bool bool_; - int32_t int_; - int64_t long_; - double double_; - std::string* string_; - std::vector* byte_list_; - std::vector* int_list_; - std::vector* long_list_; - std::vector* double_list_; - std::vector* list_; - std::map* map_; - }; - - // The currently active union entry. - Type type_ = Type::kNull; -}; - -#endif - } // namespace flutter #endif // FLUTTER_SHELL_PLATFORM_COMMON_CPP_CLIENT_WRAPPER_INCLUDE_FLUTTER_ENCODABLE_VALUE_H_ diff --git a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_codec.cc b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_codec.cc index bb6309844fb..db2f2422e51 100644 --- a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_codec.cc +++ b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_codec.cc @@ -46,34 +46,6 @@ enum class EncodedType { // Returns the encoded type that should be written when serializing |value|. EncodedType EncodedTypeForValue(const EncodableValue& value) { -#ifdef USE_LEGACY_ENCODABLE_VALUE - switch (value.type()) { - case EncodableValue::Type::kNull: - return EncodedType::kNull; - case EncodableValue::Type::kBool: - return value.BoolValue() ? EncodedType::kTrue : EncodedType::kFalse; - case EncodableValue::Type::kInt: - return EncodedType::kInt32; - case EncodableValue::Type::kLong: - return EncodedType::kInt64; - case EncodableValue::Type::kDouble: - return EncodedType::kFloat64; - case EncodableValue::Type::kString: - return EncodedType::kString; - case EncodableValue::Type::kByteList: - return EncodedType::kUInt8List; - case EncodableValue::Type::kIntList: - return EncodedType::kInt32List; - case EncodableValue::Type::kLongList: - return EncodedType::kInt64List; - case EncodableValue::Type::kDoubleList: - return EncodedType::kFloat64List; - case EncodableValue::Type::kList: - return EncodedType::kList; - case EncodableValue::Type::kMap: - return EncodedType::kMap; - } -#else switch (value.index()) { case 0: return EncodedType::kNull; @@ -100,7 +72,6 @@ EncodedType EncodedTypeForValue(const EncodableValue& value) { case 11: return EncodedType::kMap; } -#endif assert(false); return EncodedType::kNull; } @@ -125,59 +96,6 @@ EncodableValue StandardCodecSerializer::ReadValue( void StandardCodecSerializer::WriteValue(const EncodableValue& value, ByteStreamWriter* stream) const { stream->WriteByte(static_cast(EncodedTypeForValue(value))); -#ifdef USE_LEGACY_ENCODABLE_VALUE - switch (value.type()) { - case EncodableValue::Type::kNull: - case EncodableValue::Type::kBool: - // Null and bool are encoded directly in the type. - break; - case EncodableValue::Type::kInt: - stream->WriteInt32(value.IntValue()); - break; - case EncodableValue::Type::kLong: - stream->WriteInt64(value.LongValue()); - break; - case EncodableValue::Type::kDouble: - stream->WriteAlignment(8); - stream->WriteDouble(value.DoubleValue()); - break; - case EncodableValue::Type::kString: { - const auto& string_value = value.StringValue(); - size_t size = string_value.size(); - WriteSize(size, stream); - if (size > 0) { - stream->WriteBytes( - reinterpret_cast(string_value.data()), size); - } - break; - } - case EncodableValue::Type::kByteList: - WriteVector(value.ByteListValue(), stream); - break; - case EncodableValue::Type::kIntList: - WriteVector(value.IntListValue(), stream); - break; - case EncodableValue::Type::kLongList: - WriteVector(value.LongListValue(), stream); - break; - case EncodableValue::Type::kDoubleList: - WriteVector(value.DoubleListValue(), stream); - break; - case EncodableValue::Type::kList: - WriteSize(value.ListValue().size(), stream); - for (const auto& item : value.ListValue()) { - WriteValue(item, stream); - } - break; - case EncodableValue::Type::kMap: - WriteSize(value.MapValue().size(), stream); - for (const auto& pair : value.MapValue()) { - WriteValue(pair.first, stream); - WriteValue(pair.second, stream); - } - break; - } -#else // TODO: Consider replacing this this with a std::visitor. switch (value.index()) { case 0: @@ -239,7 +157,6 @@ void StandardCodecSerializer::WriteValue(const EncodableValue& value, << "Custom types require codec extensions." << std::endl; break; } -#endif } EncodableValue StandardCodecSerializer::ReadValueOfType( @@ -437,18 +354,6 @@ std::unique_ptr> StandardMethodCodec::DecodeMethodCallInternal(const uint8_t* message, size_t message_size) const { ByteBufferStreamReader stream(message, message_size); -#ifdef USE_LEGACY_ENCODABLE_VALUE - EncodableValue method_name = serializer_->ReadValue(&stream); - if (!method_name.IsString()) { - std::cerr << "Invalid method call; method name is not a string." - << std::endl; - return nullptr; - } - auto arguments = - std::make_unique(serializer_->ReadValue(&stream)); - return std::make_unique>(method_name.StringValue(), - std::move(arguments)); -#else EncodableValue method_name_value = serializer_->ReadValue(&stream); const auto* method_name = std::get_if(&method_name_value); if (!method_name) { @@ -460,7 +365,6 @@ StandardMethodCodec::DecodeMethodCallInternal(const uint8_t* message, std::make_unique(serializer_->ReadValue(&stream)); return std::make_unique>(*method_name, std::move(arguments)); -#endif } std::unique_ptr> @@ -533,15 +437,6 @@ bool StandardMethodCodec::DecodeAndProcessResponseEnvelopeInternal( EncodableValue code = serializer_->ReadValue(&stream); EncodableValue message = serializer_->ReadValue(&stream); EncodableValue details = serializer_->ReadValue(&stream); -#ifdef USE_LEGACY_ENCODABLE_VALUE - if (details.IsNull()) { - result->Error(code.StringValue(), - message.IsNull() ? "" : message.StringValue()); - } else { - result->Error(code.StringValue(), - message.IsNull() ? "" : message.StringValue(), details); - } -#else const std::string& message_string = message.IsNull() ? "" : std::get(message); if (details.IsNull()) { @@ -549,7 +444,6 @@ bool StandardMethodCodec::DecodeAndProcessResponseEnvelopeInternal( } else { result->Error(std::get(code), message_string, details); } -#endif return true; } default: diff --git a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_message_codec_unittests.cc b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_message_codec_unittests.cc index e5cfc61251b..1ddb9e7e286 100644 --- a/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_message_codec_unittests.cc +++ b/engine/src/flutter/shell/platform/common/cpp/client_wrapper/standard_message_codec_unittests.cc @@ -7,11 +7,8 @@ #include #include -#include "gtest/gtest.h" - -#ifndef USE_LEGACY_ENCODABLE_VALUE #include "flutter/shell/platform/common/cpp/client_wrapper/testing/test_codec_extensions.h" -#endif +#include "gtest/gtest.h" namespace flutter { @@ -34,21 +31,11 @@ static void CheckEncodeDecode( EXPECT_EQ(*encoded, expected_encoding); auto decoded = codec.DecodeMessage(*encoded); -#ifdef USE_LEGACY_ENCODABLE_VALUE - // Full equality isn't implemented for the legacy path; just do a sanity test - // of basic types. - if (value.IsNull() || value.IsBool() || value.IsInt() || value.IsLong() || - value.IsDouble() || value.IsString()) { - EXPECT_FALSE(value < *decoded); - EXPECT_FALSE(*decoded < value); - } -#else if (custom_comparator) { EXPECT_TRUE(custom_comparator(value, *decoded)); } else { EXPECT_EQ(value, *decoded); } -#endif } // Validates round-trip encoding and decoding of |value|, and checks that the @@ -60,11 +47,7 @@ static void CheckEncodeDecodeWithEncodePrefix( const EncodableValue& value, const std::vector& expected_encoding_prefix, size_t expected_encoding_length) { -#ifdef USE_LEGACY_ENCODABLE_VALUE - EXPECT_TRUE(value.IsMap()); -#else EXPECT_TRUE(std::holds_alternative(value)); -#endif const StandardMessageCodec& codec = StandardMessageCodec::GetInstance(); auto encoded = codec.EncodeMessage(value); ASSERT_TRUE(encoded); @@ -77,11 +60,7 @@ static void CheckEncodeDecodeWithEncodePrefix( auto decoded = codec.DecodeMessage(*encoded); -#ifdef USE_LEGACY_ENCODABLE_VALUE - EXPECT_NE(decoded, nullptr); -#else EXPECT_EQ(value, *decoded); -#endif } TEST(StandardMessageCodec, CanEncodeAndDecodeNull) { @@ -205,8 +184,6 @@ TEST(StandardMessageCodec, CanEncodeAndDecodeFloat64Array) { CheckEncodeDecode(value, bytes); } -#ifndef USE_LEGACY_ENCODABLE_VALUE - TEST(StandardMessageCodec, CanEncodeAndDecodeSimpleCustomType) { std::vector bytes = {0x80, 0x09, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00}; @@ -242,6 +219,4 @@ TEST(StandardMessageCodec, CanEncodeAndDecodeVariableLengthCustomType) { some_data_comparator); } -#endif // !USE_LEGACY_ENCODABLE_VALUE - } // namespace flutter