Merge main branch changes into dev. (#270)

* Avoid double deletion of internal objects during cleanup.

This has been observed during cleanup when a DocumentReferenceInternal is
destroyed, its Future API can end up deleting orphaned Future APIs that contain
Futures holding the containing `DocumentReference`.

PiperOrigin-RevId: 320260380

* Avoid empty statement warnings in Firebase assertions

Wrapping macro bodies in do { } while(false) makes them into a statement that
legitimately should be followed by a semicolon.

PiperOrigin-RevId: 320272779

* Miscellaneous test-only fixes

  * Avoid dereferencing awaited pointers after Await has failed, preventing
    crashes after test timeouts.
  * Await `CollectionReference::Add`, preventing nondeterminism in tests.

PiperOrigin-RevId: 320449430

* Delete C++ Firestore objects when C# has no more references to them.

This was achieved by using the CppInstanceManager, which provides this functionality elsewhere in the Unity SDK. When running UIHandlerAutomated, this eliminates all 11 leaks from Firestore::GetFirestore().

PiperOrigin-RevId: 320609048

* Remove the unconditional calls to Firebase::Terminate() in test cleanup.

These calls were present as a workaround for bugs in the Firestore destructor; however, since those bugs have been fixed the calls to Terminate() are now superfluous and, worse, can hide bugs. As a result, they are being removed.

PiperOrigin-RevId: 320627333

* Change std:unique_ptr to UniquePtr

This is causing Rapid build fail with error message like "error: no template named 'make_unique' in namespace 'std'; did you mean 'MakeUnique'?"
Since we have our own implementation, we should use it consistently.

PiperOrigin-RevId: 320681249

* Update Android deps to latest

PiperOrigin-RevId: 320688041

* Make test failures in numeric transforms tests easier to read

Previously, if the value was of the wrong type, you'd get a message like:

    Value of: snap.Get("sum").is_integer()
      Actual: false
    Expected: true

Which would give no indication of what the actual type or value was. Now tests
will fail like this:

   Expected equality of these values:
     snap.Get("sum")
       Which is: 1337 (Type::kDouble)
     FieldValue::Integer(value)
       Which is: 1337 (Type::kInteger)

As an added bonus this also simplifies the calling code because now we can just
assert that a value in a snapshot is equal to some expected value and
GoogleTest will do the heavy lifting of printing the differences.

One unsolved problem with this approach is how to handle equality within
epsilon for floating point values. This turns out to be non-trivial without
writing custom matchers, which is beyond the scope of what I wanted to tackle
here. Instead of solving this I've changed the tests to use values that have an
exact representation as doubles. This is easier to do for integral values than
for fractional ones so the tests now use integer-valued doubles to achieve the
same effect of cumulative addition as before.

PiperOrigin-RevId: 321022746

* Add JNI Object wrapper and type conversion traits

This is the first in a series of commits that aims to convert our JNI usage to
a more modern approach while still remaining STLPort compatible.

PiperOrigin-RevId: 321059370

* Add JNI ownership types

These generate local and global reference subtypes of a given JNI wrapper that
make it possible to automatically emit DeleteLocalRef and DeleteGlobalRef
calls in the course of regular usage.

PiperOrigin-RevId: 321175591

* Add FIREventScreenView and params

PiperOrigin-RevId: 321183165

* Add another line in the generate constant header script

The generated headers are currently missing a newline prior to @ifdef cpp_examples which is causing doc generation to fail.

PiperOrigin-RevId: 321272103

* Add initial Env with minimal support for Strings

PiperOrigin-RevId: 321475293

* Rework ToJni conversions to enable pass-through of JNI types

Previously, all types needed to be in the JniTypeMap, but this was never
intended to be the end state because it would require an entry for all subtypes
of Object which couldn't scale.

The new implementation based on ranked choice overload selection also resolves
ambiguities. For example: unsigned char could be a uint8_t (which converts to
jbyte) or the underlying type for jboolean. Absent the ranking, an argument of
type unsigned char would resolve to multiple overloads and would be ambiguous.

PiperOrigin-RevId: 321835773

* Add support for calling methods and getting fields.

PiperOrigin-RevId: 322398533

* Create dummy workflow for integration tests (#106)

To manually trigger a workflow in a branch, a workflow with the same name needs to exist in master. This adds such a workflow.

* Create feature-request.md

* Update and rename firebase-cpp-sdk-issue.md to issue.md

Update issue template

* Update issue.md

* Update issue templates

Add a new "General Question" template
Also make sure new feature request issues are marked with "new" label

* Update feature-request.md

* Revise string methods to be wrapper-only

Based on our offline discussion about reducing the number of overloads.

PiperOrigin-RevId: 322722526

* Fix deletion of the pointers returned from CreateFirestore().

The pointers returned from CreateFirestore() should be explicitly deleted, as well as the underlying app pointer, as is done in the ~FirestoreIntegrationTest() destructor for Firestore pointers returned from firestore() and CachedFirestore(). Several test cases in firestore_test.cc were failing to perform this deletion on the pointers returned from CreateFirestore(), resulting in memory leaks.

To facilitate consistency in this deletion logic, I exposed the Release() method so that they could be called by tests that use CreateFirestore().

I then updated the code in firestore_test.cc to call Release() on every pointer returned from CreateFirestore(). This fixes the memory leaks of the objects returned from CreateFirestore(), at least in the case that the tests pass. A future changelist will migrate usages of CreateFirestore() to CachedFirestore() to ensure that the Firestore pointers are deleted whether or not the test passes.

PiperOrigin-RevId: 322814077

* Add exception support to Env

This includes a Throwable wrapper for jthrowable, Env implementatinos of
JNIEnv::Throw, plus tools for writing exception resilient code.
PiperOrigin-RevId: 322836751

* Add logic to ignore a specific file in Kokoro build logic

The chromium_certificate_verifier uses a cc file as an include file, which breaks the CMake logic with add_library.  By excluding that file from the add_library, but keeping it in the zip file, it will still be available for the build to work, but will no longer try to treat it as a source file, which caused the problem.

Also, made the local_test script use the regular_grpc flag, since it is now needed

PiperOrigin-RevId: 323644686

* Add support for cacheable global declarations of JNI types

This includes:

  * constructors
  * instance methods
  * static fields
  * static methods

PiperOrigin-RevId: 323697946

* Add support for embedded files and other odds and ends

PiperOrigin-RevId: 323710861

* Convert CollectionReference to new JNI framework

PiperOrigin-RevId: 323822884

* Add C++ proxies for Java standard library types

This includes proxies for commonly used elements of java.util:

  * ArrayList
  * Collection
  * HashMap
  * Iterator
  * List
  * Map
  * Set

Only commonly used methods are included. Additional methods can be added as
needed.

PiperOrigin-RevId: 324895315

* Fix assertion incorrectly checking a moved-from rather than the moved-to object.

This should fix https://github.com/firebase/firebase-cpp-sdk/issues/85.

Note that this _was_ covered by tests (checked manually). Presumably, because a moved-from `std::function` is in a valid but unspecified state, it might or might not be left empty, depending on the implementation.

PiperOrigin-RevId: 324919105

* Improve `Variant` error message when used with an unsupported type.

In the previous implementation, `set_value_t` was declared to be a template function but never defined (instead, a few specializations were defined). This could cause a linker error when a `Variant` is used with an unsupported type (using `firestore::FieldValue` as the example):
```
ld.lld: error: blaze-out/k8-fastbuild/bin/_solib_k8/libfirebase_Sfirestore_Sclient_Scpp_Slibfield_Uvalue_Utest.ifso: undefined reference to void firebase::Variant::set_value_t<firebase::firestore::FieldValue>(firebase::firestore::FieldValue) [--no-allow-shlib-undefined]
```
(see https://sponge.corp.google.com/invocation?id=0dbf93d2-8644-4058-9b98-0513ad032e08&searchFor=user%3Avarconst)

Deleting the regular template has the advantage of turning it into a compile-time error that contains a reference to the line in the source code that triggers it:

```
In file included from firebase/firestore/client/cpp/src/tests/field_value_test.cc:17:
./firebase/app/client/cpp/src/include/firebase/variant.h:134:5: error: call to deleted member function 'set_value_t'
    set_value_t(value);
    ^~~~~~~~~~~
firebase/firestore/client/cpp/src/tests/field_value_test.cc:295:10: note: in instantiation of function template specialization 'firebase::Variant::Variant<firebase::firestore::FieldValue>' requested here
  return FieldValue{};
         ^
./firebase/app/client/cpp/src/include/firebase/variant.h:1114:8: note: candidate function [with T = firebase::firestore::FieldValue] has been explicitly deleted
  void set_value_t(T value) = delete;
       ^
1 error generated.
```
(see https://sponge.corp.google.com/invocation?id=8122d244-50d5-4072-98fb-9c5c11dc42ad&searchFor=user%3Avarconst)

This should be a non-breaking change (the code that was compiling previously should be unaffected).

PiperOrigin-RevId: 324927992

* Add support for creating and manipulating Java arrays to the `JNIEnv` wrapper

PiperOrigin-RevId: 325087878

* Improve the tests for ClearPersistence() to use the default Firebase app instead of a custom one.

This fixes a concern raised by @pengzk in cl/309775646 that the Firestore* pointers were leaking. By using the default Firestore object retrieved via firestore() instead of a custom Firestore object returned from CreateFirestore() the Firestore* pointer will be properly cleaned up upon test completion.

PiperOrigin-RevId: 325229850

* Convert DocumentReference and supporting classes to the new JNI framework

This includes:
  * SourceInternal
  * MetadataChangesInternal
  * FieldPathConverter
  * SetOptionsInternal
  * DocumentReferenceInternal

This also includes some changes to other types (like QueryInternal) to shim in
usage of the changed types. In some cases both the new and old ways coincide
within a method leading to some temporary bloat. These will be cleaned up in a
subsequent CL.

PiperOrigin-RevId: 325352325

* Rework MapFieldValue and MapFieldPathValue calls

Also:

  * Centralize Java update methods' first-pair-separate-from-varargs handling
    in a new MakeUpdateFieldPathArgs method
  * Also begin work on new-style error handling in transactions by bridging
    Env::UnhandledExceptionHandler to TransactionInternal::PreserveException.

PiperOrigin-RevId: 325468252

* Automated g4 rollback of changelist 325229850.

*** Reason for rollback ***

firestore_test_android appears to have been broken by this change (b/163526671).

*** Original change description ***

Improve the tests for ClearPersistence() to use the default Firebase app instead of a custom one.

This fixes a concern raised by @pengzk in cl/309775646 that the Firestore* pointers were leaking. By using the default Firestore object retrieved via firestore() instead of a custom Firestore object returned from CreateFirestore() the Firestore* pointer will be properly cleaned up upon test completion.

***

PiperOrigin-RevId: 326267389

* Updated MessageForwardingService to be a JobIntentService for Android O.

As of Android O, background services can no longer spawn other background
services, they must instead create JobIntentServices, which can queue up work
for the OS to perform when it is ready. This change also requires that the
JobIntentService be declared in the manifest file.

PiperOrigin-RevId: 326749322

* Deprecating Send.

When Send is actually removed from the underlying iOS SDK, we should check in cr/322694231 which removes it from C++ entirely.

PiperOrigin-RevId: 326753736

* LSC: Change for loops to use const refs, per performance-for-range-copy
clang-tidy.

This CL optimizes C++11 range-based for loops where the variable is copied in
each iteration but it would suffice to obtain it by const reference.  This is
only applied to loop variables of types that are expensive to copy which means
they are not trivially copyable or have a non-trivial copy constructor or
destructor.

To ensure that it is safe to replace the copy with a const reference the
following heuristic is employed:
  The loop variable is const qualified.
  The loop variable is not const, but only const methods or operators are
  invoked on it, or it is used as const reference or value argument in
  constructors or function calls.

See go/lsc-performance-for-range-copy for details.

Applied ClangTidy fixes to google3 paths matching '[abcdefghijklmnoprs].*'.

The changelist was automatically generated using the apply_fixes.sh script:
  devtools/cymbal/clang_tidy/apply_fixes.sh --checks=-*,performance-for-range-copy --create_changelist --files_to_process=[abcdefghijklmnoprs].*

Track: canary
Findings source: /placer/prod/home/devtools-cxx-clang-tidy/canary/latest/clang_tidy-?????-of-?????
Subcategories: performance-for-range-copy

WARNING: Automatically generated changes should be carefully inspected. For most
ClangTidy warnings multiple alternative fixes are possible and only one of them
is suggested. There's no guarantee that it will be the best one (or even a right
fix). The amount of reviewers' attention to automated changes should be at least
the same as for manually written code.

Tested:
    tap_presubmit: http://test/OCL:323300886:BASE:324354295:1596315075612:bb83204a
    Some tests failed; test failures are believed to be unrelated to this CL
PiperOrigin-RevId: 326827164

* Update the Android dependencies for M77

PiperOrigin-RevId: 327556559

* Convert DocumentChange to the new JNI framework

PiperOrigin-RevId: 327653990

* Convert ServerTimetampBehavior to new JNI framework

PiperOrigin-RevId: 327717920

* Convert SnapshotMetadata to the new JNI framework

PiperOrigin-RevId: 327727645

* Make Unity send Cloud API headers indicating the language version and the Firestore version.

This only works for iOS and Android for now; Android is still a TODO.

Also bump the Firestore version to 1.16.4 (it hasn't been updated in a long time and was still 1.1.0).

From debug logging, the value sent via the header looks like:
```
gl-dotnet/4.0.30319.42000 fire/1.16.4 grpc/1.32.0-dev
```

PiperOrigin-RevId: 327871420

* Convert DocumentSnapshot to the new JNI framework

PiperOrigin-RevId: 327886189

* Improve the error message that is generated when a Future fails.

PiperOrigin-RevId: 328179796

* Convert Blob to the new JNI framework

Also fix redundant blob caching behavior in `FieldValueInternal`, consolidating
the code to populate `cached_blob_` in a single `EnsureCachedBlob` method.

PiperOrigin-RevId: 328849949

* Convert Direction to the new JNI framework

Note that this gets rid of the enum caching mechanism in favor of just making a
JNI call to get the associated field. This reduces complexity, removes static
state, and greatly reduces the amount of code, with a minor performance penalty
to code that's not remotely performance critical.

PiperOrigin-RevId: 328856579

* Convert Settings to the new JNI framework

PiperOrigin-RevId: 329734038

* Convert WriteBatch to the new JNI framework

PiperOrigin-RevId: 329805287

* Convert Timestamp to the new JNI framework

PiperOrigin-RevId: 329814232

* Change forward declaration for SignInResult to struct

SignInResult is declared as a struct in user.h but forward declared here as a class.
This did not cause error in our build but is causing compiler error for user.

Fixed #120

PiperOrigin-RevId: 329958702

* Convert QuerySnapshot to the new JNI framework

PiperOrigin-RevId: 330111277

* Update the Android dependencies for M78

PiperOrigin-RevId: 330559438

* Re-write `run_local_tests.sh` to run the tests in parallel.

When I profiled this change locally, the runtime of the script was reduced from about 30 minutes down to 12 minutes when the blaze commands were run in parallel. This makes sense because a lot of the time is spent just waiting for Kokoro to perform the build.

PiperOrigin-RevId: 330748434

* Plumb through error messages for Query and Document listens in C++ and Unity.

NOTE: This changelist is a breaking change in that it changes the public C++ Firestore API in a backwards-incompatible manner.
PiperOrigin-RevId: 330757239

* Check that calls to Terminate() and ClearPersistence() actually succeed.

I had incorrectly assumed that `Await()` would fail the test if the `Future` it was specified failed. This incorrect assumption hid the fact that `ClearPersistence()` failed on Android, resulting in unexplained downstream failures, resulting in a rollback: cl/326267389.

With this change, the failure of the `Future` objects returned from `ClearPersistence()` and `Terminate()` will be noted, highlighting the source of the test failures.

PiperOrigin-RevId: 330777066

* Add logic to detect the compiler version and the C++ language standard used.

This is largely adapted from the Cloud C++ APIs with the following changes:

* added C++20 to the list of possible standards;
* added "latest" as a possible C++ standard for MSVC;
* added the C++ standard library vendor to the compiler info string, primarily
  to track STLPort.

Here are some sample values I'm getting:
* on my Mac laptop: `AppleClang-11.0.3.11030032-ex-2011-libcpp`;
* google3 Android build: `Clang-9.0.8-ex-2017-libcpp`;
* google3 Windows build: `MSVC-19.22.27905-ex-2017-msvc`;
* google3 Linux build: `Clang-9999.0.0-noex-2017-libcpp` (unfortunately,
  Clang trunk in google3 simply sets the version to 9999:
  https://source.corp.google.com/piper///depot/google3/third_party/llvm/llvm-project/clang/BUILD;l=374-383;rcl=330443088)

Note that as long as the C++ SDKs are distributed in precompiled form, the compiler version reported will be from the compiler we used to compile the binaries, not the compiler used by our users. Unfortunately, there is no clear way to avoid this that wouldn't cause an ODR violation (if e.g. `CompilerId` were placed in a header as an inline function, it would end up having different definitions depending on whether it's included internally or by the user (indirectly)). However, this shouldn't be a big issue as the metrics will still allow tracking total C++ usage and, to an extent, usage by platform.

PiperOrigin-RevId: 331654266

* Automated g4 rollback of changelist 326267389.

*** Reason for rollback ***

Roll forward cl/325229850: Improve the tests for ClearPersistence() to use the default Firebase app instead of a custom one.

I've added a workaround for the broken test, a call to Terminate() in Android, and created b/168628900 to track the underlying bug.

*** Original change description ***

Automated g4 rollback of changelist 325229850.

*** Reason for rollback ***

firestore_test_android appears to have been broken by this change (b/163526671).

*** Original change description ***

Improve the tests for ClearPersistence() to use the default Firebase app instead of a custom one.

This fixes a concern raised by @pengzk in cl/309775646 that the Firestore* pointers were leaking. By using the default Firestore object retrieved via firestore() instead of a custom Firestore object return...

***

PiperOrigin-RevId: 331991549

* Temporarily add a platform token to the Cloud API headers.

Until b/135633112 is resolved and support for Firebase platform logging is
rolled out on the Firestore backend, there is no good way to estimate the
number of users of the Firestore C++ SDK by platform. As a workaround, add
a platform token to the Cloud headers. Proper support for platform tokens was
actually never added to Cloud headers, but the data processing pipeline
simply ignores unknown tokens so there is no harm in doing this addition.

The implementation reuses the notion of a client language in the Core API to
lump together two tokens (the language and the platform). This is deemed
acceptable only due to the temporary nature of this workaround.

Sample of the header values I'm seeing:
- running C++ tests on Linux in google3:
  `gl-cpp/Clang-9999.0.0-noex-2017-libcpp gl-linux/ fire/1.17.1 grpc/1.33.0-dev`
  (notice the `gl-linux/` token);
- in Unity: `gl-dotnet/4.0.30319 gl-macos/ fire/1.17.1 grpc/1.33.0-dev` (notice
  the `gl-mac/` token);

PiperOrigin-RevId: 332094253

* Add play-services-base to Android deps for analytics/admob/remote_config.

Due to a change in the transitive dependencies of analytics, play-services-base is no longer present. This is needed to check for the presence of Google Play Services. Admob and Remote Config both depend on analytics (through 'app'), which is how they previously got that dependency. Other APIs depend directly on play-services-base at the Android level.

PiperOrigin-RevId: 332267491

* Update the Build and Podfiles

PiperOrigin-RevId: 332327282

* Update the version numbers for 6.16.0

PiperOrigin-RevId: 332496615

* Convert GeoPoint to the new JNI framework

PiperOrigin-RevId: 333116446

* Handling `IllegalStateException` when loading or creating interstitial ads.
(reported in https://github.com/firebase/firebase-cpp-sdk/issues/121

New error code and message for the default fallback case in switch statements- ConstantsHelper.CALLBACK_ERROR_UNKOWN and ConstantsHelper.CALLBACK_ERROR_MESSAGE_UNKNOWN.
Corresponding new error code added to C++ side (admob/types.h)

Removed a redundant overridden method as it was just calling its base class method directly.

Updated release notes with this bugfix

PiperOrigin-RevId: 333125360

* Convert Query to the new JNI framework

PiperOrigin-RevId: 333157347

* Copybara Firestore

PiperOrigin-RevId: 333174406

* Added a test for C++ namespace renaming to Blastdoor tests, and added a fix to
rename symbols that are external references implemented in other files.

This fixes a Blastdoor issue where a symbol that needs to be renamed is passed
between multiple internal libraries -- it needs to be renamed regardless of whether its
implementation is present or if it is an external symbol.

PiperOrigin-RevId: 333175764

* Set the language in Cloud headers to `gl-cpp/` in the C++ SDK on Android.

This is possible now that the Copybara CL cr/333174406 is submitted. This CL requires on Android functionality available starting from M80 (Firestore 21.7.0).

PiperOrigin-RevId: 333356092

* Convert FirestoreInternal to the new JNI framework

This converts all method invocations but does not necessarily convert all uses
of older APIs because those are still needed to support classes that have not
yet converted.

PiperOrigin-RevId: 333429091

* Convert ListenerRegistration to the new JNI framework

PiperOrigin-RevId: 333539837

* Fix it so only external C++ symbols matching the list of namespaces to rename
are renamed. C symbols that are external will not be renamed.

Also adds a flag to turn off this new behavior, though it's on by default for
now.

PiperOrigin-RevId: 333613425

* Convert EventListener to the new JNI framework

PiperOrigin-RevId: 334212158

* Clean up exception naming

Rename FirebaseFirestoreExceptionInternal to ExceptionInternal.  Rename methods
in ExceptionInternal to better reflect their function.

PiperOrigin-RevId: 334219916

* Convert ExceptionInternal to the new JNI framework

Also partially convert TransactionInternal since these are so intertwined.

PiperOrigin-RevId: 334241429

* Make snapshot from TransactionGetResult return by value.

This ensure C# DocumentSnapshot will own the C++ DocumentSnapshot when it is read from within a transaction.

PiperOrigin-RevId: 334276809

* Add Ad Impression constants to public header

PiperOrigin-RevId: 334451358

* Finish conversion of TransactionInternal to the new JNI framework

PiperOrigin-RevId: 334459761

* Add boxed primitive types to the JNI library

PiperOrigin-RevId: 334472082

* Add example to ad unit in header file

PiperOrigin-RevId: 334482610

* Add note about value param in ad impression event

PiperOrigin-RevId: 334497833

* Add Equals to the JNI Object proxy.

Also add GetClass to some JNI proxies.

Remove Wrapper::EqualsJavaObject

PiperOrigin-RevId: 334501941

* Add a cache of Firestore Java references to FirestoreInternal pointers

Use it in DocumentSnapshotInternal::Create, removing the need for FieldValue to
have a FirestoreInternal pointer.

PiperOrigin-RevId: 334519517

* Update to the Messaging Library Manifest File which caused build issues in GH CI.  Embedding the service clause inside application.

PiperOrigin-RevId: 334851815

* Automated g4 rollback of changelist 333356092.

*** Reason for rollback ***

Temporary rollback to unblock the FPL release (which depends on Android M79).

*** Original change description ***

Set the language in Cloud headers to `gl-cpp/` in the C++ SDK on Android.

This is possible now that the Copybara CL cr/333174406 is submitted. This CL requires on Android functionality available starting from M80 (Firestore 21.7.0).

***

PiperOrigin-RevId: 335476967

* Remove FirestoreInternal::Wrap and Internal

Also remove the related ApiType using declarations.

PiperOrigin-RevId: 335887511

* Convert FieldValue to the new JNI framework

PiperOrigin-RevId: 335989850

* Convert Wrapper to the new JNI framework

PiperOrigin-RevId: 335995848

* Reduce dependencies on app's util_android.h

PiperOrigin-RevId: 336138470

* Post-migration clean-up

  * Remove references to jni.h where JNI types aren't directly used
  * Clean up remaining jobject APIs that don't belong anymore
  * Clean up method names now that conflicts are gone

PiperOrigin-RevId: 336164270

* Reorganize utilities

  * Move exception utilities into exception_android.h
  * Move collection conversion utilities in Wrapper into util_android.h

This more-or-less achieves the goal of reducing the role of Wrapper as a
dumping ground for random functionality and brings exception-related code into
a single location.

PiperOrigin-RevId: 336189320

* [FIS]CPP package change (8/n)

PiperOrigin-RevId: 336203653

* Fix a deadlock between snapshot listeners and cleanup.

The deadlock may be triggered by the following steps:
1. Add a snapshot listener to a collection (a document reference or a query will likely work as well, but not tested).
2. Wait for the listener to fire.
3. Immediately after that, delete the App or the Firestore instance (which invokes cleanup).

Note that because the deadlock is timing-based, it's not guaranteed to happen.

With simplifications, this leads to the following call stacks (using collection listeners for the sake of the example):

  User callback thread
- `AsyncEventListener::OnEvent` locks the listener mutex (LM);
- `AsyncEventListener::OnEvent` invokes the user callback;
- when the user callback is finished, a `QuerySnapshot` passed to the callback is destroyed
- the destructor of `QuerySnapshot` tries to unregister itself from the cleanup;
- the unregister function tries to acquire the cleanup mutex (CM).

  “Main” thread (the thread on which the Firestore instance is destroyed)
- Firebase App is destroyed;
- Firestore instance is destroyed;
- `Firestore` destructor triggers cleanup;
- Cleanup locks the cleanup mutex (CM);
- Cleanup invokes `firestore::ListenerRegistration::Cleanup`;
- Listener registration cleanup invokes `AsyncEventListener::Mute`;
- `AsyncEventListener::Mute` tries to acquire the listener mutex (LM).

To work around this, make sure to clear the listeners _before_ invoking the cleanup in `Firestore` destructor.

An alternative fix would be to make sure `CleanupNotifier` doesn't hold the mutex while invoking cleanup callbacks. Unfortunately, cleanup callbacks might destroy objects that are subject to cleanup as well and thus would try to unregister themselves, preventing this approach. In other words, if `CleanupNotifier` contains, say, 10 callbacks, there is no guarantee that it will still contain 10 callbacks after the first one is invoked.

PiperOrigin-RevId: 336603266

* Update the version numbers to 6.16.1

PiperOrigin-RevId: 336993745

* Added helper function to create directories recursively on desktop platforms(mac, windows and linux).

This fixes SEGFAULTS that were seen on running database integration tests. Issue was that "app_name" is usually a string with a "/" in it and mkdir calls on Mac and Windows were not creating directories recursively.

Changes were first done on github in this PR,
https://github.com/firebase/firebase-cpp-sdk/pull/124

Updated C++ and Unity release notes.

Created an accompanying unit test in `database/util_desktop_test UtilDesktopTest.TestSplitString`

Modified UtilDesktopTest.TestGetAppDataPath to test with an app path with a delimiter (the reason our previous release didn't catch this bug).

PiperOrigin-RevId: 337121244

* Remove the call from Database to variant_utils that take Flexbuffers

Because of a problem with the merge_libraries script, functions that take Flexbuffers as parameters are not being handled correctly. Until this is fixed, work around it by not relying on those functions.

PiperOrigin-RevId: 337611271

* Remove the dependency on variant_util from Database

PiperOrigin-RevId: 337929528

* [FIS] mark IID deprecated

PiperOrigin-RevId: 338139599

* Import Firestore release 1.19.0 from GitHub (Firebase 6.34.0, M81).

Manual changes:
- add a new build target for `FirebaseMetadataProvider` and related plumbing;
- downgrade the constants defined in `FirebaseMetadataProvider` from `constexpr` to just `const` to work around a Visual Studio compiler bug;
- remove `core_portable` build target (it's an unused target);
- revert the manual import of https://github.com/firebase/firebase-ios-sdk/pull/6778 (affecting `remote/serializer.cc`) being overwritten (it's part of M82, not M81);
- prevent cr/337586325 from being overwritten by the import;
- bump the Firestore version in `third_party/firebase/ios/Releases/FirebaseFirestore/version.bzl`;
- revert the google3-internal change to `util/exception.cc` being overwritten (see cr/295257418).

BUG=130370442

Copybara-generated description follows:

  - 2d7778cdfb43a9fe7e042f5beea89e8056fb74e7 Add a changelog entry for Firestore platform logging (#66... by Konstantin Varlamov <[email protected]>
  - a039948badb3e35f3c9d773972c7eb477911bec1 Update CHANGELOG for Firestore v1.19.0 (#6601) by Gil <[email protected]>
  - 393d32f05e072cb65242340e7737b860b1f73f57 Make FirestoreException a type defined by Firestore/core ... by Gil <[email protected]>
  - 54e0bb81fd054d8d822592db17762591972a55af Always send the user agent regardless of the heartbeat va... by Konstantin Varlamov <[email protected]>
  - 2311c36dbcd19f2f6e89f0f2747582f0647442f7 Integrate Firestore with Firebase platform logging (#6507) by Konstantin Varlamov <[email protected]>
  - 24a77d04c88fd9e6466009cd343a4d7553b65cc3 Import Spec tests (#6525) by Sebastian Schmidt <[email protected]>
  - 47fcf141ad7cd2905068a1b1a08988a92fc2bc6c Fix FSTGoogleTestTests under Xcode 12 (#6478) by Gil <[email protected]>

PiperOrigin-RevId: 338359239

* Make Android's FirestoreException match iOS

This prepares for the copybara import of
https://github.com/firebase/firebase-ios-sdk/pull/6589, keeping any dependent
work in this stream independent of when we actually perform the import into
third_party.

PiperOrigin-RevId: 339161530

* [M82]Update android dependencies

PiperOrigin-RevId: 339288456

* [RemoteConfig V2] update api deprecation for Fireconf

PiperOrigin-RevId: 339295475

* Update the Build and Podfiles for 7.0.0

PiperOrigin-RevId: 339314101

* Removing deprecated Send and Direct Channel functionality

Cloned from CL 322694231 and 319894420

PiperOrigin-RevId: 339360356

* [FCM]Add GetToken, DeleteToken function

PiperOrigin-RevId: 339497618

* [M82]Fix an RC change that fails build unity

PiperOrigin-RevId: 339517841

* Updated the raw_data field in messaging.h to be a vector of bytes instead of a
string.

Using a string makes it difficult to work with byte streams that have embedded
null characters. In these situations it makes more sense to represent the data
as what it actually is, a sequence of raw bytes.

Previously this field was unused in C++ and never populated, so although this
is a change to a public header it should not break anyone, and anyone who is
broken by this was not using it correctly anyway.

Patch of CL 288600981, 288601322, 288601437

PiperOrigin-RevId: 339735518

* Remove deprecated SetMinimumSessionDuration in Analytics

SetMinimumSessionDuration has been deprecated for more than a year, so removing it.

PiperOrigin-RevId: 339744045

* Update the version numbers to 7.0.0

PiperOrigin-RevId: 340263010

* Automated g4 rollback of changelist 335476967.

*** Reason for rollback ***

Firebase C++ now depends on Android M82, so this is fine to resubmit.

*** Original change description ***

Automated g4 rollback of changelist 333356092.

*** Reason for rollback ***

Temporary rollback to unblock the FPL release (which depends on Android M79).

*** Original change description ***

Set the language in Cloud headers to `gl-cpp/` in the C++ SDK on Android.

This is possible now that the Copybara CL cr/333174406 is submitted. This CL requires on Android functionality available starting from M80 (Firestore 21.7.0).

***

***

PiperOrigin-RevId: 340267852

* Port WhereNotEqualTo and WhereNotIn to C++ SDK

PiperOrigin-RevId: 340640828

* LSC: Add absl::GetFlag and absl::SetFlag to uses of some flags so they can be migrated to v2 flags (i.e. ABSL_FLAG).

Affected flags: all relevant call sites under [d-i].*

More information: go/v2_flags_migration_lsc

Tested:
    TAP sample presubmit queue
    http://test/OCL:340643476:BASE:340643884:1604503763836:7248bd60
PiperOrigin-RevId: 340706255

* [Unity] Port NotEqual and NotIn Queries to Unity SDK

iOS: https://github.com/firebase/firebase-ios-sdk/pull/6418
Android: https://github.com/firebase/firebase-android-sdk/pull/1975
C++: cl/340640828
PiperOrigin-RevId: 341115259

* Add support for setting and retrieving the cache size to `Settings`.

PiperOrigin-RevId: 341144709

* #cleanup Unable to fix after @UiThread or runOnMainSync

(Not submitting until 11/9)

A go/rosie is not being done for this as adding the new calls and removing the old calls must be done at the same time (if we did one before the other, the tests would be failing in between)

For several years now, Android instrumentation tests in Google3 have been using the incorrect flag to specify test timeouts to AndroidJUnitRunner. However, due to an old bit of hacky behavior in Google3InstrumentationTestRunner, we cannot simply fix the problem by switching the code to use the correct flag.

In particular, Google3InstrumentationTestRunner currently starts a Looper that allows tests to be able to post events from the test thread (when tests aren’t supposed to be able to). Since using the correct flag in AndroidJUnitRunner would cause the test to now run in a separate thread from before, any tests that relied on this Looper would start to fail.

So, before we can turn on the flag, we need to go through and address all the tests that relied on the above behavior in Google3InstrumentationTestRunner.

If your test is in this changelist, it means that the test is posting events from the test thread, and we were unable to find a simple fix to suggest. To unblock everyone else, we’ve decided to move the associated Looper call to your tests’ setup so that your tests will still work when timeout enforcement is done correctly. A TODO(b/…) is being added next to the new call as a tracking bug for teams who wish to later (on their own time/schedule) refactor their test to no longer rely on the call.
```
# Startblock config for deferred review.
Startblock:
  has lgtm
  and then
  add tedbisson
```
PiperOrigin-RevId: 341435027

* [FIS]Add unit test for getId, getToken, delete

PiperOrigin-RevId: 341440510

* Make `Query` methods that return new queries (e.g. `WhereEqualTo`) const.

PiperOrigin-RevId: 341469549

* Remove deprecated Dynamic Links properties in C++ and Unity SDK

PiperOrigin-RevId: 341662413

* Extract the has-exceptions test into a common header

Also make some portable definitions of Abseil support macros in preparation for
future CLs.

PiperOrigin-RevId: 341724467

* Implement Firebase Heartbeat in C++.

Also integrates the Firestore C++ SDK with the heartbeat and Firebase platform logging.

See go/firestore-sdk-metrics for more context.

Sample user agent strings I'm seeing in tests:

C++ Linux
```
fire-cpp/6.16.1 fire-cpp-arch/x86_64 fire-cpp-os/linux fire-cpp-stl/libcpp fire-fst/1.19.0
```

C++ macOS
```
fire-cpp/6.16.1 fire-cpp-arch/x86_64 fire-cpp-os/darwin fire-cpp-stl/libcpp fire-fst/1.19.0
```

Unity macOS
```
fire-cpp/6.16.1 fire-cpp-arch/x86_64 fire-cpp-os/darwin fire-cpp-stl/libcpp fire-fst/1.19.0 fire-unity/6.16.1 fire-unity-ver/2019.2.0f1
```

Unity iOS
```
apple-platform/ios apple-sdk/18A390 fire-analytics/6.9.0 fire-auth/6.9.2 fire-cpp-arch/arm64 fire-cpp-os/ios fire-cpp-stl/libcpp fire-cpp/6.16.1 fire-fst/1.19.0 fire-install/1.7.0 fire-ios/6.10.4 fire-unity-ver/2019.2.0f1 fire-unity/6.16.1 swift/true xcode/12A7300
```

C++ Windows
```
fire-cpp/6.16.1 fire-cpp-arch/x86_64 fire-cpp-os/windows fire-cpp-stl/MT fire-fst/1.19.0
```

PiperOrigin-RevId: 341930017

* Fix Unity Editor hang on Windows when Listen() is invoked (b/172566004).

The issue is that when the C++ callback crosses the boundary into C# via P/Invoke, C# becomes aware of the existence of the thread. Later, when the "play" button is used in the Unity Editor to restart the app, the AppDomain unloading process starts, first signaling all threads that it knows exist then waiting for all of those threads to terminate; however, the callback thread is part of a thread pool and does not terminate in response to the signal, causing AppDomain unloading to deadlock.

This fix converts the callbacks to use `callback.h`, which was created a few years ago by the FPL team to address this exact issue. It addresses the issue because the thread that crosses the P/Invoke boundary is one that *is* terminated in response to the signal sent during AppDomain unloading, thus avoiding deadlock.

This fix probably also fixes b/170201731, where the Unity Editor hangs intermittently on non-Windows hosts as well.

PiperOrigin-RevId: 342100274

* Fix Android crash when Firestore is disposed during a transaction callback.

PiperOrigin-RevId: 342108114

* Copybara Firestore

PiperOrigin-RevId: 342159130

* Re-write the transaction logic to run the user-supplied callback asynchronously.

The motivation for this change is to work around the `ThreadAbortException` that crashes the Unity Editor if Play/Pause is toggled while a transaction is in progress (b/169264353).

Previously, the user-supplied C# transaction callback was called from C++ and would block in C# until the callback, and all of its asynchronous tasks, especially I/O-bound `Transaction.GetSnapshotAsync()` tasks, completed. If the Play/Pause button was used to restart the app in the Unity Editor during the time that the C++ thread was blocked in C# then the `ThreadAbortException` would occur and unavoidably cross the P/Invoke boundary into C++, causing the crash.

The fix is to still call the user-supplied C# transaction callback synchronously from C++; however, instead of blocking in C# until all of the asynchronous tasks complete, the callback returns to C++ and C++ waits for C# to signal the completion of the asynchronous tasks. This reduces the window during which the `ThreadAbortException` could occur to be on par with other listener callbacks that do not suffer from `ThreadAbortException`-related crashes.

PiperOrigin-RevId: 342923297

* Clean up `Firestore` instance management.

The main change is to merge the `firestore()`, `CachedFirestore()`, and `CreateFirestore()` methods into a single new method: `TestFirestore()`. The new `TestFirestore()` method accepts an app name that defaults to the default app's name.

The old methods map to the new methods as follows:
- `firestore()` -> `TestFirestore()`.
- `CachedFirestore(app_name)` -> `TestFirestore(app_name)`
- `CreateFirestore(app_name)` -> `db = TestFirestore(app_name)` followed by `DeleteFirestore(db)` or `RemoveFirestore(db)`

Finally, instead of explicitly calling `delete` on `App` and `Firestore` instances, use the methods `DeleteFirestore()` and `DeleteApp()`, respectively. All objects returned from `TestFirestore()` will be automatically deleted at the end of the test, so deleting these objects explicitly would result in double-deletion in the `FirestoreIntegrationTest` destructor. This is different from the old `CreateFirestore` method, which required that the caller explicitly delete the returned `Firestore` instance and its `App`.

PiperOrigin-RevId: 343482286

* Remove unnecessary std before strlen, as it causes problems

PiperOrigin-RevId: 343586290

* Update Integration and Testapp minimum target iOS version to fix rapid buid failures.

PiperOrigin-RevId: 343591435

* A second update to the integration and testapp XCode projects to bump the minimum target iOS version.  The previous attempt to set the version to 10.0 didn't work.  Should have been 10.12 according to second bullet point in the [Firebase release notes](https://firebase.google.com/support/release-notes/ios#version_700_-_october_26_2020).

PiperOrigin-RevId: 343888975

* Automated g4 rollback of changelist 343888975.

*** Reason for rollback ***

The version should have been 10.0 all along.  I misread the release notes - it's the Mac OSX version must be 10.12, not the iOS version.

I've determined that this issue is caused by the Unity project which targets iOS 9.0, a version beneath our minimum supported version.

*** Original change description ***

A second update to the integration and testapp XCode projects to bump the minimum target iOS version.  The previous attempt to set the version to 10.0 didn't work.  Should have been 10.12 according to second bullet point in the [Firebase release notes](https://firebase.google.com/support/release-notes/ios#version_700_-_october_26_2020).

***

PiperOrigin-RevId: 344283048

* Fix invalid conversion from AuthError to a Firestore Error.

PiperOrigin-RevId: 344844086

* Fix AdMob Android to initialize JavaVM earlier in initialization.

Fixes publicly reported bug: https://github.com/firebase/firebase-cpp-sdk/issues/192

PiperOrigin-RevId: 344901416

* Fix 1 ClangTidyReadability finding:
* unqualified call to function 'std::getline' uses ADL For more info see go/clang_tidy/checks/google3-readability-adl-call

This CL looks good? Just LGTM and Approve it!
This CL doesn’t look good? This is what you can do:
* Suggest a fix on the CL (go/how-to-suggest-fix).
* Revert this CL, by replying "REVERT: <provide reason>"
* File a bug under go/clang-tidy-bug for category ClangTidyReadability if the change looks generally problematic.
* Revert this CL and not get a CL that cleans up these paths in the future by
replying "BLOCKLIST: <provide reason>". This is not reversible! We recommend to
opt out the respective paths in your CL Robot configuration instead:
go/clrobot-opt-out.

This CL was generated by CL Robot - a tool that cleans up code findings
(go/clrobot). The affected code paths have been enabled for CL Robot in //depot/google3/METADATA.
Anything wrong with the signup? File a bug at go/clrobot-bug.

#codehealth

PiperOrigin-RevId: 345303103

* Fix memory leaks in ReleaseXArrayElements:

The inspected code used JNI_COMMIT as a release mode,
which is specified as a release mode that copies
the changes to the Java array, but does not free the
native buffer (in case when the array is a copy) [1, 4].
Hence, when used as the last Release... mode, it effectively
leaks the native buffer when the provided array is a copy
(see the Hotspot implementation [2, 3], which always copies).

Instead, in this use-case "0" mode must be used.

The code fragments have been inspected to not do anything fancy with
the buffer pointer — they all store the buffer in local variables,
and release the array after they are done.

A full-blown fix is to use a safer alternative, jni_helper,
as `CHECK_JNI(FATAL, env).GetXArrayElements`, see
http://google3/util/java/jni_helper.h?l=141-150&rcl=341324486

Ironically, the issue was discovered when I searched for any good examples
of JNI_COMMIT usage IRL, to aid in making a decision on supporting this
flag in jni-rs, safe JNI bindings for Rust.

The code under third_party is not yet inspected.

[1]: https://docs.oracle.com/en/java/javase/11/docs/specs/jni/functions.html#releaseprimitivetypearrayelements-routines
[2]: http://google3/third_party/java_src/jdk/head/src/src/hotspot/share/prims/jni.cpp?l=2613&rcl=302688582
[3]: http://google3/third_party/java_src/jdk/head/src/src/hotspot/share/prims/jni.cpp?l=2665-2670&rcl=302688582
[4]: https://developer.android.com/training/articles/perf-jni#primitive-arrays

Tested:
    TAP --sample ran all affected tests and none failed
    http://test/OCL:341596811:BASE:341578570:1605013504633:7ec031b2
PiperOrigin-RevId: 345402895

* Fix bug where including a "delete" operation in an update causes partial updates.

The easiest fix would have been to replace `break` with `continue`; however, I changed it to an if/else statement to be in line with the other SDKs. See b/174676322 for details.

This bug affects both the Firestore Unity and C++ SDKs. Therefore, I have added unit test coverage to both for this specific case.

This bug was originally reported by a customer: https://github.com/firebase/quickstart-unity/issues/882

PiperOrigin-RevId: 345664484

* [M82][RemoteConfig] Remove deprecated android apis in 7.0.0

This is a hacky fix to switch the old api into new ones. Some of the old apis are not functional at all, but need to make sure app is not crash.

Android Api removed:
FirebaseRemoteConfig.activateFetched
FirebaseRemoteConfig.setDefaults(int)
FirebaseRemoteConfig.setDefaults(Map)
FirebaseRemoteConfig.setConfigSettings
FirebaseRemoteConfig.getByteArray

FirebaseRemoteConfigSettings.isDeveloperModeEnabled
FirebaseRemoteConfigSettings.Builder.setDeveloperModeEnabled

PiperOrigin-RevId: 345794794

* Add copybara logic to handle CL description errors

This is what the documentation recommends to do.

PiperOrigin-RevId: 346662580

* Add unit tests for promise_android.h.

PiperOrigin-RevId: 347364291

* Delete unused (and invalid) overload of Promise::RegisterForTask().

The method is "invalid" because, when instantiated, it fails to compile (the `RegisterForTask` overload that it calls does not exist). This was never noticed because this type of compilation error is not detected until the method is actually invoked, forcing the compiler to instantiate it. Since the method was never invoked, nobody noticed.

PiperOrigin-RevId: 347404402

* Fix DocumentSnapshot for non-existent documents in C++ and Unity

There are two fixes here:

  * In Android C++, a non-existent document is returned as a null map;
    translate that to an empty map in C++
  * In Unity, handle non-existent documents specially to avoid returning an
    empty Dictionary to C# users (where null is the expected value).

PiperOrigin-RevId: 347416592

* Add Installations to the copybara and build logic

PiperOrigin-RevId: 347706043

* Actually implement DocumentChange.Type

This was an error introduced in cl/327653990 that wasn't discovered
because we didn't have any test coverage for this method.

PiperOrigin-RevId: 347889325

* Optimize calls to std::string::find() and friends for a single char.

The character literal overload is more efficient.

go/lsc-performance-faster-string-find

Tested:
    TAP for global presubmit queue
    http://test/OCL:347655100:BASE:347631998:1608131503084:adc733c1
PiperOrigin-RevId: 347936227

* Allow Firestore::set_log_level to be called early on Android

Handle calls to Firestore::set_log_level before any Firestore instances have
been created. On Android, defer calls to FirebaseFirestore.setLogLevel until
after an instance has been created.

PiperOrigin-RevId: 348025209

* Add Get/Set languge code to the Firebase Auth C++/Unity APIs.

API Design Doc: go/CppAuthLanguageCode

The implementation calls into the Android or iOS Firebase SDKs for those platforms,and plumbs the language code into the corresponding RPCs on desktop.  Fakes have been updated to fore the new methods so that TAP CI may execute.

Unity SWIG maps the two C++ methods firebase::auth::set_language_code() and firebase::auth::language_code() into a C# property FirebasAuth.LanguageCode.

PiperOrigin-RevId: 348029104

* Fix Unicode handling on Android

The JNI support for Java Strings added in cl/321475293 did not handle Unicode
characters correctly, passing the number of bytes requested to a method that
actually wanted the number of chars. Switching to this broke reading strings
from Java if they have any non-ASCII Unicode characters in them.

Additionally, the old routines cl/321475293 was supposed to replace treat the
bytes coming into/out of Java as modified UTF-8, even though our product works
with standard UTF-8. This meant we had latent bugs around handling of null
bytes and characters beyond the basic multilingual plane.

This CL fixes both issues, by converting Strings to UTF-8 bytes using methods
on String itself. This avoids dealing in modified UTF-8 or the bug prone JNI
methods like `GetStringUTFRegion`.

PiperOrigin-RevId: 348050717

* Reflect changes made to our Open Source repo in order to fix build errors in release version 7.0.0.  Reflecting the work made in the repo so that we don't export the problematic files again.

Fixes include:
  - Using std::mutex in app/heartbeat_date_storage_desktop.  Replaced its use with our own internal implementation of Mutex.
  - ios_pod CmakeList updated with sunmou@'s changes to fallback to the xcframework path for header resolution.
  - Updating main podfile to the new minimum supported iOS version of 10.0.
  - Added heartbeat_date_storage_desktop to app's cmakefile on Desktop and iOS.
  - Removed firebase_firestore_settings_ios files from firestore's cmake file.
  - Removed util_desktop_windows, macos and linux files from database CMakeLists. This implentation had been migrated to firebase/app.
  - Added play-services-base dependency to google_api_resources gradle file.
  - Added new lines to the ends of numerous build.gradle files.

PiperOrigin-RevId: 348119031

* Internal change.

PiperOrigin-RevId: 348605790

* Using the recommended backwards compatible way of scheduling jobs introduced in Android O.

We moved from using `IntentService` to `JobIntentService` in preparation for this change but the call to schedule jobs remained the same which meant that our custom IntentService was not doing any work at all.

Using `JobIntentService.enqueueWork`, when running on Android O or later, the work will be dispatched as a job via JobScheduler.enqueue. When running on older versions of the platform, it will use Context.startService.
https://developer.android.com/reference/androidx/core/app/JobIntentService

Fixes
https://github.com/firebase/quickstart-unity/issues/877
https://github.com/firebase/quickstart-unity/issues/883

PiperOrigin-RevId: 350176964

* Process the current run loop while sleeping in tests.

This will allow any callbacks scheduled on the main queue from APIs like
FIRAuth to be processed while we wait.

PiperOrigin-RevId: 351726805

* Add a function registry entry for the current user uid

Firestore partitions local data by uid, so this is required to make Auth a soft
dependency of Firestore.

PiperOrigin-RevId: 351731118

* Add JNI wrapper for the GMS `Task` class and modify the Firestore Android C++ SDK implementation to use it.

This change has two benefits: It improves readability of the code because variables will be defined as `Local<Task>` instead of `Local<Object>` and also improves type safety because it is no longer possible to specify any object when a `Task` is specifically required.

The motivation for this change also includes future unit tests which will interact with `Task` objects directly, instead of encapsulating them in `Promise` objects.

As part of this change, I also created a new `FirestoreAndroidIntegrationTest` class, which extends `FirestoreIntegrationTest` and adds Android-specific functionality. I modified the existing `PromiseTest` to use it, and the new `TaskTest` that was added uses it as well.

PiperOrigin-RevId: 351816780

* Add function registry entries for AuthStateListeners

PiperOrigin-RevId: 351835389

* Rework firebase_metadata_provider to use an alias

PiperOrigin-RevId: 351843753

* Add a `JavaEq` matcher.

This "matcher" can be used in the tests for the C++ SDK for Android to compare two Java objects for equality using their Java `.equals()` method, while producing a message that includes the object's `.toString()` return value in a failure message.

PiperOrigin-RevId: 352444881

* [RemoteConfig V2] Desktop impl

+ Move the endpoint from RC V1 to RC V2
+ Change the rest call by using nanopb to using json
+ fill in the majority of the desktop impl of V2 apis

PiperOrigin-RevId: 352611740

* Use the Objective-C CredentialsProvider on iOS

Previously, we used the C++ CredentialsProvider on all non-Android platforms.
This works because Firebase Auth's C++ interface is portable.

While switching to use Auth via the FunctionRegistry mechanism (to make Auth a
soft dependency of Firestore), it's become clear that the FunctionRegistry
mechanism is only available on desktop platforms. This means we can't use C++
Auth on iOS.

PiperOrigin-RevId: 353057413

* Use the function registry for Auth calls

This makes Firebase Auth functionally a soft dependency of Firestore, but does
not include the BUILD changes required to affect that.

PiperOrigin-RevId: 353905031

* Update gms_package_versions_generated.bzl by running get_gms_package_versions.py.

This fixes Java "one definition violations" such as http://sponge2/3397376c-55b7-4dc9-9937-7cf2e705802f (failed) that occur when building the Firestore Android test apps via Tricorder Builder.

PiperOrigin-RevId: 353906782

* Internal change.

PiperOrigin-RevId: 354045473

* Internal change.

PiperOrigin-RevId: 354146761

* [RemoteConfig V2]Impl SetConfigSettings in iOS/Android/Desktop

PiperOrigin-RevId: 354383822

* [RemoteConfig V2]Clean up legacy code

PiperOrigin-RevId: 354426487

* Port exception-throwing abstractions from iOS to common

Unfortunately, because we still support STLPort on Android, this requires
special casing there. On desktop platforms this delegates back to the iOS core.

This includes a change to the iOS firestore_exceptions.h which needs to be
ported to GitHub before the next import. It seems as if policy checks in Abseil
fail on Android even when compiling against non-STLPort C++ runtimes.

PiperOrigin-RevId: 354562822

* Enable testing with exceptions for all C++ platforms

PiperOrigin-RevId: 354570506

* Build changes to make validation_test work everywhere

Build validation_test on non-Android platforms without enabling any specific
tests.

PiperOrigin-RevId: 354589703

* Make field_path_portable_test work on Android

Also, remove server-format parsing from this implementation. FieldPathPortable
can only ever take values from users.

PiperOrigin-RevId: 354602321

* Remote old Database REST interface, no longer used.

PiperOrigin-RevId: 355014438

* Deprecating old RemoteConfig API functions with suggestions to use equivalent methods from the new API.

Some questions and observations,
- `Initialize` and `Terminate` are handled by object oriented calls.
- `GetConfigSetting` and `SetConfigSetting` are now `GetConfigSettings` and `SetConfigSettings`
- It is recommended to use `Activate` in new API instead of `ActivateFetched`.
- Return type of `GetInfo` is now `const ConfigInfo` instead of `const ConfigInfo&`.

PiperOrigin-RevId: 355078804

* Fix the crash(es) that occur when deleting Firestore from a `Future` callback.

There are two related crashes:
- one happens in any `Future` because deleting Firestore deletes the underlying `FutureManager`, which in turn force-deletes all backings. Deleting a backing while it's running a callback results in a use-after-free/segmentation fault;
- one only happens when the `Future` is issued by a `Transaction` and is `firestore::Promise`-specific -- it happens because there is a data race between the destructor of `Promise` and the cleanup thread.

The problem with `FutureManager` is solved by making it mark the backings that are running callbacks for self-deletion rather than deleting them straight away. The problem with `Promise` is solved by adding a mutex to it.

The test added to `FutureManager` crashes on HEAD with:
```
*** SIGSEGV (@0x10), see go/stacktraces#s15 received by PID 2522 (TID 2522) on cpu 27; stack trace: ***
PC: @     0x7f11692ed65b  (unknown)  firebase::ReferenceCountedFutureImpl::ReleaseMutexAndRunCallbacks()
    @     0x7f114b9d89b1       1328  FailureSignalHandler()
    @     0x7f119f8b89a0  1877003968  (unknown)
    @     0x7f11a9b64c7d         80  firebase::ReferenceCountedFutureImpl::CompleteInternal<>()
    @     0x7f11a9b64b7c         64  firebase::ReferenceCountedFutureImpl::CompleteWithResultInternal<>()
    @     0x7f11a9b5f0e6         64  firebase::ReferenceCountedFutureImpl::CompleteWithResult<>()
    @     0x7f11a9b5b689        224  firebase::detail::testing::FutureManagerTest_Repro_Test::TestBody()
```
(see https://sponge.corp.google.com/target?id=94cc7972-73aa-4651-b0fb-0306fcd90161&target=%2F%2Ffirebase%2Fapp%2Fclient%2Fcpp%3Afuture_manager_test&searchFor=user%3Avarconst)

Same crash with Address Sanitizer enabled:
```
==8335==ERROR: AddressSanitizer: heap-use-after-free on address 0x612000006d68 at pc 0x7f29b654a6f8 bp 0x7fff3407ccb0 sp 0x7fff3407cca8
WRITE of size 1 at 0x612000006d68 thread T0
    #0 0x7f29b654a6f7 in firebase::ReferenceCountedFutureImpl::RunCallback(firebase::FutureBase*, void (*)(firebase::FutureBase const&, void*), void*) firebase/app/client/cpp/src/reference_counted_future_impl.cc:466:24
    #1 0x7f29b654a42e in firebase::ReferenceCountedFutureImpl::ReleaseMutexAndRunCallbacks(firebase::FutureHandle const&) firebase/app/client/cpp/src/reference_counted_future_impl.cc:433:7
    #2 0x7f29f936d999 in void firebase::ReferenceCountedFutureImpl::CompleteInternal<int, void firebase::ReferenceCountedFutureImpl::CompleteWithResultInternal<int>(firebase::FutureHandle const&, int, char const*, int const&)::'lambda'(int*)>(firebase::FutureHandle const&, int, char const*, void firebase::ReferenceCountedFutureImpl::CompleteWithResultInternal<int>(firebase::FutureHandle const&, int, char const*, int const&)::'lambda'(int*) const&) firebase/app/client/cpp/src/reference_counted_future_impl.h:521:5
    #3 0x7f29f936d81b in void firebase::ReferenceCountedFutureImpl::CompleteWithResultInternal<int>(firebase::FutureHandle const&, int, char const*, int const&) firebase/app/client/cpp/src/reference_counted_future_impl.h:528:5
    #4 0x7f29f936382c in void firebase::ReferenceCountedFutureImpl::CompleteWithResult<int>(firebase::SafeFutureHandle<int>, int, char const*, int const&) firebase/app/client/cpp/src/reference_counted_future_impl.h:302:5
    #5 0x7f29f935cd64 in firebase::detail::testing::FutureManagerTest_Repro_Test::TestBody() firebase/app/client/cpp/tests/future_manager_test.cc:66:16

0x612000006d68 is located 296 bytes inside of 304-byte region [0x612000006c40,0x612000006d70)
freed by thread T0 here:
    #0 0x56101d3c75c2 in operator delete(void*, unsigned long) third_party/llvm/llvm-project/compiler-rt/lib/asan/asan_new_delete.cpp:172:3
    #1 0x7f29b65497af in firebase::ReferenceCountedFutureImpl::~ReferenceCountedFutureImpl() firebase/app/client/cpp/src/reference_counted_future_impl.cc:335:59
    #2 0x7f29b653ad57 in firebase::FutureManager::CleanupOrphanedFutureApis(bool) firebase/app/client/cpp/src/future_manager.cc:117:14
    #3 0x7f29b653a91b in firebase::FutureManager::~FutureManager() firebase/app/client/cpp/src/future_manager.cc:34:3
    #4 0x7f29f936d655 in firebase::UniquePtr<firebase::FutureManager>::reset(firebase::FutureManager*) firebase/app/client/cpp/memory/unique_ptr.h:83:5
    #5 0x7f29f936d592 in firebase::UniquePtr<firebase::FutureManager>::operator=(firebase::FutureManager*) firebase/app/client/cpp/memory/unique_ptr.h:70:5
    #6 0x7f29f936144c in firebase::detail::testing::FutureManagerTest_Repro_Test::TestBody()::$_0::operator()(firebase::Future<int> const&) const firebase/app/client/cpp/tests/future_manager_test.cc:63:20
```
(see https://sponge.corp.google.com/target?id=c1c85581-7522-4ff0-b434-9f82de575c9c&target=%2F%2Ffirebase%2Fapp%2Fclient%2Fcpp%3Afuture_manager_test&searchFor=user%3Avarconst)

PiperOrigin-RevId: 355305313

* Reflect changes made to our Open Source repo in order to fix build errors in release version 7.0.0.  Reflecting the work made in the repo so that we don't export the problematic files again.

Fixes include:
  - Using std::mutex in app/heartbeat_date_storage_desktop.  Replaced its use with our own internal implementation of Mutex.
  - ios_pod CmakeList updated with sunmou@'s changes to fallback to the xcframework path for header resolution.
  - Updating main podfile to the new minimum supported iOS version of 10.0.
  - Added heartbeat_date_storage_desktop to app's cmakefile on Desktop and iOS.
  - Removed firebase_firestore_settings_ios files from firestore's cmake file.
  - Removed util_desktop_windows, macos and linux files from database CMakeLists. This implentation had been migrated to firebase/app.
  - Added play-services-base dependency to google_api_resources gradle file.
  - Added new lines to the ends of numerous build.gradle files.

PiperOrigin-RevId: 348119031

* Applied google3-readability-pass-trivial-by-value ClangTidy fixes to all of google3.

http://g3doc/devtools/cymbal/clang_tidy/g3doc/checks/google3-readability-pass-trivial-by-value

This check finds function signatures that pass trivial types by `const Type&`.
It is simpler and more efficient to pass these types by value.

The changelist was automatically generated using the apply_fixes.sh script:
  ./devtools/cymbal/clang_tidy/apply_fixes.sh --checks=-*,google3-readability-pass-trivial-by-value

WARNING: Automatically generated changes should be carefully inspected. For most
ClangTidy warnings multiple alternative fixes are possible and only one of them
is suggested. There's no guarantee that it will be the best one (or even a right
fix). The amount of reviewers' attention to automated changes should be at least
the same as for manually written code.

Tested:
    TAP --sample ran all affected tests and none failed
    http://test/OCL:347842546:BASE:347811712:1608141504976:7eb78f31
PiperOrigin-RevId: 348605790

* Using the recommended backwards compatible way of scheduling jobs introduced in Android O.

We moved from using `IntentService` to `JobIntentService` in preparation for this change but the call to schedule jobs remained the same which meant that our custom IntentService was not doing any work at all.

Using `JobIntentService.enqueueWork`, when running on Android O or later, the work will be dispatched as a job via JobSchedule…

Author: 11 people

.github/workflows/integration_tests.yml

@@ -141,6 +141,8 @@ jobs:
             startsWith(matrix.os, 'macos')
         run: |
           brew install openssl
+          # brew won't overwrite MacOS system default OpenSSL, so force it here.
+          echo "OPENSSL_ROOT_DIR=/usr/local/opt/[email protected]" >> $GITHUB_ENV
 
       - name: Install OpenSSL (Linux)
         if: matrix.target_platform == 'Desktop' &&

Android/firebase_dependencies.gradle

@@ -16,29 +16,30 @@ import org.gradle.util.ConfigureUtil;
 
 // A map of library to the dependencies that need to be added for it.
 def firebaseDependenciesMap = [
-  'app' : ['com.google.firebase:firebase-analytics:18.0.0'],
-  'admob' : ['com.google.firebase:firebase-ads:19.5.0',
-             'com.google.android.gms:play-services-measurement-sdk-api:18.0.0',
-             'com.google.android.gms:play-services-base:17.5.0'],
-  'analytics' : ['com.google.firebase:firebase-analytics:18.0.0',
-                 'com.google.android.gms:play-services-base:17.5.0'],
-  'auth' : ['com.google.firebase:firebase-auth:20.0.0'],
-  'database' : ['com.google.firebase:firebase-database:19.5.1'],
+  'app' : ['com.google.firebase:firebase-analytics:18.0.2'],
+  'admob' : ['com.google.firebase:firebase-ads:19.7.0',
+             'com.google.android.gms:play-services-measurement-sdk-api:18.0.2',
+             'com.google.android.gms:play-services-base:17.6.0'],
+  'analytics' : ['com.google.firebase:firebase-analytics:18.0.2',
+                 'com.google.android.gms:play-services-base:17.6.0'],
+  'auth' : ['com.google.firebase:firebase-auth:20.0.2'],
+  'database' : ['com.google.firebase:firebase-database:19.6.0'],
   'dynamic_links' : ['com.google.firebase:firebase-dynamic-links:19.1.1'],
-  'firestore' : ['com.google.firebase:firebase-firestore:22.0.0'],
-  'functions' : ['com.google.firebase:firebase-functions:19.1.0'],
-  'installations' : ['com.google.firebase:firebase-installations:16.3.3',
-                     'com.google.android.gms:play-services-base:17.4.0'],
-  'instance_id' : ['com.google.firebase:firebase-iid:21.0.0'],
+  'firestore' : ['com.google.firebase:firebase-firestore:22.0.2'],
+  'functions' : ['com.google.firebase:firebase-functions:19.2.0'],
+  'installations' : ['com.google.firebase:firebase-installations:16.3.5',
+                     'com.google.android.gms:play-services-base:17.6.0'],
+  'instance_id' : ['com.google.firebase:firebase-iid:21.0.1'],
   'invites' : ['com.google.firebase:firebase-invites:17.0.0'],
   // Messaging has an additional local dependency to include.
-  'messaging' : ['com.google.firebase:firebase-messaging:21.0.0',
+  'messaging' : ['com.google.firebase:firebase-messaging:21.0.1',
                  'firebase_cpp_sdk.messaging:messaging_java',
-                 'androidx.core:core:1.0.1'],
-  'performance' : ['com.google.firebase:firebase-perf:19.0.9'],
-  'remote_config' : ['com.google.firebase:firebase-config:20.0.0',
-                     'com.google.android.gms:play-services-base:17.5.0'],
-  'storage' : ['com.google.firebase:firebase-storage:19.2.0']
+                 'androidx.core:core:1.0.1',
+                 'com.google.flatbuffers:flatbuffers-java:1.9.0'],
+  'performance' : ['com.google.firebase:firebase-perf:19.1.0'],
+  'remote_config' : ['com.google.firebase:firebase-config:20.0.3',
+                     'com.google.android.gms:play-services-base:17.6.0'],
+  'storage' : ['com.google.firebase:firebase-storage:19.2.1']
 ]
 
 // A map of library to the gradle resources that they depend upon.

admob/admob_resources/build.gradle

@@ -18,7 +18,7 @@ buildscript {
     jcenter()
   }
   dependencies {
-    classpath 'com.android.tools.build:gradle:3.2.1'
+    classpath 'com.android.tools.build:gradle:3.3.3'
     classpath 'com.google.gms:google-services:4.2.0'
   }
 }
@@ -45,13 +45,13 @@ android {
 }
 
 dependencies {
-  implementation 'com.google.firebase:firebase-analytics:18.0.0'
-  implementation 'com.google.firebase:firebase-ads:19.5.0'
+  implementation 'com.google.firebase:firebase-analytics:18.0.2'
+  implementation 'com.google.firebase:firebase-ads:19.7.0'
 }
 
 afterEvaluate {
   generateReleaseBuildConfig.enabled = false
 }
 
 apply from: "$rootDir/android_build_files/extract_and_dex.gradle"
-extractAndDexAarFile('admob_resources')
+extractAndDexAarFile('admob_resources')

admob/build.gradle

@@ -18,7 +18,7 @@ buildscript {
     jcenter()
   }
   dependencies {
-    classpath 'com.android.tools.build:gradle:3.2.1'
+    classpath 'com.android.tools.build:gradle:3.3.3'
   }
 }
 allprojects {

admob/integration_test/Podfile

@@ -4,7 +4,7 @@ platform :ios, '10.0'
 # Firebase AdMob test application.
 
 target 'integration_test' do
-  pod 'Firebase/AdMob', '7.0.0'
+  pod 'Firebase/AdMob', '7.5.0'
 end
 
 post_install do |installer|

admob/integration_test/build.gradle

@@ -20,7 +20,7 @@ buildscript {
     jcenter()
   }
   dependencies {
-    classpath 'com.android.tools.build:gradle:3.2.1'
+    classpath 'com.android.tools.build:gradle:3.3.3'
     classpath 'com.google.gms:google-services:4.0.1'
   }
 }

admob/integration_test/gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.1-all.zip

analytics/build.gradle

@@ -18,7 +18,7 @@ buildscript {
     jcenter()
   }
   dependencies {
-    classpath 'com.android.tools.build:gradle:3.2.1'
+    classpath 'com.android.tools.build:gradle:3.3.3'
   }
 }
 allprojects {

analytics/integration_test/Podfile

@@ -4,7 +4,7 @@ platform :ios, '10.0'
 # Firebase Analytics test application.
 
 target 'integration_test' do
-  pod 'Firebase/Analytics', '7.0.0'
+  pod 'Firebase/Analytics', '7.5.0'
 end
 
 post_install do |installer|

analytics/integration_test/build.gradle

@@ -20,7 +20,7 @@ buildscript {
     jcenter()
   }
   dependencies {
-    classpath 'com.android.tools.build:gradle:3.2.1'
+    classpath 'com.android.tools.build:gradle:3.3.3'
     classpath 'com.google.gms:google-services:4.0.1'
   }
 }