Port subset of Mutations (#2257)

* Add stubs for missing tests in model/mutation_test.cc
* Port SetMutation::ApplyToRemoteDocument()
  Also involves porting MutationResult.
* Port PatchMutation::ApplyToRemoteDocument()
* Port DeleteMutation::ApplyToLocalView()
* Add MaybeDocumentPtr alias

This is to enable porting of the local serializer.

Author: rsgowman

Firestore/core/src/firebase/firestore/model/mutation.cc

@@ -16,10 +16,12 @@
 
 #include "Firestore/core/src/firebase/firestore/model/mutation.h"
 
+#include <cstdlib>
 #include <utility>
 
 #include "Firestore/core/src/firebase/firestore/model/document.h"
 #include "Firestore/core/src/firebase/firestore/model/field_path.h"
+#include "Firestore/core/src/firebase/firestore/model/no_document.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 
 namespace firebase {
@@ -53,8 +55,24 @@ SetMutation::SetMutation(DocumentKey&& key,
       value_(std::move(value)) {
 }
 
-std::shared_ptr<const MaybeDocument> SetMutation::ApplyToLocalView(
-    const std::shared_ptr<const MaybeDocument>& maybe_doc,
+MaybeDocumentPtr SetMutation::ApplyToRemoteDocument(
+    const MaybeDocumentPtr& maybe_doc,
+    const MutationResult& mutation_result) const {
+  VerifyKeyMatches(maybe_doc.get());
+
+  HARD_ASSERT(mutation_result.transform_results() == nullptr,
+              "Transform results received by SetMutation.");
+
+  // Unlike applyToLocalView, if we're applying a mutation to a remote document
+  // the server has accepted the mutation so the precondition must have held.
+
+  const SnapshotVersion& version = mutation_result.version();
+  return absl::make_unique<Document>(FieldValue(value_), key(), version,
+                                     DocumentState::kCommittedMutations);
+}
+
+MaybeDocumentPtr SetMutation::ApplyToLocalView(
+    const MaybeDocumentPtr& maybe_doc,
     const MaybeDocument*,
     const Timestamp&) const {
   VerifyKeyMatches(maybe_doc.get());
@@ -77,8 +95,35 @@ PatchMutation::PatchMutation(DocumentKey&& key,
       mask_(std::move(mask)) {
 }
 
-std::shared_ptr<const MaybeDocument> PatchMutation::ApplyToLocalView(
-    const std::shared_ptr<const MaybeDocument>& maybe_doc,
+MaybeDocumentPtr PatchMutation::ApplyToRemoteDocument(
+    const MaybeDocumentPtr& maybe_doc,
+    const MutationResult& mutation_result) const {
+  VerifyKeyMatches(maybe_doc.get());
+  HARD_ASSERT(mutation_result.transform_results() == nullptr,
+              "Transform results received by PatchMutation.");
+
+  if (!precondition().IsValidFor(maybe_doc.get())) {
+    // Since the mutation was not rejected, we know that the precondition
+    // matched on the backend. We therefore must not have the expected version
+    // of the document in our cache and return an UnknownDocument with the known
+    // updateTime.
+
+    // TODO(rsgowman): heldwriteacks: Implement. Like this (once UnknownDocument
+    // is ported):
+    // return absl::make_unique<UnknownDocument>(key(),
+    // mutation_result.version());
+
+    abort();
+  }
+
+  const SnapshotVersion& version = mutation_result.version();
+  FieldValue new_data = PatchDocument(maybe_doc.get());
+  return absl::make_unique<Document>(std::move(new_data), key(), version,
+                                     DocumentState::kCommittedMutations);
+}
+
+MaybeDocumentPtr PatchMutation::ApplyToLocalView(
+    const MaybeDocumentPtr& maybe_doc,
     const MaybeDocument*,
     const Timestamp&) const {
   VerifyKeyMatches(maybe_doc.get());
@@ -116,6 +161,31 @@ FieldValue PatchMutation::PatchObject(FieldValue obj) const {
   return obj;
 }
 
+DeleteMutation::DeleteMutation(DocumentKey&& key, Precondition&& precondition)
+    : Mutation(std::move(key), std::move(precondition)) {
+}
+
+MaybeDocumentPtr DeleteMutation::ApplyToRemoteDocument(
+    const MaybeDocumentPtr& /*maybe_doc*/,
+    const MutationResult& /*mutation_result*/) const {
+  // TODO(rsgowman): Implement.
+  abort();
+}
+
+MaybeDocumentPtr DeleteMutation::ApplyToLocalView(
+    const MaybeDocumentPtr& maybe_doc,
+    const MaybeDocument*,
+    const Timestamp&) const {
+  VerifyKeyMatches(maybe_doc.get());
+
+  if (!precondition().IsValidFor(maybe_doc.get())) {
+    return maybe_doc;
+  }
+
+  return absl::make_unique<NoDocument>(key(), SnapshotVersion::None(),
+                                       /*hasCommittedMutations=*/false);
+}
+
 }  // namespace model
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/src/firebase/firestore/model/mutation.h

@@ -18,6 +18,8 @@
 #define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_MUTATION_H_
 
 #include <memory>
+#include <utility>
+#include <vector>
 
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
 #include "Firestore/core/src/firebase/firestore/model/field_mask.h"
@@ -30,6 +32,56 @@ namespace firebase {
 namespace firestore {
 namespace model {
 
+using MaybeDocumentPtr = std::shared_ptr<const MaybeDocument>;
+
+/**
+ * The result of applying a mutation to the server. This is a model of the
+ * WriteResult proto message.
+ *
+ * Note that MutationResult does not name which document was mutated. The
+ * association is implied positionally: for each entry in the array of
+ * Mutations, there's a corresponding entry in the array of MutationResults.
+ */
+class MutationResult {
+ public:
+  MutationResult(
+      SnapshotVersion&& version,
+      const std::shared_ptr<const std::vector<FieldValue>>& transform_results)
+      : version_(std::move(version)),
+        transform_results_(std::move(transform_results)) {
+  }
+
+  /**
+   * The version at which the mutation was committed.
+   *
+   * - For most operations, this is the update_time in the WriteResult.
+   * - For deletes, it is the commit_time of the WriteResponse (because
+   *   deletes are not stored and have no update_time).
+   *
+   * Note that these versions can be different: No-op writes will not change
+   * the update_time even though the commit_time advances.
+   */
+  const SnapshotVersion& version() const {
+    return version_;
+  }
+
+  /**
+   * The resulting fields returned from the backend after a TransformMutation
+   * has been committed.  Contains one FieldValue for each FieldTransform
+   * that was in the mutation.
+   *
+   * Will be null if the mutation was not a TransformMutation.
+   */
+  const std::shared_ptr<const std::vector<FieldValue>>& transform_results()
+      const {
+    return transform_results_;
+  }
+
+ private:
+  const SnapshotVersion version_;
+  const std::shared_ptr<const std::vector<FieldValue>> transform_results_;
+};
+
 /**
  * Represents a Mutation of a document. Different subclasses of Mutation will
  * perform different kinds of changes to a base document. For example, a
@@ -85,7 +137,24 @@ class Mutation {
     return precondition_;
   }
 
-  // TODO(rsgowman): ApplyToRemoteDocument()
+  /**
+   * Applies this mutation to the given MaybeDocument for the purposes of
+   * computing a new remote document. If the input document doesn't match the
+   * expected state (e.g. it is null or outdated), an `UnknownDocument` can be
+   * returned.
+   *
+   * @param maybe_doc The document to mutate. The input document can be nullptr
+   *     if the client has no knowledge of the pre-mutation state of the
+   *     document.
+   * @param mutation_result The result of applying the mutation from the
+   *     backend.
+   * @return The mutated document. The returned document may be an
+   *     UnknownDocument if the mutation could not be applied to the locally
+   *     cached base document.
+   */
+  virtual MaybeDocumentPtr ApplyToRemoteDocument(
+      const MaybeDocumentPtr& maybe_doc,
+      const MutationResult& mutation_result) const = 0;
 
   /**
    * Applies this mutation to the given MaybeDocument for the purposes of
@@ -104,8 +173,8 @@ class Mutation {
    *     only if maybe_doc was nullptr and the mutation would not create a new
    *     document.
    */
-  virtual std::shared_ptr<const MaybeDocument> ApplyToLocalView(
-      const std::shared_ptr<const MaybeDocument>& maybe_doc,
+  virtual MaybeDocumentPtr ApplyToLocalView(
+      const MaybeDocumentPtr& maybe_doc,
       const MaybeDocument* base_doc,
       const Timestamp& local_write_time) const = 0;
 
@@ -131,10 +200,12 @@ class SetMutation : public Mutation {
               FieldValue&& value,
               Precondition&& precondition);
 
-  // TODO(rsgowman): ApplyToRemoteDocument()
+  MaybeDocumentPtr ApplyToRemoteDocument(
+      const MaybeDocumentPtr& maybe_doc,
+      const MutationResult& mutation_result) const override;
 
-  std::shared_ptr<const MaybeDocument> ApplyToLocalView(
-      const std::shared_ptr<const MaybeDocument>& maybe_doc,
+  MaybeDocumentPtr ApplyToLocalView(
+      const MaybeDocumentPtr& maybe_doc,
       const MaybeDocument* base_doc,
       const Timestamp& local_write_time) const override;
 
@@ -162,10 +233,12 @@ class PatchMutation : public Mutation {
                 FieldMask&& mask,
                 Precondition&& precondition);
 
-  // TODO(rsgowman): ApplyToRemoteDocument()
+  MaybeDocumentPtr ApplyToRemoteDocument(
+      const MaybeDocumentPtr& maybe_doc,
+      const MutationResult& mutation_result) const override;
 
-  std::shared_ptr<const MaybeDocument> ApplyToLocalView(
-      const std::shared_ptr<const MaybeDocument>& maybe_doc,
+  MaybeDocumentPtr ApplyToLocalView(
+      const MaybeDocumentPtr& maybe_doc,
       const MaybeDocument* base_doc,
       const Timestamp& local_write_time) const override;
 
@@ -177,6 +250,21 @@ class PatchMutation : public Mutation {
   const FieldMask mask_;
 };
 
+/** Represents a Delete operation. */
+class DeleteMutation : public Mutation {
+ public:
+  DeleteMutation(DocumentKey&& key, Precondition&& precondition);
+
+  MaybeDocumentPtr ApplyToRemoteDocument(
+      const MaybeDocumentPtr& maybe_doc,
+      const MutationResult& mutation_result) const override;
+
+  MaybeDocumentPtr ApplyToLocalView(
+      const MaybeDocumentPtr& maybe_doc,
+      const MaybeDocument* base_doc,
+      const Timestamp& local_write_time) const override;
+};
+
 }  // namespace model
 }  // namespace firestore
 }  // namespace firebase