These were discovered by running integration tests using the new `Serializer`.
Also, port all the missing tests from `FSTSerializerBetaTests.mm` (that I could find).
* Add support for building Objective-C protos in CMake
* Add support for building FSTLocalSerializer to CMake
* Build ProtoSizer with CMake
* Build memory components with CMake
* Build LevelDB components with CMake
* Clean up references to Firestore.pbrpc
We're no longer using Objective-C gRPC services and this is no longer generated.
* Remove no longer existing entries from xcgmock
* Use python executable directly
* python2 is not guaranteed to exist
* scripts aren't directly executable on Windows
* Add Firestore v1 protos
* Point cmake at Firestore v1 protos
* Regenerate protobuf-related sources
* Make local protos refer to v1 protos
* fixup! Regenerate protobuf-related sources
* Remove v1beta1 protos
* s/v1beta1/v1/g in source.
* s/v1beta1/v1/ in the Xcode project
* Remove stale bug comments.
This was fixed by adding an explicit FieldPath API rather than exposing
escaping to the end user.
* Revert "Revert "gRPC: replace Objective-C implementation with the new C++ implementation (#1968)" (#2030)"
This reverts commit ea567dca47.
* gRPC: fix bugs found during testing (#2039)
All in `GrpcStream`:
* make sure there are no pending completions when "finish" operation is enqueued;
* always finish gRPC calls;
* when connectivity changes, reset not just the calls, but the underlying channel as well.
* Revert "Partially revert "Update CHANGELOG for Firestore v0.14.0 (#2025)" (#2031)"
This reverts commit b2437b80f6.
* Update changelog for v0.15.0.
* gRPC: add gRPC wrapper classes to CMake build (#2015)
* add a C++ equivalent of `FIRFirestoreVersionString`. This eliminates the only Objective-C dependency of `grpc_connection.mm` and allows making it a pure C++ file;
* open-source `binary_to_array.py` script and use it in the build to embed `roots.pem` certificate file from gRPC into the Firestore binary. The embedded char array is then used to load certificate at runtime.
* Revert local change -- do not enable sanitizers by default
* Add C++ namespaces and use C++ linkage for nanopb-generated sources.
* Regenerate nanopb sources as C++
* Add generated C++ nanopb sources to the podspec
* add support for SSL disabled to `GrpcConnection` (unfortunately, there
currently is no way to verify this change actually works);
* make gRPC calls using the C++ implementation:
* make `FSTRemoteStore` create C++ streams instead of their Objective-C
counterparts;
* port https://github.com/firebase/firebase-js-sdk/pull/1041: streams
are now never recreated, only restarted;
* make `FSTDatastore` delegate server calls to the C++ implementation;
* port `MockWatchStream` and `MockWriteStream` to C++ (`FSTMockDatastore` is
still in place, because `Datastore` is not fully ported yet);
* no longer generate Objective-C gRPC service definitions from protos;
* remove all references to Objective-C gRPC client;
* check in gRPC root certificates file and load it at runtime (the check-in part
is temporary until gRPC-C++.podspec provides the certificate). This makes SSL
work.
All proto targets (objc, cpp, nanopb) now depend on the proto sources,
so they'll be rebuilt if the proto sources change.
Also updated Firestore/Protos/README.md to reflect recent changes.
Also update travis config to build the protos. (Previously, cpp and
nanopb were rebuilt, since they're used in the cmake build. But objc was
not since it's not actually depended on by anything in cmake.)
* Mark all dynamic and repeated fields as requiring malloc
* Remove nanopb options files
* Don't pass options-file to nanopb_cpp_generator
* Regenerate nanopb sources
No pb_callback_t fields remain
* Enable dynamic allocation support in the nanopb decoder
* Generate Objective-C proto messages.
* Generate C++ protos
* Delete build-protos.sh
* Rework CMake integration to be able to generate from nothing
* Split protoc and nanopb python generation (#1795)
* Initial build_protos.py can regenerate nanopb
* Delegate to build_protos.py for nanopb
* Simplify CMake integration:
* Generate python in a single pass
* Pass python includes to build_protos
* Generate nanopb in-place
* Use --no-timestamp in nanopb output
* Rename nanopb/.../*.pb.c to nanopb/.../*.nanopb.c
This ensures that all generated nanopb files use the same (sub)
extension of nanopb. This matches up with nanopb's --extension
parameter (which will be enabled later in this PR.)
* Remove references to NANOPB_PROTOC_BIN
Which wasn't being used, and wasn't pointing to a valid protoc.
* Add ability to generate protos from cmake build.
Currently, it's an entirely manual process via 'generate_protos' target.
This target is not automatically run during a build.
See Firestore/Protos/build-protos.sh for expected usage.
* cleanup/update license in build-protos.sh
* Build grpc proto sources (objc only)
* Use 32bit nanopb fields (instead of 16)
To match xcode build, but also to allow google/api/annotations.proto to
compile. (A recent change to nanopb now enforces this.) This isn't
strictly necessary, since we don't make use of that proto, so we
could've simply removed it instead (and in fact, the objc protos do
exactly that) but matching the xcode build certainly seems worthwhile.
* Rebuild all proto sources
* Skip whitespace checks on protoc generated files
* Build zlib with grpc's add_subdirectory
* Build grpc and its children with add_subdirectory.
* Build c-ares with grpc's add_subdirectory
* Convert protobuf to a download-only ExternalProject
* Temporarily break protobuf within grpc
This works because libgrpc has no actual dependency on protobuf
* Update boringssl to master@{2018-07-10}
* Add a download-only boringssl ExternalProject
Match boringssl version to grpc submodule version
Note: not yet in use
* Split grpc into separate download and build tasks
This allows other external targets to download into the gRPC source tree
before grpc is actually built.
* Convert grpc to an http download
* Build googletest with add_subdirectory
Also:
* Revert library-name modifications in the abseil-cpp build
* Move abseil-cpp add_subdirectory build into place
* Build nanopb with add_subdirectory
* Force nanopb first to work around ODR violations
This is a temporary work-around for b/111328563.
* Pull out sanitizer options into a separate file
* Reorder packages
* Remove the extra "external/$target" directory from PREFIX
Instead of BINARY_DIR/external/foo/src/foo the contents will be in
BINARY_DIR/src/foo.
* Make libprotobuf-nanopb targets line up with nanopb's CMakeLists.txt
* Fix CMake style
* Install protobuf
* Use the built-in FindProtobuf.cmake
* Add additional build configuration flags
* Preserve generator configuration in the protobuf sub-build
Without this, the build fails on Win64 because the default
configuration builds a Win32 libprotobuf and the Win64 build rejects
it.
* Wire the installed protobuf into the gRPC build.
* Install nanopb
This avoids a collision with the libprotobuf generated files.
Also removes the "well-known" cpp protos, relying on libprotobuf to supply these instead.
Previously, the tests would compare serialization results against a
precomputed (via protoc) array of bytes. Now they serialize via our
nanopb based class and deserialize via libprotobuf (and vice versa) and
then ensure the result is the same as the input
* Build (grpc's) nanopb with -DPB_FIELD_16BIT
We require (at least) 16 bit fields. (By default, nanopb uses 8 bit
fields, ie allowing up to 256 field tags.)
Also note that this patch adds this to grpc's nanopb, rather than to our
nanopb. We'll need to eventually either:
a) we instruct grpc to use our nanopb
b) we rely on grpc's nanopb instead of using our own.
(^ marked as a TODO for now.)
* Add some dependant protos
Imported from protobuf. Nanopb requires these to be present (though
anything using libprotobuf does not, as these are already built into
that.)
* Add generated nanopb protos based off of newly added proto definitions
* Build the nanopb protos
* Serialize and deserialize null
* Implement schema versions
* Style fixes
* newlines, copyrights, assumptions
* Fix nullability
* Raw ptr -> shared_ptr
* kVersionTableGlobal -> kVersionGlobalTable
* Drop utils, move into static methods
* Drop extra include
* Add a few more comments
* Move version constant into migrations file
* formatting?
* Fix comment
* Split add and update queryData
* Work on adding targetCount
* More work on count
* Using shared_ptr
* Implement count for query cache
* use quotes
* Add cast
* Styling
* Revert year bump in copyright
* Add adversarial key to migration test
* Add comment
* Fix style
This simplifies the import process back into google3 and allows us to add additional directories to the project without needing to update the project files for each directory we add. This shows up most clearly in the change to Firestore/Example/Firestore.xcodeproj/project.pbxproj: this no longer needs to list essentially every directory in the project as a header search path.
* Clang-format configuration for C++ files
* Add support C++-only sources to the podspec
* Podspec support for fully qualified imports
* xcodeproj changes for fully-qualified imports
* Use fully-qualified imports in Firestore sources
Konstantin Varlamov