Make sure every member of Error enum has the kError prefix (#5546)

This is for consistency with other Firebase C++ SDKs (e.g. [RTDB](https://github.com/firebase/firebase-cpp-sdk/blob/d0fc238bb866c92ed4241b55ddd82c8cf87867cd/database/src/include/firebase/database/common.h#L24-L60)).

Author: var-const

Firestore/core/include/firebase/firestore/firestore_errors.h

@@ -28,21 +28,21 @@ namespace firestore {
 enum Error {
   /** The operation completed successfully. */
   // Note: NSError objects will never have a code with this value.
-  kOk = 0,
+  kErrorOk = 0,
 
   /** The operation was cancelled (typically by the caller). */
-  kCancelled = 1,
+  kErrorCancelled = 1,
 
   /** Unknown error or an error from a different error domain. */
-  kUnknown = 2,
+  kErrorUnknown = 2,
 
   /**
    * Client specified an invalid argument. Note that this differs from
    * FailedPrecondition. InvalidArgument indicates arguments that are
    * problematic regardless of the state of the system (e.g., an invalid field
    * name).
    */
-  kInvalidArgument = 3,
+  kErrorInvalidArgument = 3,
 
   /**
    * Deadline expired before operation could complete. For operations that
@@ -51,61 +51,61 @@ enum Error {
    * from a server could have been delayed long enough for the deadline to
    * expire.
    */
-  kDeadlineExceeded = 4,
+  kErrorDeadlineExceeded = 4,
 
   /** Some requested document was not found. */
-  kNotFound = 5,
+  kErrorNotFound = 5,
 
   /** Some document that we attempted to create already exists. */
-  kAlreadyExists = 6,
+  kErrorAlreadyExists = 6,
 
   /** The caller does not have permission to execute the specified operation. */
-  kPermissionDenied = 7,
+  kErrorPermissionDenied = 7,
 
   /**
    * Some resource has been exhausted, perhaps a per-user quota, or perhaps the
    * entire file system is out of space.
    */
-  kResourceExhausted = 8,
+  kErrorResourceExhausted = 8,
 
   /**
    * Operation was rejected because the system is not in a state required for
    * the operation's execution.
    */
-  kFailedPrecondition = 9,
+  kErrorFailedPrecondition = 9,
 
   /**
    * The operation was aborted, typically due to a concurrency issue like
    * transaction aborts, etc.
    */
-  kAborted = 10,
+  kErrorAborted = 10,
 
   /** Operation was attempted past the valid range. */
-  kOutOfRange = 11,
+  kErrorOutOfRange = 11,
 
   /** Operation is not implemented or not supported/enabled. */
-  kUnimplemented = 12,
+  kErrorUnimplemented = 12,
 
   /**
    * Internal errors. Means some invariants expected by underlying system has
    * been broken. If you see one of these errors, something is very broken.
    */
-  kInternal = 13,
+  kErrorInternal = 13,
 
   /**
    * The service is currently unavailable. This is a most likely a transient
    * condition and may be corrected by retrying with a backoff.
    */
-  kUnavailable = 14,
+  kErrorUnavailable = 14,
 
   /** Unrecoverable data loss or corruption. */
-  kDataLoss = 15,
+  kErrorDataLoss = 15,
 
   /**
    * The request does not have valid authentication credentials for the
    * operation.
    */
-  kUnauthenticated = 16
+  kErrorUnauthenticated = 16
 };
 
 }  // namespace firestore

Firestore/core/src/api/document_reference.cc

@@ -153,12 +153,12 @@ void DocumentReference::GetDocument(Source source,
         // 2) Actually call the callback with an error if the
         // document doesn't exist when you are offline.
         listener_->OnEvent(
-            Status{Error::kUnavailable,
+            Status{Error::kErrorUnavailable,
                    "Failed to get document because the client is offline."});
       } else if (snapshot.exists() && snapshot.metadata().from_cache() &&
                  source_ == Source::Server) {
         listener_->OnEvent(
-            Status{Error::kUnavailable,
+            Status{Error::kErrorUnavailable,
                    "Failed to get document from server. (However, "
                    "this document does exist in the local cache. Run "
                    "again without setting source to "

Firestore/core/src/api/firestore.cc

@@ -167,7 +167,7 @@ void Firestore::ClearPersistence(util::StatusCallback callback) {
       std::lock_guard<std::mutex> lock{mutex_};
       if (client_ && !client()->is_terminated()) {
         Yield(util::Status(
-            Error::kFailedPrecondition,
+            Error::kErrorFailedPrecondition,
             "Persistence cannot be cleared while the client is running."));
         return;
       }

Firestore/core/src/api/query_core.cc

@@ -109,7 +109,7 @@ void Query::GetDocuments(Source source, QuerySnapshotListener&& callback) {
 
       if (snapshot.metadata().from_cache() && source_ == Source::Server) {
         listener_->OnEvent(Status{
-            Error::kUnavailable,
+            Error::kErrorUnavailable,
             "Failed to get documents from server. (However, these documents "
             "may exist in the local cache. Run again without setting source to "
             "FirestoreSourceServer to retrieve the cached documents.)"});

Firestore/core/src/auth/firebase_credentials_provider_apple.mm

@@ -97,7 +97,7 @@
       // Cancel the request since the user changed while the request was
       // outstanding so the response is likely for a previous user (which
       // user, we can't be sure).
-      completion(util::Status(Error::kAborted,
+      completion(util::Status(Error::kErrorAborted,
                               "GetToken aborted due to token change."));
     } else {
       if (error == nil) {
@@ -107,7 +107,7 @@
           completion(Token::Unauthenticated());
         }
       } else {
-        Error error_code = Error::kUnknown;
+        Error error_code = Error::kErrorUnknown;
         if (error.domain == FIRFirestoreErrorDomain) {
           error_code = static_cast<Error>(error.code);
         }

Firestore/core/src/core/firestore_client.cc

@@ -382,7 +382,7 @@ void FirestoreClient::GetDocumentFromLocalCache(
                            /*from_cache=*/true});
     } else {
       maybe_snapshot =
-          Status{Error::kUnavailable,
+          Status{Error::kErrorUnavailable,
                  "Failed to get document from cache. (However, this document "
                  "may exist on the server. Run again without setting source to "
                  "FirestoreSourceCache to attempt to retrieve the document "};

Firestore/core/src/core/sync_engine.cc

@@ -72,9 +72,9 @@ const ListenSequenceNumber kIrrelevantSequenceNumber = -1;
 
 bool ErrorIsInteresting(const Status& error) {
   bool missing_index =
-      (error.code() == Error::kFailedPrecondition &&
+      (error.code() == Error::kErrorFailedPrecondition &&
        error.error_message().find("requires an index") != std::string::npos);
-  bool no_permission = (error.code() == Error::kPermissionDenied);
+  bool no_permission = (error.code() == Error::kErrorPermissionDenied);
   return missing_index || no_permission;
 }
 
@@ -448,7 +448,7 @@ void SyncEngine::FailOutstandingPendingWriteCallbacks(
     const std::string& message) {
   for (const auto& entry : pending_writes_callbacks_) {
     for (const auto& callback : entry.second) {
-      callback(Status(Error::kCancelled, message));
+      callback(Status(Error::kErrorCancelled, message));
     }
   }
 

Firestore/core/src/core/transaction.cc

@@ -67,7 +67,7 @@ Status Transaction::RecordVersion(const MaybeDocument& doc) {
   if (existing_version.has_value()) {
     if (doc_version != existing_version.value()) {
       // This transaction will fail no matter what.
-      return Status{Error::kAborted,
+      return Status{Error::kErrorAborted,
                     "Document version changed between two reads."};
     }
     return Status::OK();
@@ -82,7 +82,7 @@ void Transaction::Lookup(const std::vector<DocumentKey>& keys,
   EnsureCommitNotCalled();
 
   if (!mutations_.empty()) {
-    Status lookup_error = Status{Error::kInvalidArgument,
+    Status lookup_error = Status{Error::kErrorInvalidArgument,
                                  "Firestore transactions require all reads to "
                                  "be executed before all writes"};
     callback(lookup_error);
@@ -146,7 +146,7 @@ StatusOr<Precondition> Transaction::CreateUpdatePrecondition(
       //
       // Note: this can change once we can send separate verify writes in the
       // transaction.
-      return Status{Error::kInvalidArgument,
+      return Status{Error::kErrorInvalidArgument,
                     "Can't update a document that doesn't exist."};
     }
     // Document exists, just base precondition on document update time.

Firestore/core/src/core/transaction_runner.cc

@@ -39,7 +39,8 @@ bool IsRetryableTransactionError(const util::Status& error) {
   // FAILED_PRECONDITION and non-matching document versions with ABORTED. These
   // errors should be retried.
   Error code = error.code();
-  return code == Error::kAborted || code == Error::kFailedPrecondition ||
+  return code == Error::kErrorAborted ||
+         code == Error::kErrorFailedPrecondition ||
          !remote::Datastore::IsPermanentError(error);
 }
 }  // namespace

Firestore/core/src/local/leveldb_mutation_queue.cc

@@ -474,7 +474,7 @@ Message<firestore_client_MutationQueue> LevelDbMutationQueue::MetadataForKey(
 
   if (reader.ok()) {
     return result;
-  } else if (reader.status().code() == Error::kNotFound) {
+  } else if (reader.status().code() == Error::kErrorNotFound) {
     // Return a default-constructed message (`TryParse` is guaranteed to return
     // a default-constructed message on failure).
     return result;