| // Copyright 2015 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 "services/ws/public/cpp/property_type_converters.h" |
| |
| #include <stdint.h> |
| |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/unguessable_token.h" |
| #include "mojo/public/cpp/base/unguessable_token_mojom_traits.h" |
| #include "mojo/public/mojom/base/unguessable_token.mojom.h" |
| #include "skia/public/interfaces/bitmap.mojom.h" |
| #include "skia/public/interfaces/bitmap_skbitmap_struct_traits.h" |
| #include "third_party/skia/include/core/SkBitmap.h" |
| #include "ui/gfx/geometry/rect.h" |
| #include "ui/gfx/geometry/size.h" |
| |
| namespace mojo { |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, gfx::Rect>::Convert( |
| const gfx::Rect& input) { |
| std::vector<uint8_t> vec(16); |
| vec[0] = (input.x() >> 24) & 0xFF; |
| vec[1] = (input.x() >> 16) & 0xFF; |
| vec[2] = (input.x() >> 8) & 0xFF; |
| vec[3] = input.x() & 0xFF; |
| vec[4] = (input.y() >> 24) & 0xFF; |
| vec[5] = (input.y() >> 16) & 0xFF; |
| vec[6] = (input.y() >> 8) & 0xFF; |
| vec[7] = input.y() & 0xFF; |
| vec[8] = (input.width() >> 24) & 0xFF; |
| vec[9] = (input.width() >> 16) & 0xFF; |
| vec[10] = (input.width() >> 8) & 0xFF; |
| vec[11] = input.width() & 0xFF; |
| vec[12] = (input.height() >> 24) & 0xFF; |
| vec[13] = (input.height() >> 16) & 0xFF; |
| vec[14] = (input.height() >> 8) & 0xFF; |
| vec[15] = input.height() & 0xFF; |
| return vec; |
| } |
| |
| // static |
| gfx::Rect TypeConverter<gfx::Rect, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| if (input.size() != 16) |
| return gfx::Rect(); |
| |
| return gfx::Rect( |
| input[0] << 24 | input[1] << 16 | input[2] << 8 | input[3], |
| input[4] << 24 | input[5] << 16 | input[6] << 8 | input[7], |
| input[8] << 24 | input[9] << 16 | input[10] << 8 | input[11], |
| input[12] << 24 | input[13] << 16 | input[14] << 8 | input[15]); |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, gfx::Size>::Convert( |
| const gfx::Size& input) { |
| std::vector<uint8_t> vec(8); |
| vec[0] = (input.width() >> 24) & 0xFF; |
| vec[1] = (input.width() >> 16) & 0xFF; |
| vec[2] = (input.width() >> 8) & 0xFF; |
| vec[3] = input.width() & 0xFF; |
| vec[4] = (input.height() >> 24) & 0xFF; |
| vec[5] = (input.height() >> 16) & 0xFF; |
| vec[6] = (input.height() >> 8) & 0xFF; |
| vec[7] = input.height() & 0xFF; |
| return vec; |
| } |
| |
| // static |
| gfx::Size TypeConverter<gfx::Size, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| if (input.size() != 8) |
| return gfx::Size(); |
| |
| return gfx::Size(input[0] << 24 | input[1] << 16 | input[2] << 8 | input[3], |
| input[4] << 24 | input[5] << 16 | input[6] << 8 | input[7]); |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, int32_t>::Convert( |
| const int32_t& input) { |
| std::vector<uint8_t> vec(4); |
| vec[0] = (input >> 24) & 0xFF; |
| vec[1] = (input >> 16) & 0xFF; |
| vec[2] = (input >> 8) & 0xFF; |
| vec[3] = input & 0xFF; |
| return vec; |
| } |
| |
| // static |
| int32_t TypeConverter<int32_t, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| if (input.size() != 4) |
| return 0; |
| |
| return input[0] << 24 | input[1] << 16 | input[2] << 8 | input[3]; |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, int64_t>::Convert( |
| const int64_t& input) { |
| std::vector<uint8_t> vec(8); |
| vec[0] = (input >> 56) & 0xFF; |
| vec[1] = (input >> 48) & 0xFF; |
| vec[2] = (input >> 40) & 0xFF; |
| vec[3] = (input >> 32) & 0xFF; |
| vec[4] = (input >> 24) & 0xFF; |
| vec[5] = (input >> 16) & 0xFF; |
| vec[6] = (input >> 8) & 0xFF; |
| vec[7] = input & 0xFF; |
| return vec; |
| } |
| |
| // static |
| int64_t TypeConverter<int64_t, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| if (input.size() != 8) |
| return 0; |
| |
| return static_cast<int64_t>(input[0]) << 56 | |
| static_cast<int64_t>(input[1]) << 48 | |
| static_cast<int64_t>(input[2]) << 40 | |
| static_cast<int64_t>(input[3]) << 32 | |
| static_cast<int64_t>(input[4]) << 24 | |
| static_cast<int64_t>(input[5]) << 16 | |
| static_cast<int64_t>(input[6]) << 8 | static_cast<int64_t>(input[7]); |
| } |
| |
| // static |
| std::vector<uint8_t> |
| TypeConverter<std::vector<uint8_t>, base::string16>::Convert( |
| const base::string16& input) { |
| return ConvertTo<std::vector<uint8_t>>(base::UTF16ToUTF8(input)); |
| } |
| |
| // static |
| base::string16 TypeConverter<base::string16, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| return base::UTF8ToUTF16(ConvertTo<std::string>(input)); |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, std::string>::Convert( |
| const std::string& input) { |
| return std::vector<uint8_t>(input.begin(), input.end()); |
| } |
| |
| // static |
| std::string TypeConverter<std::string, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| return std::string(input.begin(), input.end()); |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, SkBitmap>::Convert( |
| const SkBitmap& input) { |
| return skia::mojom::InlineBitmap::Serialize(&input); |
| } |
| |
| // static |
| SkBitmap TypeConverter<SkBitmap, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| SkBitmap output; |
| return skia::mojom::InlineBitmap::Deserialize(input, &output) ? output |
| : SkBitmap(); |
| } |
| |
| // static |
| std::vector<uint8_t> |
| TypeConverter<std::vector<uint8_t>, base::UnguessableToken>::Convert( |
| const base::UnguessableToken& input) { |
| if (input.is_empty()) |
| return std::vector<uint8_t>(); |
| |
| return mojo_base::mojom::UnguessableToken::Serialize(&input); |
| } |
| |
| // static |
| base::UnguessableToken |
| TypeConverter<base::UnguessableToken, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| if (input.empty()) |
| return base::UnguessableToken(); |
| |
| base::UnguessableToken output; |
| return mojo_base::mojom::UnguessableToken::Deserialize(input, &output) |
| ? output |
| : base::UnguessableToken(); |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, bool>::Convert( |
| bool input) { |
| std::vector<uint8_t> vec(1); |
| vec[0] = input ? 1 : 0; |
| return vec; |
| } |
| |
| // static |
| bool TypeConverter<bool, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| // Empty vectors are interpreted as false. |
| return !input.empty() && (input[0] == 1); |
| } |
| |
| // static |
| std::vector<uint8_t> TypeConverter<std::vector<uint8_t>, uint64_t>::Convert( |
| uint64_t input) { |
| return TypeConverter<std::vector<uint8_t>, int64_t>::Convert( |
| static_cast<int64_t>(input)); |
| } |
| |
| // static |
| ws::Id TypeConverter<uint64_t, std::vector<uint8_t>>::Convert( |
| const std::vector<uint8_t>& input) { |
| return static_cast<uint64_t>( |
| TypeConverter<int64_t, std::vector<uint8_t>>::Convert(input)); |
| } |
| |
| } // namespace mojo |