Name: Protocol Buffers
Short Name: protobuf
URL: https://github.com/google/protobuf
License: BSD
License File: LICENSE
Version: 3.20.3
CPEPrefix: cpe:/a:google:protobuf:3.20.3
Revision: fe271ab76f2ad2b2b28c10443865d2af21e27e0e
Security Critical: yes

Steps used to create the current version:
1. Pull the release from https://github.com/google/protobuf/releases (Source
   code zip)
2. Add build files (BUILD.gn, proto_library.gni).

   As needed, update defines required by protobuf on various platforms, warnings
   generated by compilers, and new dependencies introduced.
3. Add DEPS, DIR_METADATA, and OWNERS.
4. Add mirclient.cc and mirclient.map.
5. Add gen_extra_chromium_files.py and gen_chromium_file_lists.py.
6. Apply patches in patches/ (see the description below):

   $ for patch in patches/*; do patch -s -p1 < $patch; done

   For future releases, it will be worth looking into which patches still need
   to be applied. In case of conflict, update those patches accordingly and save
   them back in place (i.e. in patches directory).
7. Generate descriptor_pb2.py using the script "gen_extra_chromium_files.py" in
   the same directory as this file.
8. Generate proto_sources.gni using the script "gen_chromium_file_lists.py".
9. Update this file (README.chromium).

Note about libmirclient:

On Ubuntu, Chromium has an indirect dependency on the system
libprotobuf-lite through libmirclient (through GTK).  The symbols in
the system library conflict with Chromium's libprotobuf-lite used on
component builds.

mirclient.* are added to stub out libmirclient.so.9 to prevent loading
the system libprotobuf-lite.  Chromium's replacement libmirclient will
get loaded, but its symbols will never be used directly or indirectly.

Note about vpython:

Some Python scripts end up mixing protoc output from this copy of protobuf with
the google.protobuf module from vpython's protobuf. If Python scripts break due
to the vpython copy of protobuf, you may need to update the version in
//.vpython3. See https://crbug.com/1320047.

Description of the patches:

- 0004-fix-shared-library-exports.patch

  This patch allows exporting protobuf symbols in Linux .so libraries, so
  that protobuf can be built as a component (see http://crrev.com/179806).

- 0008-uninline_get_empty_string.patch
- 0010-uninline-generated-code.patch

  These patches uninline some functions, resulting in a significant reduction
  (somewhere between 500 KB and 1 MB) of binary size.

- 0021-Fix-protobuf-s-library-.gitinore-file.patch

  Un-ignores python/google/protobuf/descriptor_pb2.py and
  python/google/protobuf/compiler/plugin_pb2.py

- 0022-Allow-deprecated-fields.patch

  Allows deprecated fields to be used without extra C++ compiler warnings.

- 0026-remove-sprintf.patch

  Imports
  https://github.com/protocolbuffers/protobuf/commit/c0fc2e881bc36aafb0bf539bf41889611370f60c
  to remove use of sprintf.

- 0027-no-noreturn.patch

  Removes an instance of [[noreturn]]. The attribute is correct, but the way
  protobuf's GOOGLE_LOG(FATAL) is defined, the compiler can't see this and it
  trips -Winvalid-noreturn. See https://github.com/protocolbuffers/protobuf/issues/9817

- 0028-export-internal-metadata.patch

  Adds a missing PROTOBUF_EXPORT. See cl/443188236

- 0029-make-initializers-optimizable.patch

  Makes the InitProtobufDefaults() static initializer optimizable by Clang when
  built with libc++. It patches out the OnShutdownDestroyString call, which we
  do not need, and removes the thread-safe initialization. Thread safety is only
  needed if a static initializer spawns a thread which then calls
  InitProtobufDefaults() without synchronizing with the start of main().
  (Anything which happens after main() starts can rely on the initializer
  running.)

- 0030-workaround-window-constinit.patch

  Disables PROTOBUF_CONSTINIT in generated code in Windows shared library
  builds. Protobuf's default instances take pointers to a dllimport variable,
  fixed_address_empty_string. This is not constinit on Windows. This is a bug in
  protobuf as the default instance was intended to be constant-initialized. But
  the components build in Chromium is a developer configuration, so we tolerate
  an initializer as long as the build works, until protobuf has a proper fix.

  See https://github.com/protocolbuffers/protobuf/issues/10159.

- 0031-workaround-cfi-unrelated-cast.patch

  A workaround for Clang's Control Flow Integrity check for casting pointers to
  memory that his not yet initialized to be of that type for empty arrays, does
  not work, and still fails. This patch removes the workaround and instead
  disables cfi-unrelated-cast for the affected methods and simplifies them.

  See https://github.com/protocolbuffers/protobuf/issues/10186.
  See https://bugs.chromium.org/p/chromium/issues/detail?id=1294200#c26.

- 0032-cxx20.patch

  Fixes necessary to build in --std=c++20 mode.

  Imports https://critique.corp.google.com/cl/451177197 (a portion of
  https://github.com/protocolbuffers/protobuf/commit/6dd8af4ecfa7987bddb309862932886b84f1e4ef
  ).

- 0033-no-enum-conversion-warn.patch

  Avoid hitting the clang error -Wenum-constexpr-conversion by specifying width
  of the enum.

  Imports https://critique.corp.google.com/cl/466986872.

- 0034-change-macro-to-avoid-pedantic-warning.patch

  Avoid hitting -Wextra-semi.

  Imports (rebased):
  https://github.com/protocolbuffers/protobuf/commit/def602dd07b7eae1cac6823705975317b5607fc3

Protocol Buffers - Google's data interchange format
===================================================

Copyright 2008 Google Inc.

https://developers.google.com/protocol-buffers/

Overview
--------

Protocol Buffers (a.k.a., protobuf) are Google's language-neutral,
platform-neutral, extensible mechanism for serializing structured data. You
can find [protobuf's documentation on the Google Developers site](https://developers.google.com/protocol-buffers/).

This README file contains protobuf installation instructions. To install
protobuf, you need to install the protocol compiler (used to compile .proto
files) and the protobuf runtime for your chosen programming language.

Protocol Compiler Installation
------------------------------

The protocol compiler is written in C++. If you are using C++, please follow
the [C++ Installation Instructions](src/README.md) to install protoc along
with the C++ runtime.

For non-C++ users, the simplest way to install the protocol compiler is to
download a pre-built binary from our release page:

  [https://github.com/protocolbuffers/protobuf/releases](https://github.com/protocolbuffers/protobuf/releases)

In the downloads section of each release, you can find pre-built binaries in
zip packages: protoc-$VERSION-$PLATFORM.zip. It contains the protoc binary
as well as a set of standard .proto files distributed along with protobuf.

If you are looking for an old version that is not available in the release
page, check out the maven repo here:

  [https://repo1.maven.org/maven2/com/google/protobuf/protoc/](https://repo1.maven.org/maven2/com/google/protobuf/protoc/)

These pre-built binaries are only provided for released versions. If you want
to use the github master version at HEAD, or you need to modify protobuf code,
or you are using C++, it's recommended to build your own protoc binary from
source.

If you would like to build protoc binary from source, see the [C++ Installation
Instructions](src/README.md).

Protobuf Runtime Installation
-----------------------------

Protobuf supports several different programming languages. For each programming
language, you can find instructions in the corresponding source directory about
how to install protobuf runtime for that specific language:

| Language                             | Source                                                      |
|--------------------------------------|-------------------------------------------------------------|
| C++ (include C++ runtime and protoc) | [src](src)                                                  |
| Java                                 | [java](java)                                                |
| Python                               | [python](python)                                            |
| Objective-C                          | [objectivec](objectivec)                                    |
| C#                                   | [csharp](csharp)                                            |
| JavaScript                           | [js](js)                                                    |
| Ruby                                 | [ruby](ruby)                                                |
| Go                                   | [protocolbuffers/protobuf-go](https://github.com/protocolbuffers/protobuf-go)|
| PHP                                  | [php](php)                                                  |
| Dart                                 | [dart-lang/protobuf](https://github.com/dart-lang/protobuf) |

Quick Start
-----------

The best way to learn how to use protobuf is to follow the tutorials in our
developer guide:

https://developers.google.com/protocol-buffers/docs/tutorials

If you want to learn from code examples, take a look at the examples in the
[examples](examples) directory.

Documentation
-------------

The complete documentation for Protocol Buffers is available via the
web at:

https://developers.google.com/protocol-buffers/