Fixed Path::IsParent()

Path::StartsWith() was incorrectly performing a common prefix check,
instead the method should have been determining whether the other path
is a child of the current path.  i.e

Path("foo/bar").IsParent("foo/bar/baz") yields true

where

Path("foo/bar/baz").IsParent("foo/bar") yields false

---
Cloned from cl/259864083 added missing test cases and fixed naming.

PiperOrigin-RevId: 259953511

Author: smiles

app/src/path.cc

@@ -15,6 +15,7 @@
  */
 
 #include "app/src/path.h"
+
 #include <algorithm>
 #include <cstring>
 #include <iterator>
@@ -130,16 +131,16 @@ const char* Path::GetBaseName() const {
   return path_.c_str() + index + 1;
 }
 
-bool Path::StartsWith(const Path& prefix) const {
-  if (prefix.empty()) return true;
-  if (prefix.path_.size() > path_.size()) return false;
+bool Path::IsParent(const Path& other) const {
+  if (empty()) return true;
+  if (path_.size() > other.path_.size()) return false;
+  auto other_iter = other.path_.begin();
   auto this_iter = path_.begin();
-  auto prefix_iter = prefix.path_.begin();
-  for (; this_iter != path_.end() && prefix_iter != prefix.path_.end();
-       ++this_iter, ++prefix_iter) {
-    if (*this_iter != *prefix_iter) break;
+  for (; other_iter != other.path_.end() && this_iter != path_.end();
+       ++other_iter, ++this_iter) {
+    if (*other_iter != *this_iter) break;
   }
-  return this_iter == path_.end() || *this_iter == '/';
+  return other_iter == other.path_.end() || *other_iter == '/';
 }
 
 std::vector<std::string> Path::GetDirectories() const {

app/src/path.h

@@ -19,6 +19,7 @@
 
 #include <string>
 #include <vector>
+
 #include "app/src/include/firebase/internal/common.h"
 #include "app/src/optional.h"
 
@@ -73,11 +74,11 @@ class Path {
   // In the path: path/to/object/in/database, it would return "database".
   const char* GetBaseName() const;
 
-  // Returns true if this path starts with the prefix path. The prefix path is
-  // compared on a per-directory basis, not per-character. That is, for the path
-  // "foo/bar/baz", the path "foo/bar" would be return true, but "foo/ba" would
-  // return false.
-  bool StartsWith(const Path& prefix) const;
+  // Returns true if this path is the parent of the other path. The other path
+  // is compared on a per-directory basis, not per-character. That is, for the
+  // path "foo/bar/baz", the path "foo/bar" would be return true, but "foo/ba"
+  // would return false.
+  bool IsParent(const Path& other) const;
 
   // Returns a vector containing each directory in the path in order.
   // The path "foo/bar/baz" would return a vector containing "foo", "bar", and

database/src/desktop/core/write_tree.cc

@@ -97,7 +97,7 @@ bool WriteTree::RemoveWrite(WriteId write_id) {
         // The removed write was completely shadowed by a subsequent write.
         removed_write_was_visible = false;
         break;
-      } else if (write_to_remove.path.StartsWith(current_write.path)) {
+      } else if (write_to_remove.path.IsParent(current_write.path)) {
         // Either we're covering some writes or they're covering part of us
         // (depending on which came first).
         removed_write_overlaps_with_other_writes = true;
@@ -198,8 +198,8 @@ Optional<Variant> WriteTree::CalcCompleteEventCache(
                                   filter_data->write_ids_to_exclude->end(),
                                   write.write_id);
             if (iter == filter_data->write_ids_to_exclude->end()) {
-              return write.path.StartsWith(*filter_data->tree_path) ||
-                     filter_data->tree_path->StartsWith(write.path);
+              return write.path.IsParent(*filter_data->tree_path) ||
+                     filter_data->tree_path->IsParent(write.path);
             }
           }
           return false;
@@ -358,12 +358,12 @@ Optional<Variant> WriteTree::ShadowingWrite(const Path& path) const {
 bool WriteTree::RecordContainsPath(const UserWriteRecord& write_record,
                                    const Path& path) {
   if (write_record.is_overwrite) {
-    return write_record.path.StartsWith(path);
+    return write_record.path.IsParent(path);
   } else {
     bool result = false;
     write_record.merge.write_tree().CallOnEach(
         Path(), [&](const Path& current_path, Variant) {
-          if (write_record.path.GetChild(current_path).StartsWith(path)) {
+          if (write_record.path.GetChild(current_path).IsParent(path)) {
             result = true;
           }
         });
@@ -394,12 +394,12 @@ CompoundWrite WriteTree::LayerTree(const std::vector<UserWriteRecord>& writes,
     if (filter(write, filter_userdata)) {
       Path write_path = write.path;
       if (write.is_overwrite) {
-        if (tree_root.StartsWith(write_path)) {
+        if (tree_root.IsParent(write_path)) {
           Optional<Path> relative_path =
               Path::GetRelative(tree_root, write_path);
           compound_write =
               compound_write.AddWrite(*relative_path, write.overwrite);
-        } else if (write_path.StartsWith(tree_root)) {
+        } else if (write_path.IsParent(tree_root)) {
           compound_write = compound_write.AddWrite(
               Path(),
               VariantGetChild(&write.overwrite,
@@ -409,12 +409,12 @@ CompoundWrite WriteTree::LayerTree(const std::vector<UserWriteRecord>& writes,
           // write
         }
       } else {
-        if (tree_root.StartsWith(write_path)) {
+        if (tree_root.IsParent(write_path)) {
           Optional<Path> relative_path =
               Path::GetRelative(tree_root, write_path);
           compound_write =
               compound_write.AddWrites(*relative_path, write.merge);
-        } else if (write_path.StartsWith(tree_root)) {
+        } else if (write_path.IsParent(tree_root)) {
           Optional<Path> relative_path =
               Path::GetRelative(write_path, tree_root);
           if (relative_path->empty()) {