commit	03df0d5f5136ca402380da06d3f9f9bcf2aabd96	[log] [tgz]
author	mark a. foltz <mfoltz@chromium.org>	Wed May 15 17:56:36 2024
committer	Openscreen LUCI CQ <openscreen-scoped@luci-project-accounts.iam.gserviceaccount.com>	Thu May 16 17:08:13 2024
tree	6cd20df4ba49153f8393ac9c57e92e2069c0c4f9
parent	6a097c705fc4bb3d79bcb4a45f71b7a198ba40f8 [diff]

Roll third_party/quiche/src/ acbdda4e4..64cdc52a2 (55 commits)

https://quiche.googlesource.com/quiche.git/+log/acbdda4e4aa4..64cdc52a285d

$ git log acbdda4e4..64cdc52a2 --date=short --no-merges --format='%ad %ae %s'
2024-05-14 quiche-dev Remove unnecessary break statement in WebTransportWriteBlockedList::IsStreamBlocked()
2024-05-14 birenroy Fixes accounting for DataFrameSources in NgHttp2Adapter.
2024-05-14 quiche-dev Resolve the following 4 technical debt issues: (readability-avoid-const-params-in-decls)
2024-05-14 vasilvv Implement QuicWriteBlockedList version that supports WebTransport priority scheme.
2024-05-14 wub Set `gfe2_restart_flag_quic_opport_bundle_qpack_decoder_data5` to false on chromium.
2024-05-14 birenroy Associates all test cases that involve a `DataFrameSource` with a test fixture.
2024-05-14 quiche-dev Enabling rolled out flags.
2024-05-13 rch Deprecate --gfe2_reloadable_flag_quic_enable_http3_metadata_decoding
2024-05-13 birenroy Migrates the remaining tests from TestDataFrameSource -> VisitorDataSource.
2024-05-13 birenroy Migrates oghttp2_adapter_test.cc from TestDataFrameSource to VisitorDataSource.
2024-05-13 birenroy Migrates nghttp2_adapter_test.cc from TestDataFrameSource to VisitorDataSource.
2024-05-13 birenroy Adds VisitorDataSource, which invokes visitor methods to set up and send DATA frames.
2024-05-13 wub No public description
2024-05-13 bnc Add some QuicIntervalDeque::Iterator methods.
2024-05-13 birenroy Migrates two tests to TestVisitor.
2024-05-10 birenroy Renames DataSavingVisitor to TestVisitor.
2024-05-09 birenroy Plumbs the `end_stream` bit through the oghttp2 session interface.
2024-05-06 quiche-dev Fix QUICHE_DCHECK_LE compile error
2024-05-06 birenroy Exports QUIC flag `quic_stop_reading_also_stops_header_decompression` to QUICHE.
2024-05-06 bnc Make QuicIntervalDeque::Iterator random access.
2024-05-06 danzh No public description
2024-05-06 quiche-dev Fix QuicIntervalDeque::Iterator::operator+=
2024-05-05 vasilvv Move blackhole detector and ping alarms into QuicConnectionAlarms.
2024-05-04 wub Fix a bug in `QuicSession::GetFlowControlSendWindowSize` when the input stream id is a qpack stream id.
2024-05-02 birenroy Updates Http2Adapter::SubmitRequest/SubmitResponse to include an `end_stream` parameter.
2024-04-30 vasilvv Move QuicIdleNetworkDetector alarm into QuicConnectionAlarms.
2024-04-29 danzh Fix test expectations differ when --gfe2_reloadable_flag_quic_stop_reading_also_stops_header_decompression is true.
2024-04-29 wub GFE custom prober: Allow HTTP/3 probe to set `SSL_OP_NO_TICKET` despite it being a no-op in TLS1.3.
2024-04-26 wub Remove QuicConnectionProcessPacketContext.
2024-04-26 wub Replace `kAckDecimationDelay` by protocol flag `quic_ack_decimation_delay` so we can experiment with different values.
2024-04-26 quiche-dev No public description
2024-04-26 vasilvv Move all of the individual alarms in QuicConnection into a new holder class.
2024-04-25 birenroy Exposes an accessor within QuicStream for the number of bytes consumed on a stream.
2024-04-25 ericorth Delete partial message buffering from QBONE
2024-04-24 wub Add `ssl_config` to `QuicCryptoClientConfig` and `QuicCryptoServerConfig`.
2024-04-24 birenroy A tiny fix to help chunked_buffer_test.cc build in the Envoy OSS project.
2024-04-24 quiche-dev Wire up xRPC client to talk to Phosphor
2024-04-23 rch Factor the QuicDispatcher's blocked writer list into a stand-alone QuicBlockedWriterList.
2024-04-23 birenroy Reserves the right amount of space for a set in BalsaHeaders::RemoveAllOfHeaderInList().
2024-04-23 quiche-dev Remove HTTP specific logic from BlindSignAuth and dependencies
2024-04-23 birenroy Replaces a std::string used to buffer data in OgHttp2Session with a new buffer type.
2024-04-23 vasilvv Implement MoqtOutgoingQueue.
2024-04-22 wub Silence quic_bug_10752_22 if write_length is reduced to zero due to flow control.
2024-04-22 quiche-dev Enabling rolled out flags.
2024-04-22 quiche-dev Remove duplicate method of BlindSignAuth::GetTokens now that the Chrome is setting service_type.
2024-04-22 dschinazi Add support for nested proxying in MASQUE client code
2024-04-19 birenroy Adds a ChunkedBuffer class to contain HTTP/2 wire format bytes.
2024-04-19 dschinazi Introduce kDefaultMaxPacketSizeForTunnels
2024-04-18 quiche-dev Add ServiceType enum parameter to BlindSignAuth::GetTokens. This will allow GetInitialDataRequest and AuthAndSignRequest requests to be reused for different services.
2024-04-12 birenroy OgHttp2Session refactoring.
2024-04-11 quiche-dev Expose QUIC application/transport errors send/received on wire
2024-04-11 birenroy Removes the old SpdySerializedFrame constructor and the ReleaseBuffer() method.
2024-04-10 birenroy Adds a new SpdySerializedFrame constructor that makes memory ownership clear.
2024-04-10 birenroy Removes an unnecessary method from spdy::SpdySerializedFrame.
2024-04-10 birenroy Replaces one instance of std::list with QuicheCircularDeque in OgHttp2Session.

Created with:
roll-dep third_party/quiche/src
R=muyao@google.com

Change-Id: I3ce62592719fdc5ee27787573c1fcbde0b323b00
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/5542198
Reviewed-by: Muyao Xu <muyaoxu@google.com>
Commit-Queue: Mark Foltz <mfoltz@chromium.org>

2 files changed

tree: 6cd20df4ba49153f8393ac9c57e92e2069c0c4f9

README.md

Open Screen Library

The Open Screen Library implements the Open Screen Protocol, Multicast DNS and DNS-SD, and the Chromecast protocols (discovery, application control, and media streaming).

The library consists of feature modules that share a common platform API that must be implemented and linked by the embedding application.

The major feature modules in the library can be used independently and have their own documentation:

Getting the code

Installing depot_tools

Library dependencies are managed using gclient, from the depot_tools repo.

To get gclient, run the following command in your terminal:

    git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git

Then add the depot_tools folder to your PATH environment variable.

Note that openscreen does not use other features of depot_tools like repo or drover. However, some git-cl functions do work, like git cl try, git cl format, git cl lint, and git cl upload.

Checking out code

From the parent directory of where you want the openscreen checkout (e.g., ~/my_project_dir), configure gclient and check out openscreen with the following commands:

    cd ~/my_project_dir
    gclient config https://chromium.googlesource.com/openscreen
    gclient sync

The first gclient command will create a default .gclient file in ~/my_project_dir that describes how to pull down the openscreen repository. The second command creates an openscreen/ subdirectory, downloads the source code, all third-party dependencies, and the toolchain needed to build things; and at their appropriate revisions.

Syncing your local checkout

To update your local checkout from the openscreen reference repository, just run

   cd ~/my_project_dir/openscreen
   git pull
   gclient sync

This will rebase any local commits on the remote top-of-tree, and update any dependencies that have changed.

Build setup

The following are the main tools are required for development/builds.

Installed by gclient automatically
- Build file generator: gn (installed into buildtools/)
- Code formatter: clang-format (installed into buildtools/)
- Builder: ninja
- Compiler/Linker: clang
Installed by you
- JSON validator: yajsv
- libstdc++
- gcc
- XCode

yajsv installation

Install go from https://golang.org or your Linux package manager.
go install github.com/neilpa/yajsv@latest

libstdc++ (Linux only)

Ensure that libstdc++ 8 is installed, as clang depends on the system instance of it. On Debian flavors, you can run:

   sudo apt-get install libstdc++-8-dev libstdc++6-8-dbg

XCode (Mac only)

You can install the XCode command-line tools only or the full version of XCode.

xcode-select --install

gcc (optional, Linux only)

Setting the gn argument is_clang=false on Linux enables building using gcc instead.

  mkdir out/debug-gcc
  gn gen out/debug-gcc --args="is_clang=false"

Note that g++ version 9 or newer must be installed. On Debian flavors you can run:

  sudo apt-get install gcc-9

Debug build

Setting the gn argument is_debug=true enables debug build.

  gn gen out/debug --args="is_debug=true"

gn configuration

Running gn args opens an editor that allows to create a list of arguments passed to every invocation of gn gen. gn args --list will list all of the possible arguments you can set.

  gn args out/debug

Building targets

We use the Open Screen Protocol demo application as an example, however, the instructions are essentially the same for all executable targets.

  mkdir out/debug
  gn gen out/debug             # Creates the build directory and necessary ninja files
  ninja -C out/debug osp_demo  # Builds the executable with ninja
  ./out/debug/osp_demo         # Runs the executable

The -C argument to ninja works just like it does for GNU Make: it specifies the working directory for the build. So the same could be done as follows:

  ./gn gen out/debug
  cd out/debug
  ninja osp_demo
  ./osp_demo

After editing a file, only ninja needs to be rerun, not gn. If you have edited a BUILD.gn file, ninja will re-run gn for you.

We recommend using autoninja instead of ninja, which takes the same command-line arguments but automatically parallelizes the build for your system, depending on number of processor cores, amount of RAM, etc.

Also, while specifying build targets is possible while using ninja, typically for development it is sufficient to just build everything, especially since the Open Screen repository is still quite small. That makes the invocation to the build system simplify to:

  autoninja -C out/debug

For details on running osp_demo, see its README.md.

Building all targets

Running ninja -C out/debug gn_all will build all non-test targets in the repository.

gn ls --type=executable out/debug will list all of the executable targets that can be built.

If you want to customize the build further, you can run gn args out/debug to pull up an editor for build flags. gn args --list out/debug prints all of the build flags available.

Building and running unit tests

  ninja -C out/debug openscreen_unittests
  ./out/debug/openscreen_unittests

Contributing changes

Open Screen library code should follow the Open Screen Library Style Guide.

This library uses Chromium Gerrit for patch management and code review (for better or worse). You will need to register for an account at chromium-review.googlesource.com to upload patches for review.

The following sections contain some tips about dealing with Gerrit for code reviews, specifically when pushing patches for review, getting patches reviewed, and committing patches.

Uploading a patch for review

The git cl tool handles details of interacting with Gerrit (the Chromium code review tool) and is recommended for pushing patches for review. Once you have committed changes locally, simply run:

  git cl format
  git cl upload

The first command will will auto-format the code changes using clang-format. Then, the second command runs the PRESUBMIT.py script to check style and, if it passes, a newcode review will be posted on chromium-review.googlesource.com.

If you make additional commits to your local branch, then running git cl upload again in the same branch will merge those commits into the ongoing review as a new patchset.

It's simplest to create a local git branch for each patch you want reviewed separately. git cl keeps track of review status separately for each local branch.

Addressing merge conflicts

If conflicting commits have been landed in the repository for a patch in review, Gerrit will flag the patch as having a merge conflict. In that case, use the instructions above to rebase your commits on top-of-tree and upload a new patchset with the merge conflicts resolved.

Tryjobs

Clicking the CQ DRY RUN button (also, confusingly, labeled COMMIT QUEUE +1) will run the current patchset through all LUCI builders and report the results. It is always a good idea get a green tryjob on a patch before sending it for review to avoid extra back-and-forth.

You can also run git cl try from the commandline to submit a tryjob.

Code reviews

Send your patch to one or more committers in the COMMITTERS file for code review. All patches must receive at least one LGTM by a committer before it can be submitted.

Submitting patches

After your patch has received one or more LGTM commit it by clicking the SUBMIT button (or, confusingly, COMMIT QUEUE +2) in Gerrit. This will run your patch through the builders again before committing to the main openscreen repository.