Import trimmed svn-1.8.0-rc3

1 files changed, 5486 insertions, 0 deletions

diff --git a/subversion/libsvn_wc/update_editor.c b/subversion/libsvn_wc/update_editor.c
new file mode 100644
index 0000000..617ad47
--- /dev/null
+++ b/subversion/libsvn_wc/update_editor.c
@@ -0,0 +1,5486 @@
+/*
+ * update_editor.c :  main editor for checkouts and updates
+ *
+ * ====================================================================
+ *    Licensed to the Apache Software Foundation (ASF) under one
+ *    or more contributor license agreements.  See the NOTICE file
+ *    distributed with this work for additional information
+ *    regarding copyright ownership.  The ASF licenses this file
+ *    to you under the Apache License, Version 2.0 (the
+ *    "License"); you may not use this file except in compliance
+ *    with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing,
+ *    software distributed under the License is distributed on an
+ *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *    KIND, either express or implied.  See the License for the
+ *    specific language governing permissions and limitations
+ *    under the License.
+ * ====================================================================
+ */
+
+
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <apr_pools.h>
+#include <apr_hash.h>
+#include <apr_md5.h>
+#include <apr_tables.h>
+#include <apr_strings.h>
+
+#include "svn_types.h"
+#include "svn_pools.h"
+#include "svn_hash.h"
+#include "svn_string.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_error.h"
+#include "svn_io.h"
+#include "svn_private_config.h"
+#include "svn_time.h"
+
+#include "wc.h"
+#include "adm_files.h"
+#include "conflicts.h"
+#include "translate.h"
+#include "workqueue.h"
+
+#include "private/svn_subr_private.h"
+#include "private/svn_wc_private.h"
+#include "private/svn_editor.h"
+
+/* Checks whether a svn_wc__db_status_t indicates whether a node is
+   present in a working copy. Used by the editor implementation */
+#define IS_NODE_PRESENT(status)                             \
+           ((status) != svn_wc__db_status_server_excluded &&\
+            (status) != svn_wc__db_status_excluded &&       \
+            (status) != svn_wc__db_status_not_present)
+
+static svn_error_t *
+path_join_under_root(const char **result_path,
+                     const char *base_path,
+                     const char *add_path,
+                     apr_pool_t *result_pool);
+
+
+/*
+ * This code handles "checkout" and "update" and "switch".
+ * A checkout is similar to an update that is only adding new items.
+ *
+ * The intended behaviour of "update" and "switch", focusing on the checks
+ * to be made before applying a change, is:
+ *
+ *   For each incoming change:
+ *     if target is already in conflict or obstructed:
+ *       skip this change
+ *     else
+ *     if this action will cause a tree conflict:
+ *       record the tree conflict
+ *       skip this change
+ *     else:
+ *       make this change
+ *
+ * In more detail:
+ *
+ *   For each incoming change:
+ *
+ *   1.   if  # Incoming change is inside an item already in conflict:
+ *    a.    tree/text/prop change to node beneath tree-conflicted dir
+ *        then  # Skip all changes in this conflicted subtree [*1]:
+ *          do not update the Base nor the Working
+ *          notify "skipped because already in conflict" just once
+ *            for the whole conflicted subtree
+ *
+ *        if  # Incoming change affects an item already in conflict:
+ *    b.    tree/text/prop change to tree-conflicted dir/file, or
+ *    c.    tree change to a text/prop-conflicted file/dir, or
+ *    d.    text/prop change to a text/prop-conflicted file/dir [*2], or
+ *    e.    tree change to a dir tree containing any conflicts,
+ *        then  # Skip this change [*1]:
+ *          do not update the Base nor the Working
+ *          notify "skipped because already in conflict"
+ *
+ *   2.   if  # Incoming change affects an item that's "obstructed":
+ *    a.    on-disk node kind doesn't match recorded Working node kind
+ *            (including an absence/presence mis-match),
+ *        then  # Skip this change [*1]:
+ *          do not update the Base nor the Working
+ *          notify "skipped because obstructed"
+ *
+ *   3.   if  # Incoming change raises a tree conflict:
+ *    a.    tree/text/prop change to node beneath sched-delete dir, or
+ *    b.    tree/text/prop change to sched-delete dir/file, or
+ *    c.    text/prop change to tree-scheduled dir/file,
+ *        then  # Skip this change:
+ *          do not update the Base nor the Working [*3]
+ *          notify "tree conflict"
+ *
+ *   4.   Apply the change:
+ *          update the Base
+ *          update the Working, possibly raising text/prop conflicts
+ *          notify
+ *
+ * Notes:
+ *
+ *      "Tree change" here refers to an add or delete of the target node,
+ *      including the add or delete part of a copy or move or rename.
+ *
+ * [*1] We should skip changes to an entire node, as the base revision number
+ *      applies to the entire node. Not sure how this affects attempts to
+ *      handle text and prop changes separately.
+ *
+ * [*2] Details of which combinations of property and text changes conflict
+ *      are not specified here.
+ *
+ * [*3] For now, we skip the update, and require the user to:
+ *        - Modify the WC to be compatible with the incoming change;
+ *        - Mark the conflict as resolved;
+ *        - Repeat the update.
+ *      Ideally, it would be possible to resolve any conflict without
+ *      repeating the update. To achieve this, we would have to store the
+ *      necessary data at conflict detection time, and delay the update of
+ *      the Base until the time of resolving.
+ */
+
+
+/*** batons ***/
+
+struct edit_baton
+{
+  /* For updates, the "destination" of the edit is ANCHOR_ABSPATH, the
+     directory containing TARGET_ABSPATH. If ANCHOR_ABSPATH itself is the
+     target, the values are identical.
+
+     TARGET_BASENAME is the name of TARGET_ABSPATH in ANCHOR_ABSPATH, or "" if
+     ANCHOR_ABSPATH is the target */
+  const char *target_basename;
+
+  /* Absolute variants of ANCHOR and TARGET */
+  const char *anchor_abspath;
+  const char *target_abspath;
+
+  /* The DB handle for managing the working copy state.  */
+  svn_wc__db_t *db;
+
+  /* Array of file extension patterns to preserve as extensions in
+     generated conflict files. */
+  const apr_array_header_t *ext_patterns;
+
+  /* Hash mapping const char * absolute working copy paths to depth-first
+     ordered arrays of svn_prop_inherited_item_t * structures representing
+     the properties inherited by the base node at that working copy path.
+     May be NULL. */
+  apr_hash_t *wcroot_iprops;
+
+  /* The revision we're targeting...or something like that.  This
+     starts off as a pointer to the revision to which we are updating,
+     or SVN_INVALID_REVNUM, but by the end of the edit, should be
+     pointing to the final revision. */
+  svn_revnum_t *target_revision;
+
+  /* The requested depth of this edit. */
+  svn_depth_t requested_depth;
+
+  /* Is the requested depth merely an operational limitation, or is
+     also the new sticky ambient depth of the update target? */
+  svn_boolean_t depth_is_sticky;
+
+  /* Need to know if the user wants us to overwrite the 'now' times on
+     edited/added files with the last-commit-time. */
+  svn_boolean_t use_commit_times;
+
+  /* Was the root actually opened (was this a non-empty edit)? */
+  svn_boolean_t root_opened;
+
+  /* Was the update-target deleted?  This is a special situation. */
+  svn_boolean_t target_deleted;
+
+  /* Allow unversioned obstructions when adding a path. */
+  svn_boolean_t allow_unver_obstructions;
+
+  /* Handle local additions as modifications of new nodes */
+  svn_boolean_t adds_as_modification;
+
+  /* If set, we check out into an empty directory. This allows for a number
+     of conflict checks to be omitted. */
+  svn_boolean_t clean_checkout;
+
+  /* If this is a 'switch' operation, the new relpath of target_abspath,
+     else NULL. */
+  const char *switch_relpath;
+
+  /* The URL to the root of the repository. */
+  const char *repos_root;
+
+  /* The UUID of the repos, or NULL. */
+  const char *repos_uuid;
+
+  /* External diff3 to use for merges (can be null, in which case
+     internal merge code is used). */
+  const char *diff3_cmd;
+
+  /* Externals handler */
+  svn_wc_external_update_t external_func;
+  void *external_baton;
+
+  /* This editor sends back notifications as it edits. */
+  svn_wc_notify_func2_t notify_func;
+  void *notify_baton;
+
+  /* This editor is normally wrapped in a cancellation editor anyway,
+     so it doesn't bother to check for cancellation itself.  However,
+     it needs a cancel_func and cancel_baton available to pass to
+     long-running functions. */
+  svn_cancel_func_t cancel_func;
+  void *cancel_baton;
+
+  /* This editor will invoke a interactive conflict-resolution
+     callback, if available. */
+  svn_wc_conflict_resolver_func2_t conflict_func;
+  void *conflict_baton;
+
+  /* Subtrees that were skipped during the edit, and therefore shouldn't
+     have their revision/url info updated at the end.  If a path is a
+     directory, its descendants will also be skipped.  The keys are paths
+     relative to the working copy root and the values unspecified. */
+  apr_hash_t *skipped_trees;
+
+  /* A mapping from const char * repos_relpaths to the apr_hash_t * instances
+     returned from fetch_dirents_func for that repos_relpath. These
+     are used to avoid issue #3569 in specific update scenarios where a
+     restricted depth is used. */
+  apr_hash_t *dir_dirents;
+
+  /* Absolute path of the working copy root or NULL if not initialized yet */
+  const char *wcroot_abspath;
+
+  apr_pool_t *pool;
+};
+
+
+/* Record in the edit baton EB that LOCAL_ABSPATH's base version is not being
+ * updated.
+ *
+ * Add to EB->skipped_trees a copy (allocated in EB->pool) of the string
+ * LOCAL_ABSPATH.
+ */
+static svn_error_t *
+remember_skipped_tree(struct edit_baton *eb,
+                      const char *local_abspath,
+                      apr_pool_t *scratch_pool)
+{
+  SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
+
+  svn_hash_sets(eb->skipped_trees,
+                apr_pstrdup(eb->pool,
+                            svn_dirent_skip_ancestor(eb->wcroot_abspath,
+                                                     local_abspath)),
+                (void *)1);
+
+  return SVN_NO_ERROR;
+}
+
+/* Per directory baton. Lives in its own subpool of the parent directory
+   or of the edit baton if there is no parent directory */
+struct dir_baton
+{
+  /* Basename of this directory. */
+  const char *name;
+
+  /* Absolute path of this directory */
+  const char *local_abspath;
+
+  /* The repository relative path this directory will correspond to. */
+  const char *new_relpath;
+
+  /* The revision of the directory before updating */
+  svn_revnum_t old_revision;
+
+  /* The repos_relpath before updating/switching */
+  const char *old_repos_relpath;
+
+  /* The global edit baton. */
+  struct edit_baton *edit_baton;
+
+  /* Baton for this directory's parent, or NULL if this is the root
+     directory. */
+  struct dir_baton *parent_baton;
+
+  /* Set if updates to this directory are skipped */
+  svn_boolean_t skip_this;
+
+  /* Set if there was a previous notification for this directory */
+  svn_boolean_t already_notified;
+
+  /* Set if this directory is being added during this editor drive. */
+  svn_boolean_t adding_dir;
+
+  /* Set on a node and its descendants are not present in the working copy
+     but should still be updated (not skipped). These nodes should all be
+     marked as deleted. */
+  svn_boolean_t shadowed;
+
+  /* Set on a node when the existing node is obstructed, and the edit operation
+     continues as semi-shadowed update */
+  svn_boolean_t edit_obstructed;
+
+  /* The (new) changed_* information, cached to avoid retrieving it later */
+  svn_revnum_t changed_rev;
+  apr_time_t changed_date;
+  const char *changed_author;
+
+  /* If not NULL, contains a mapping of const char* basenames of children that
+     have been deleted to their svn_skel_t* tree conflicts.
+     We store this hash to allow replacements to continue under a just
+     installed tree conflict.
+
+     The add after the delete will then update the tree conflicts information
+     and reinstall it. */
+  apr_hash_t *deletion_conflicts;
+
+  /* A hash of file names (only the hash key matters) seen by add_file
+     and not yet added to the database by close_file. */
+  apr_hash_t *not_present_files;
+
+  /* Set if an unversioned dir of the same name already existed in
+     this directory. */
+  svn_boolean_t obstruction_found;
+
+  /* Set if a dir of the same name already exists and is
+     scheduled for addition without history. */
+  svn_boolean_t add_existed;
+
+  /* An array of svn_prop_t structures, representing all the property
+     changes to be applied to this directory. */
+  apr_array_header_t *propchanges;
+
+  /* A boolean indicating whether this node or one of its children has
+     received any 'real' changes. Used to avoid tree conflicts for simple
+     entryprop changes, like lock management */
+  svn_boolean_t edited;
+
+  /* The tree conflict to install once the node is really edited */
+  svn_skel_t *edit_conflict;
+
+  /* The bump information for this directory. */
+  struct bump_dir_info *bump_info;
+
+  /* The depth of the directory in the wc (or inferred if added).  Not
+     used for filtering; we have a separate wrapping editor for that. */
+  svn_depth_t ambient_depth;
+
+  /* Was the directory marked as incomplete before the update?
+     (In other words, are we resuming an interrupted update?)
+
+     If WAS_INCOMPLETE is set to TRUE we expect to receive all child nodes
+     and properties for/of the directory. If WAS_INCOMPLETE is FALSE then
+     we only receive the changes in/for children and properties.*/
+  svn_boolean_t was_incomplete;
+
+  /* The pool in which this baton itself is allocated. */
+  apr_pool_t *pool;
+
+  /* how many nodes are referring to baton? */
+  int ref_count;
+
+};
+
+
+struct handler_baton
+{
+  svn_txdelta_window_handler_t apply_handler;
+  void *apply_baton;
+  apr_pool_t *pool;
+  struct file_baton *fb;
+
+  /* Where we are assembling the new file. */
+  const char *new_text_base_tmp_abspath;
+
+    /* The expected source checksum of the text source or NULL if no base
+     checksum is available (MD5 if the server provides a checksum, SHA1 if
+     the server doesn't) */
+  svn_checksum_t *expected_source_checksum;
+
+  /* Why two checksums?
+     The editor currently provides an md5 which we use to detect corruption
+     during transmission.  We use the sha1 inside libsvn_wc both for pristine
+     handling and corruption detection.  In the future, the editor will also
+     provide a sha1, so we may not have to calculate both, but for the time
+     being, that's the way it is. */
+
+  /* The calculated checksum of the text source or NULL if the acual
+     checksum is not being calculated. The checksum kind is identical to the
+     kind of expected_source_checksum. */
+  svn_checksum_t *actual_source_checksum;
+
+  /* The stream used to calculate the source checksums */
+  svn_stream_t *source_checksum_stream;
+
+  /* A calculated MD5 digest of NEW_TEXT_BASE_TMP_ABSPATH.
+     This is initialized to all zeroes when the baton is created, then
+     populated with the MD5 digest of the resultant fulltext after the
+     last window is handled by the handler returned from
+     apply_textdelta(). */
+  unsigned char new_text_base_md5_digest[APR_MD5_DIGESTSIZE];
+
+  /* A calculated SHA-1 of NEW_TEXT_BASE_TMP_ABSPATH, which we'll use for
+     eventually writing the pristine. */
+  svn_checksum_t * new_text_base_sha1_checksum;
+};
+
+
+/* Get an empty file in the temporary area for WRI_ABSPATH.  The file will
+   not be set for automatic deletion, and the name will be returned in
+   TMP_FILENAME.
+
+   This implementation creates a new empty file with a unique name.
+
+   ### This is inefficient for callers that just want an empty file to read
+   ### from.  There could be (and there used to be) a permanent, shared
+   ### empty file for this purpose.
+
+   ### This is inefficient for callers that just want to reserve a unique
+   ### file name to create later.  A better way may not be readily available.
+ */
+static svn_error_t *
+get_empty_tmp_file(const char **tmp_filename,
+                   svn_wc__db_t *db,
+                   const char *wri_abspath,
+                   apr_pool_t *result_pool,
+                   apr_pool_t *scratch_pool)
+{
+  const char *temp_dir_abspath;
+
+  SVN_ERR(svn_wc__db_temp_wcroot_tempdir(&temp_dir_abspath, db, wri_abspath,
+                                         scratch_pool, scratch_pool));
+  SVN_ERR(svn_io_open_unique_file3(NULL, tmp_filename, temp_dir_abspath,
+                                   svn_io_file_del_none,
+                                   scratch_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* An APR pool cleanup handler.  This runs the working queue for an
+   editor baton. */
+static apr_status_t
+cleanup_edit_baton(void *edit_baton)
+{
+  struct edit_baton *eb = edit_baton;
+  svn_error_t *err;
+  apr_pool_t *pool = apr_pool_parent_get(eb->pool);
+
+  err = svn_wc__wq_run(eb->db, eb->wcroot_abspath,
+                       NULL /* cancel_func */, NULL /* cancel_baton */,
+                       pool);
+
+  if (err)
+    {
+      apr_status_t apr_err = err->apr_err;
+      svn_error_clear(err);
+      return apr_err;
+    }
+  return APR_SUCCESS;
+}
+
+/* Make a new dir baton in a subpool of PB->pool. PB is the parent baton.
+   If PATH and PB are NULL, this is the root directory of the edit; in this
+   case, make the new dir baton in a subpool of EB->pool.
+   ADDING should be TRUE if we are adding this directory.  */
+static svn_error_t *
+make_dir_baton(struct dir_baton **d_p,
+               const char *path,
+               struct edit_baton *eb,
+               struct dir_baton *pb,
+               svn_boolean_t adding,
+               apr_pool_t *scratch_pool)
+{
+  apr_pool_t *dir_pool;
+  struct dir_baton *d;
+
+  if (pb != NULL)
+    dir_pool = svn_pool_create(pb->pool);
+  else
+    dir_pool = svn_pool_create(eb->pool);
+
+  SVN_ERR_ASSERT(path || (! pb));
+
+  /* Okay, no easy out, so allocate and initialize a dir baton. */
+  d = apr_pcalloc(dir_pool, sizeof(*d));
+
+  /* Construct the PATH and baseNAME of this directory. */
+  if (path)
+    {
+      d->name = svn_dirent_basename(path, dir_pool);
+      SVN_ERR(path_join_under_root(&d->local_abspath,
+                                   pb->local_abspath, d->name, dir_pool));
+    }
+  else
+    {
+      /* This is the root baton. */
+      d->name = NULL;
+      d->local_abspath = eb->anchor_abspath;
+    }
+
+  /* Figure out the new_relpath for this directory. */
+  if (eb->switch_relpath)
+    {
+      /* Handle switches... */
+
+      if (pb == NULL)
+        {
+          if (*eb->target_basename == '\0')
+            {
+              /* No parent baton and target_basename=="" means that we are
+                 the target of the switch. Thus, our NEW_RELPATH will be
+                 the SWITCH_RELPATH.  */
+              d->new_relpath = eb->switch_relpath;
+            }
+          else
+            {
+              /* This node is NOT the target of the switch (one of our
+                 children is the target); therefore, it must already exist.
+                 Get its old REPOS_RELPATH, as it won't be changing.  */
+              SVN_ERR(svn_wc__db_scan_base_repos(&d->new_relpath, NULL, NULL,
+                                                 eb->db, d->local_abspath,
+                                                 dir_pool, scratch_pool));
+            }
+        }
+      else
+        {
+          /* This directory is *not* the root (has a parent). If there is
+             no grandparent, then we may have anchored at the parent,
+             and self is the target. If we match the target, then set
+             NEW_RELPATH to the SWITCH_RELPATH.
+
+             Otherwise, we simply extend NEW_RELPATH from the parent.  */
+          if (pb->parent_baton == NULL
+              && strcmp(eb->target_basename, d->name) == 0)
+            d->new_relpath = eb->switch_relpath;
+          else
+            d->new_relpath = svn_relpath_join(pb->new_relpath, d->name,
+                                              dir_pool);
+        }
+    }
+  else  /* must be an update */
+    {
+      /* If we are adding the node, then simply extend the parent's
+         relpath for our own.  */
+      if (adding)
+        {
+          SVN_ERR_ASSERT(pb != NULL);
+          d->new_relpath = svn_relpath_join(pb->new_relpath, d->name,
+                                            dir_pool);
+        }
+      else
+        {
+          SVN_ERR(svn_wc__db_scan_base_repos(&d->new_relpath, NULL, NULL,
+                                             eb->db, d->local_abspath,
+                                             dir_pool, scratch_pool));
+          SVN_ERR_ASSERT(d->new_relpath);
+        }
+    }
+
+  d->edit_baton   = eb;
+  d->parent_baton = pb;
+  d->pool         = dir_pool;
+  d->propchanges  = apr_array_make(dir_pool, 1, sizeof(svn_prop_t));
+  d->obstruction_found = FALSE;
+  d->add_existed  = FALSE;
+  d->ref_count = 1;
+  d->old_revision = SVN_INVALID_REVNUM;
+  d->adding_dir   = adding;
+  d->changed_rev  = SVN_INVALID_REVNUM;
+  d->not_present_files = apr_hash_make(dir_pool);
+
+  /* Copy some flags from the parent baton */
+  if (pb)
+    {
+      d->skip_this = pb->skip_this;
+      d->shadowed = pb->shadowed || pb->edit_obstructed;
+
+      /* the parent's bump info has one more referer */
+      pb->ref_count++;
+    }
+
+  /* The caller of this function needs to fill these in. */
+  d->ambient_depth = svn_depth_unknown;
+  d->was_incomplete = FALSE;
+
+  *d_p = d;
+  return SVN_NO_ERROR;
+}
+
+
+/* Forward declarations. */
+static svn_error_t *
+already_in_a_tree_conflict(svn_boolean_t *conflicted,
+                           svn_boolean_t *ignored,
+                           svn_wc__db_t *db,
+                           const char *local_abspath,
+                           apr_pool_t *scratch_pool);
+
+
+static void
+do_notification(const struct edit_baton *eb,
+                const char *local_abspath,
+                svn_node_kind_t kind,
+                svn_wc_notify_action_t action,
+                apr_pool_t *scratch_pool)
+{
+  svn_wc_notify_t *notify;
+
+  if (eb->notify_func == NULL)
+    return;
+
+  notify = svn_wc_create_notify(local_abspath, action, scratch_pool);
+  notify->kind = kind;
+
+  (*eb->notify_func)(eb->notify_baton, notify, scratch_pool);
+}
+
+/* Decrement the directory's reference count. If it hits zero,
+   then this directory is "done". This means it is safe to clear its pool.
+
+   In addition, when the directory is "done", we recurse to possible cleanup
+   the parent directory.
+*/
+static svn_error_t *
+maybe_release_dir_info(struct dir_baton *db)
+{
+  db->ref_count--;
+
+  if (!db->ref_count)
+    {
+      struct dir_baton *pb = db->parent_baton;
+
+      svn_pool_destroy(db->pool);
+
+      if (pb)
+        SVN_ERR(maybe_release_dir_info(pb));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* Per file baton. Lives in its own subpool below the pool of the parent
+   directory */
+struct file_baton
+{
+  /* Pool specific to this file_baton. */
+  apr_pool_t *pool;
+
+  /* Name of this file (its entry in the directory). */
+  const char *name;
+
+  /* Absolute path to this file */
+  const char *local_abspath;
+
+  /* The repository relative path this file will correspond to. */
+  const char *new_relpath;
+
+  /* The revision of the file before updating */
+  svn_revnum_t old_revision;
+
+  /* The repos_relpath before updating/switching */
+  const char *old_repos_relpath;
+
+  /* The global edit baton. */
+  struct edit_baton *edit_baton;
+
+  /* The parent directory of this file. */
+  struct dir_baton *dir_baton;
+
+  /* Set if updates to this directory are skipped */
+  svn_boolean_t skip_this;
+
+  /* Set if there was a previous notification  */
+  svn_boolean_t already_notified;
+
+  /* Set if this file is new. */
+  svn_boolean_t adding_file;
+
+  /* Set if an unversioned file of the same name already existed in
+     this directory. */
+  svn_boolean_t obstruction_found;
+
+  /* Set if a file of the same name already exists and is
+     scheduled for addition without history. */
+  svn_boolean_t add_existed;
+
+  /* Set if this file is being added in the BASE layer, but is not-present
+     in the working copy (replaced, deleted, etc.). */
+  svn_boolean_t shadowed;
+
+  /* Set on a node when the existing node is obstructed, and the edit operation
+     continues as semi-shadowed update */
+  svn_boolean_t edit_obstructed;
+
+  /* The (new) changed_* information, cached to avoid retrieving it later */
+  svn_revnum_t changed_rev;
+  apr_time_t changed_date;
+  const char *changed_author;
+
+  /* If there are file content changes, these are the checksums of the
+     resulting new text base, which is in the pristine store, else NULL. */
+  const svn_checksum_t *new_text_base_md5_checksum;
+  const svn_checksum_t *new_text_base_sha1_checksum;
+
+  /* The checksum of the file before the update */
+  const svn_checksum_t *original_checksum;
+
+  /* An array of svn_prop_t structures, representing all the property
+     changes to be applied to this file.  Once a file baton is
+     initialized, this is never NULL, but it may have zero elements.  */
+  apr_array_header_t *propchanges;
+
+  /* For existing files, whether there are local modifications. FALSE for added
+     files */
+  svn_boolean_t local_prop_mods;
+
+  /* Bump information for the directory this file lives in */
+  struct bump_dir_info *bump_info;
+
+  /* A boolean indicating whether this node or one of its children has
+     received any 'real' changes. Used to avoid tree conflicts for simple
+     entryprop changes, like lock management */
+  svn_boolean_t edited;
+
+  /* The tree conflict to install once the node is really edited */
+  svn_skel_t *edit_conflict;
+};
+
+
+/* Make a new file baton in a subpool of PB->pool. PB is the parent baton.
+ * PATH is relative to the root of the edit. ADDING tells whether this file
+ * is being added. */
+static svn_error_t *
+make_file_baton(struct file_baton **f_p,
+                struct dir_baton *pb,
+                const char *path,
+                svn_boolean_t adding,
+                apr_pool_t *scratch_pool)
+{
+  struct edit_baton *eb = pb->edit_baton;
+  apr_pool_t *file_pool = svn_pool_create(pb->pool);
+  struct file_baton *f = apr_pcalloc(file_pool, sizeof(*f));
+
+  SVN_ERR_ASSERT(path);
+
+  /* Make the file's on-disk name. */
+  f->name = svn_dirent_basename(path, file_pool);
+  f->old_revision = SVN_INVALID_REVNUM;
+  SVN_ERR(path_join_under_root(&f->local_abspath,
+                               pb->local_abspath, f->name, file_pool));
+
+  /* Figure out the new URL for this file. */
+  if (eb->switch_relpath)
+    {
+      /* Handle switches... */
+
+      /* This file has a parent directory. If there is
+         no grandparent, then we may have anchored at the parent,
+         and self is the target. If we match the target, then set
+         NEW_RELPATH to the SWITCH_RELPATH.
+
+         Otherwise, we simply extend NEW_RELPATH from the parent.  */
+      if (pb->parent_baton == NULL
+          && strcmp(eb->target_basename, f->name) == 0)
+        f->new_relpath = eb->switch_relpath;
+      else
+        f->new_relpath = svn_relpath_join(pb->new_relpath, f->name,
+                                          file_pool);
+    }
+  else  /* must be an update */
+    {
+      if (adding)
+        f->new_relpath = svn_relpath_join(pb->new_relpath, f->name, file_pool);
+      else
+        {
+          SVN_ERR(svn_wc__db_scan_base_repos(&f->new_relpath, NULL, NULL,
+                                             eb->db, f->local_abspath,
+                                             file_pool, scratch_pool));
+          SVN_ERR_ASSERT(f->new_relpath);
+        }
+    }
+
+  f->pool              = file_pool;
+  f->edit_baton        = pb->edit_baton;
+  f->propchanges       = apr_array_make(file_pool, 1, sizeof(svn_prop_t));
+  f->bump_info         = pb->bump_info;
+  f->adding_file       = adding;
+  f->obstruction_found = FALSE;
+  f->add_existed       = FALSE;
+  f->skip_this         = pb->skip_this;
+  f->shadowed          = pb->shadowed || pb->edit_obstructed;
+  f->dir_baton         = pb;
+  f->changed_rev       = SVN_INVALID_REVNUM;
+
+  /* the directory has one more referer now */
+  pb->ref_count++;
+
+  *f_p = f;
+  return SVN_NO_ERROR;
+}
+
+/* Complete a conflict skel by describing the update.
+ *
+ * LOCAL_KIND is the node kind of the tree conflict victim in the
+ * working copy.
+ *
+ * All temporary allocations are be made in SCRATCH_POOL, while allocations
+ * needed for the returned conflict struct are made in RESULT_POOL.
+ */
+static svn_error_t *
+complete_conflict(svn_skel_t *conflict,
+                  const struct edit_baton *eb,
+                  const char *local_abspath,
+                  const char *old_repos_relpath,
+                  svn_revnum_t old_revision,
+                  const char *new_repos_relpath,
+                  svn_node_kind_t local_kind,
+                  svn_node_kind_t target_kind,
+                  apr_pool_t *result_pool,
+                  apr_pool_t *scratch_pool)
+{
+  svn_wc_conflict_version_t *original_version;
+  svn_wc_conflict_version_t *target_version;
+  svn_boolean_t is_complete;
+
+  if (!conflict)
+    return SVN_NO_ERROR; /* Not conflicted */
+
+  SVN_ERR(svn_wc__conflict_skel_is_complete(&is_complete, conflict));
+
+  if (is_complete)
+    return SVN_NO_ERROR; /* Already completed */
+
+  if (old_repos_relpath)
+    original_version = svn_wc_conflict_version_create2(eb->repos_root,
+                                                       eb->repos_uuid,
+                                                       old_repos_relpath,
+                                                       old_revision,
+                                                       local_kind,
+                                                       result_pool);
+  else
+    original_version = NULL;
+
+  if (new_repos_relpath)
+    target_version = svn_wc_conflict_version_create2(eb->repos_root,
+                                                        eb->repos_uuid,
+                                                        new_repos_relpath,
+                                                        *eb->target_revision,
+                                                        target_kind,
+                                                        result_pool);
+  else
+    target_version = NULL;
+
+  if (eb->switch_relpath)
+    SVN_ERR(svn_wc__conflict_skel_set_op_switch(conflict,
+                                                original_version,
+                                                target_version,
+                                                result_pool, scratch_pool));
+  else
+    SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict,
+                                                original_version,
+                                                target_version,
+                                                result_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* Called when a directory is really edited, to avoid marking a
+   tree conflict on a node for a no-change edit */
+static svn_error_t *
+mark_directory_edited(struct dir_baton *db, apr_pool_t *scratch_pool)
+{
+  if (db->edited)
+    return SVN_NO_ERROR;
+
+  if (db->parent_baton)
+    SVN_ERR(mark_directory_edited(db->parent_baton, scratch_pool));
+
+  db->edited = TRUE;
+
+  if (db->edit_conflict)
+    {
+      /* We have a (delayed) tree conflict to install */
+
+      SVN_ERR(complete_conflict(db->edit_conflict, db->edit_baton,
+                                db->local_abspath,
+                                db->old_repos_relpath, db->old_revision,
+                                db->new_relpath,
+                                svn_node_dir, svn_node_dir,
+                                db->pool, scratch_pool));
+      SVN_ERR(svn_wc__db_op_mark_conflict(db->edit_baton->db,
+                                          db->local_abspath,
+                                          db->edit_conflict, NULL,
+                                          scratch_pool));
+
+      do_notification(db->edit_baton, db->local_abspath, svn_node_dir,
+                      svn_wc_notify_tree_conflict, scratch_pool);
+      db->already_notified = TRUE;
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* Called when a file is really edited, to avoid marking a
+   tree conflict on a node for a no-change edit */
+static svn_error_t *
+mark_file_edited(struct file_baton *fb, apr_pool_t *scratch_pool)
+{
+  if (fb->edited)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(mark_directory_edited(fb->dir_baton, scratch_pool));
+
+  fb->edited = TRUE;
+
+  if (fb->edit_conflict)
+    {
+      /* We have a (delayed) tree conflict to install */
+
+      SVN_ERR(complete_conflict(fb->edit_conflict, fb->edit_baton,
+                                fb->local_abspath, fb->old_repos_relpath,
+                                fb->old_revision, fb->new_relpath,
+                                svn_node_file, svn_node_file,
+                                fb->pool, scratch_pool));
+
+      SVN_ERR(svn_wc__db_op_mark_conflict(fb->edit_baton->db,
+                                          fb->local_abspath,
+                                          fb->edit_conflict, NULL,
+                                          scratch_pool));
+
+      do_notification(fb->edit_baton, fb->local_abspath, svn_node_file,
+                      svn_wc_notify_tree_conflict, scratch_pool);
+      fb->already_notified = TRUE;
+    }
+
+  return SVN_NO_ERROR;
+}
+
+
+/* Handle the next delta window of the file described by BATON.  If it is
+ * the end (WINDOW == NULL), then check the checksum, store the text in the
+ * pristine store and write its details into BATON->fb->new_text_base_*. */
+static svn_error_t *
+window_handler(svn_txdelta_window_t *window, void *baton)
+{
+  struct handler_baton *hb = baton;
+  struct file_baton *fb = hb->fb;
+  svn_wc__db_t *db = fb->edit_baton->db;
+  svn_error_t *err;
+
+  /* Apply this window.  We may be done at that point.  */
+  err = hb->apply_handler(window, hb->apply_baton);
+  if (window != NULL && !err)
+    return SVN_NO_ERROR;
+
+  if (hb->expected_source_checksum)
+    {
+      /* Close the stream to calculate HB->actual_source_md5_checksum. */
+      svn_error_t *err2 = svn_stream_close(hb->source_checksum_stream);
+
+      if (!err2)
+        {
+          SVN_ERR_ASSERT(hb->expected_source_checksum->kind ==
+                        hb->actual_source_checksum->kind);
+
+          if (!svn_checksum_match(hb->expected_source_checksum,
+                                  hb->actual_source_checksum))
+            {
+              err = svn_error_createf(SVN_ERR_WC_CORRUPT_TEXT_BASE, err,
+                        _("Checksum mismatch while updating '%s':\n"
+                          "   expected:  %s\n"
+                          "     actual:  %s\n"),
+                        svn_dirent_local_style(fb->local_abspath, hb->pool),
+                        svn_checksum_to_cstring(hb->expected_source_checksum,
+                                                hb->pool),
+                        svn_checksum_to_cstring(hb->actual_source_checksum,
+                                                hb->pool));
+            }
+        }
+
+      err = svn_error_compose_create(err, err2);
+    }
+
+  if (err)
+    {
+      /* We failed to apply the delta; clean up the temporary file.  */
+      svn_error_clear(svn_io_remove_file2(hb->new_text_base_tmp_abspath, TRUE,
+                                          hb->pool));
+    }
+  else
+    {
+      /* Tell the file baton about the new text base's checksums. */
+      fb->new_text_base_md5_checksum =
+        svn_checksum__from_digest_md5(hb->new_text_base_md5_digest, fb->pool);
+      fb->new_text_base_sha1_checksum =
+        svn_checksum_dup(hb->new_text_base_sha1_checksum, fb->pool);
+
+      /* Store the new pristine text in the pristine store now.  Later, in a
+         single transaction we will update the BASE_NODE to include a
+         reference to this pristine text's checksum. */
+      SVN_ERR(svn_wc__db_pristine_install(db, hb->new_text_base_tmp_abspath,
+                                          fb->new_text_base_sha1_checksum,
+                                          fb->new_text_base_md5_checksum,
+                                          hb->pool));
+    }
+
+  svn_pool_destroy(hb->pool);
+
+  return err;
+}
+
+
+/* Find the last-change info within ENTRY_PROPS, and return then in the
+   CHANGED_* parameters. Each parameter will be initialized to its "none"
+   value, and will contain the relavent info if found.
+
+   CHANGED_AUTHOR will be allocated in RESULT_POOL. SCRATCH_POOL will be
+   used for some temporary allocations.
+*/
+static svn_error_t *
+accumulate_last_change(svn_revnum_t *changed_rev,
+                       apr_time_t *changed_date,
+                       const char **changed_author,
+                       const apr_array_header_t *entry_props,
+                       apr_pool_t *result_pool,
+                       apr_pool_t *scratch_pool)
+{
+  int i;
+
+  *changed_rev = SVN_INVALID_REVNUM;
+  *changed_date = 0;
+  *changed_author = NULL;
+
+  for (i = 0; i < entry_props->nelts; ++i)
+    {
+      const svn_prop_t *prop = &APR_ARRAY_IDX(entry_props, i, svn_prop_t);
+
+      /* A prop value of NULL means the information was not
+         available.  We don't remove this field from the entries
+         file; we have convention just leave it empty.  So let's
+         just skip those entry props that have no values. */
+      if (! prop->value)
+        continue;
+
+      if (! strcmp(prop->name, SVN_PROP_ENTRY_LAST_AUTHOR))
+        *changed_author = apr_pstrdup(result_pool, prop->value->data);
+      else if (! strcmp(prop->name, SVN_PROP_ENTRY_COMMITTED_REV))
+        {
+          apr_int64_t rev;
+          SVN_ERR(svn_cstring_atoi64(&rev, prop->value->data));
+          *changed_rev = (svn_revnum_t)rev;
+        }
+      else if (! strcmp(prop->name, SVN_PROP_ENTRY_COMMITTED_DATE))
+        SVN_ERR(svn_time_from_cstring(changed_date, prop->value->data,
+                                      scratch_pool));
+
+      /* Starting with Subversion 1.7 we ignore the SVN_PROP_ENTRY_UUID
+         property here. */
+    }
+
+  return SVN_NO_ERROR;
+}
+
+
+/* Join ADD_PATH to BASE_PATH.  If ADD_PATH is absolute, or if any ".."
+ * component of it resolves to a path above BASE_PATH, then return
+ * SVN_ERR_WC_OBSTRUCTED_UPDATE.
+ *
+ * This is to prevent the situation where the repository contains,
+ * say, "..\nastyfile".  Although that's perfectly legal on some
+ * systems, when checked out onto Win32 it would cause "nastyfile" to
+ * be created in the parent of the current edit directory.
+ *
+ * (http://cve.mitre.org/cgi-bin/cvename.cgi?name=2007-3846)
+ */
+static svn_error_t *
+path_join_under_root(const char **result_path,
+                     const char *base_path,
+                     const char *add_path,
+                     apr_pool_t *pool)
+{
+  svn_boolean_t under_root;
+
+  SVN_ERR(svn_dirent_is_under_root(&under_root,
+                                   result_path, base_path, add_path, pool));
+
+  if (! under_root)
+    {
+      return svn_error_createf(
+          SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
+          _("Path '%s' is not in the working copy"),
+          svn_dirent_local_style(svn_dirent_join(base_path, add_path, pool),
+                                 pool));
+    }
+
+  /* This catches issue #3288 */
+  if (strcmp(add_path, svn_dirent_basename(*result_path, NULL)) != 0)
+    {
+      return svn_error_createf(
+          SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
+          _("'%s' is not valid as filename in directory '%s'"),
+          svn_dirent_local_style(add_path, pool),
+          svn_dirent_local_style(base_path, pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+
+/*** The callbacks we'll plug into an svn_delta_editor_t structure. ***/
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+set_target_revision(void *edit_baton,
+                    svn_revnum_t target_revision,
+                    apr_pool_t *pool)
+{
+  struct edit_baton *eb = edit_baton;
+
+  *(eb->target_revision) = target_revision;
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+check_tree_conflict(svn_skel_t **pconflict,
+                    struct edit_baton *eb,
+                    const char *local_abspath,
+                    svn_wc__db_status_t working_status,
+                    svn_boolean_t exists_in_repos,
+                    svn_node_kind_t expected_kind,
+                    svn_wc_conflict_action_t action,
+                    apr_pool_t *result_pool,
+                    apr_pool_t *scratch_pool);
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+open_root(void *edit_baton,
+          svn_revnum_t base_revision, /* This is ignored in co */
+          apr_pool_t *pool,
+          void **dir_baton)
+{
+  struct edit_baton *eb = edit_baton;
+  struct dir_baton *db;
+  svn_boolean_t already_conflicted, conflict_ignored;
+  svn_error_t *err;
+  svn_wc__db_status_t status;
+  svn_wc__db_status_t base_status;
+  svn_node_kind_t kind;
+  svn_boolean_t have_work;
+
+  /* Note that something interesting is actually happening in this
+     edit run. */
+  eb->root_opened = TRUE;
+
+  SVN_ERR(make_dir_baton(&db, NULL, eb, NULL, FALSE, pool));
+  *dir_baton = db;
+
+  err = already_in_a_tree_conflict(&already_conflicted, &conflict_ignored,
+                                   eb->db, db->local_abspath, pool);
+
+  if (err)
+    {
+      if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+        return svn_error_trace(err);
+
+      svn_error_clear(err);
+      already_conflicted = conflict_ignored = FALSE;
+    }
+  else if (already_conflicted)
+    {
+      /* Record a skip of both the anchor and target in the skipped tree
+         as the anchor itself might not be updated */
+      SVN_ERR(remember_skipped_tree(eb, db->local_abspath, pool));
+      SVN_ERR(remember_skipped_tree(eb, eb->target_abspath, pool));
+
+      db->skip_this = TRUE;
+      db->already_notified = TRUE;
+
+      /* Notify that we skipped the target, while we actually skipped
+         the anchor */
+      do_notification(eb, eb->target_abspath, svn_node_unknown,
+                      svn_wc_notify_skip_conflicted, pool);
+
+      return SVN_NO_ERROR;
+    }
+
+
+  SVN_ERR(svn_wc__db_read_info(&status, &kind, &db->old_revision,
+                               &db->old_repos_relpath, NULL, NULL,
+                               &db->changed_rev, &db->changed_date,
+                               &db->changed_author, &db->ambient_depth,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, &have_work,
+                               eb->db, db->local_abspath,
+                               db->pool, pool));
+
+  if (conflict_ignored)
+    {
+      db->shadowed = TRUE;
+    }
+  else if (have_work)
+    {
+      const char *move_src_root_abspath;
+
+      SVN_ERR(svn_wc__db_base_moved_to(NULL, NULL, &move_src_root_abspath,
+                                       NULL, eb->db, db->local_abspath,
+                                       pool, pool));
+      if (move_src_root_abspath || *eb->target_basename == '\0')
+        SVN_ERR(svn_wc__db_base_get_info(&base_status, NULL,
+                                         &db->old_revision,
+                                         &db->old_repos_relpath, NULL, NULL,
+                                         &db->changed_rev, &db->changed_date,
+                                         &db->changed_author,
+                                         &db->ambient_depth,
+                                         NULL, NULL, NULL, NULL, NULL, NULL,
+                                         eb->db, db->local_abspath,
+                                         db->pool, pool));
+
+      if (move_src_root_abspath)
+        {
+          /* This is an update anchored inside a move. We need to
+             raise a move-edit tree-conflict on the move root to
+             update the move destination. */
+          svn_skel_t *tree_conflict = svn_wc__conflict_skel_create(pool);
+
+          SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+                    tree_conflict, eb->db, move_src_root_abspath,
+                    svn_wc_conflict_reason_moved_away,
+                    svn_wc_conflict_action_edit,
+                    move_src_root_abspath, pool, pool));
+
+          if (strcmp(db->local_abspath, move_src_root_abspath))
+            {
+              /* We are raising the tree-conflict on some parent of
+                 the edit root, we won't be handling that path again
+                 so raise the conflict now. */
+              SVN_ERR(complete_conflict(tree_conflict, eb,
+                                        move_src_root_abspath,
+                                        db->old_repos_relpath,
+                                        db->old_revision, db->new_relpath,
+                                        svn_node_dir, svn_node_dir,
+                                        pool, pool));
+              SVN_ERR(svn_wc__db_op_mark_conflict(eb->db,
+                                                  move_src_root_abspath,
+                                                  tree_conflict,
+                                                  NULL, pool));
+              do_notification(eb, move_src_root_abspath, svn_node_dir,
+                              svn_wc_notify_tree_conflict, pool);
+            }
+          else
+            db->edit_conflict = tree_conflict;
+        }
+
+      db->shadowed = TRUE; /* Needed for the close_directory() on the root, to
+                              make sure it doesn't use the ACTUAL tree */
+    }
+  else
+    base_status = status;
+
+  if (*eb->target_basename == '\0')
+    {
+      /* For an update with a NULL target, this is equivalent to open_dir(): */
+
+      db->was_incomplete = (base_status == svn_wc__db_status_incomplete);
+
+      /* ### TODO: Add some tree conflict and obstruction detection, etc. like
+                   open_directory() does.
+                   (or find a way to reuse that code here)
+
+         ### BH 2013: I don't think we need all of the detection here, as the
+                      user explicitly asked to update this node. So we don't
+                      have to tell that it is a local replacement/delete.
+       */
+
+      SVN_ERR(svn_wc__db_temp_op_start_directory_update(eb->db,
+                                                        db->local_abspath,
+                                                        db->new_relpath,
+                                                        *eb->target_revision,
+                                                        pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+
+/* ===================================================================== */
+/* Checking for local modifications. */
+
+/* A baton for use with modcheck_found_entry(). */
+typedef struct modcheck_baton_t {
+  svn_wc__db_t *db;         /* wc_db to access nodes */
+  svn_boolean_t found_mod;  /* whether a modification has been found */
+  svn_boolean_t found_not_delete;  /* Found a not-delete modification */
+} modcheck_baton_t;
+
+/* An implementation of svn_wc_status_func4_t. */
+static svn_error_t *
+modcheck_callback(void *baton,
+                  const char *local_abspath,
+                  const svn_wc_status3_t *status,
+                  apr_pool_t *scratch_pool)
+{
+  modcheck_baton_t *mb = baton;
+
+  switch (status->node_status)
+    {
+      case svn_wc_status_normal:
+      case svn_wc_status_incomplete:
+      case svn_wc_status_ignored:
+      case svn_wc_status_none:
+      case svn_wc_status_unversioned:
+      case svn_wc_status_external:
+        break;
+
+      case svn_wc_status_deleted:
+        mb->found_mod = TRUE;
+        break;
+
+      case svn_wc_status_missing:
+      case svn_wc_status_obstructed:
+        mb->found_mod = TRUE;
+        mb->found_not_delete = TRUE;
+        /* Exit from the status walker: We know what we want to know */
+        return svn_error_create(SVN_ERR_CEASE_INVOCATION, NULL, NULL);
+
+      default:
+      case svn_wc_status_added:
+      case svn_wc_status_replaced:
+      case svn_wc_status_modified:
+        mb->found_mod = TRUE;
+        mb->found_not_delete = TRUE;
+        /* Exit from the status walker: We know what we want to know */
+        return svn_error_create(SVN_ERR_CEASE_INVOCATION, NULL, NULL);
+    }
+
+  return SVN_NO_ERROR;
+}
+
+
+/* Set *MODIFIED to true iff there are any local modifications within the
+ * tree rooted at LOCAL_ABSPATH, using DB. If *MODIFIED
+ * is set to true and all the local modifications were deletes then set
+ * *ALL_EDITS_ARE_DELETES to true, set it to false otherwise.  LOCAL_ABSPATH
+ * may be a file or a directory. */
+svn_error_t *
+svn_wc__node_has_local_mods(svn_boolean_t *modified,
+                            svn_boolean_t *all_edits_are_deletes,
+                            svn_wc__db_t *db,
+                            const char *local_abspath,
+                            svn_cancel_func_t cancel_func,
+                            void *cancel_baton,
+                            apr_pool_t *scratch_pool)
+{
+  modcheck_baton_t modcheck_baton = { NULL, FALSE, FALSE };
+  svn_error_t *err;
+
+  modcheck_baton.db = db;
+
+  /* Walk the WC tree for status with depth infinity, looking for any local
+   * modifications. If it's a "sparse" directory, that's OK: there can be
+   * no local mods in the pieces that aren't present in the WC. */
+
+  err = svn_wc__internal_walk_status(db, local_abspath,
+                                     svn_depth_infinity,
+                                     FALSE, FALSE, FALSE, NULL,
+                                     modcheck_callback, &modcheck_baton,
+                                     cancel_func, cancel_baton,
+                                     scratch_pool);
+
+  if (err && err->apr_err == SVN_ERR_CEASE_INVOCATION)
+    svn_error_clear(err);
+  else
+    SVN_ERR(err);
+
+  *modified = modcheck_baton.found_mod;
+  *all_edits_are_deletes = (modcheck_baton.found_mod
+                            && !modcheck_baton.found_not_delete);
+
+  return SVN_NO_ERROR;
+}
+
+/* Indicates an unset svn_wc_conflict_reason_t. */
+#define SVN_WC_CONFLICT_REASON_NONE (svn_wc_conflict_reason_t)(-1)
+
+/* Check whether the incoming change ACTION on FULL_PATH would conflict with
+ * LOCAL_ABSPATH's scheduled change. If so, then raise a tree conflict with
+ * LOCAL_ABSPATH as the victim.
+ *
+ * The edit baton EB gives information including whether the operation is
+ * an update or a switch.
+ *
+ * WORKING_STATUS is the current node status of LOCAL_ABSPATH
+ * and EXISTS_IN_REPOS specifies whether a BASE_NODE representation for exists
+ * for this node. In that case the on disk type is compared to EXPECTED_KIND.
+ *
+ * If a tree conflict reason was found for the incoming action, the resulting
+ * tree conflict info is returned in *PCONFLICT. PCONFLICT must be non-NULL,
+ * while *PCONFLICT is always overwritten.
+ *
+ * The tree conflict is allocated in RESULT_POOL. Temporary allocations use
+ * SCRATCH_POOL.
+ */
+static svn_error_t *
+check_tree_conflict(svn_skel_t **pconflict,
+                    struct edit_baton *eb,
+                    const char *local_abspath,
+                    svn_wc__db_status_t working_status,
+                    svn_boolean_t exists_in_repos,
+                    svn_node_kind_t expected_kind,
+                    svn_wc_conflict_action_t action,
+                    apr_pool_t *result_pool,
+                    apr_pool_t *scratch_pool)
+{
+  svn_wc_conflict_reason_t reason = SVN_WC_CONFLICT_REASON_NONE;
+  svn_boolean_t modified = FALSE;
+  svn_boolean_t all_mods_are_deletes = FALSE;
+  const char *move_src_op_root_abspath = NULL;
+
+  *pconflict = NULL;
+
+  /* Find out if there are any local changes to this node that may
+   * be the "reason" of a tree-conflict with the incoming "action". */
+  switch (working_status)
+    {
+      case svn_wc__db_status_added:
+      case svn_wc__db_status_moved_here:
+      case svn_wc__db_status_copied:
+        if (!exists_in_repos)
+          {
+            /* The node is locally added, and it did not exist before.  This
+             * is an 'update', so the local add can only conflict with an
+             * incoming 'add'.  In fact, if we receive anything else than an
+             * svn_wc_conflict_action_add (which includes 'added',
+             * 'copied-here' and 'moved-here') during update on a node that
+             * did not exist before, then something is very wrong.
+             * Note that if there was no action on the node, this code
+             * would not have been called in the first place. */
+            SVN_ERR_ASSERT(action == svn_wc_conflict_action_add);
+
+            /* Scan the addition in case our caller didn't. */
+            if (working_status == svn_wc__db_status_added)
+              SVN_ERR(svn_wc__db_scan_addition(&working_status, NULL, NULL,
+                                               NULL, NULL, NULL, NULL,
+                                               NULL, NULL,
+                                               eb->db, local_abspath,
+                                               scratch_pool, scratch_pool));
+
+            if (working_status == svn_wc__db_status_moved_here)
+              reason = svn_wc_conflict_reason_moved_here;
+            else
+              reason = svn_wc_conflict_reason_added;
+          }
+        else
+          {
+            /* The node is locally replaced but could also be moved-away. */
+            SVN_ERR(svn_wc__db_base_moved_to(NULL, NULL, NULL,
+                                             &move_src_op_root_abspath,
+                                             eb->db, local_abspath,
+                                             scratch_pool, scratch_pool));
+            if (move_src_op_root_abspath)
+              reason = svn_wc_conflict_reason_moved_away;
+            else
+              reason = svn_wc_conflict_reason_replaced;
+          }
+        break;
+
+
+      case svn_wc__db_status_deleted:
+        {
+          SVN_ERR(svn_wc__db_base_moved_to(NULL, NULL, NULL,
+                                           &move_src_op_root_abspath,
+                                           eb->db, local_abspath,
+                                           scratch_pool, scratch_pool));
+          if (move_src_op_root_abspath)
+            reason = svn_wc_conflict_reason_moved_away;
+          else
+            reason = svn_wc_conflict_reason_deleted;
+        }
+        break;
+
+      case svn_wc__db_status_incomplete:
+        /* We used svn_wc__db_read_info(), so 'incomplete' means
+         * - there is no node in the WORKING tree
+         * - a BASE node is known to exist
+         * So the node exists and is essentially 'normal'. We still need to
+         * check prop and text mods, and those checks will retrieve the
+         * missing information (hopefully). */
+      case svn_wc__db_status_normal:
+        if (action == svn_wc_conflict_action_edit)
+          {
+            /* An edit onto a local edit or onto *no* local changes is no
+             * tree-conflict. (It's possibly a text- or prop-conflict,
+             * but we don't handle those here.)
+             *
+             * Except when there is a local obstruction
+             */
+            if (exists_in_repos)
+              {
+                svn_node_kind_t disk_kind;
+
+                SVN_ERR(svn_io_check_path(local_abspath, &disk_kind,
+                                          scratch_pool));
+
+                if (disk_kind != expected_kind && disk_kind != svn_node_none)
+                  {
+                    reason = svn_wc_conflict_reason_obstructed;
+                    break;
+                  }
+
+              }
+            return SVN_NO_ERROR;
+          }
+
+        /* Replace is handled as delete and then specifically in
+           add_directory() and add_file(), so we only expect deletes here */
+        SVN_ERR_ASSERT(action == svn_wc_conflict_action_delete);
+
+        /* Check if the update wants to delete or replace a locally
+         * modified node. */
+
+
+        /* Do a deep tree detection of local changes. The update editor will
+         * not visit the subdirectories of a directory that it wants to delete.
+         * Therefore, we need to start a separate crawl here. */
+
+        SVN_ERR(svn_wc__node_has_local_mods(&modified, &all_mods_are_deletes,
+                                            eb->db, local_abspath,
+                                            eb->cancel_func, eb->cancel_baton,
+                                            scratch_pool));
+
+        if (modified)
+          {
+            if (all_mods_are_deletes)
+              reason = svn_wc_conflict_reason_deleted;
+            else
+              reason = svn_wc_conflict_reason_edited;
+          }
+        break;
+
+      case svn_wc__db_status_server_excluded:
+        /* Not allowed to view the node. Not allowed to report tree
+         * conflicts. */
+      case svn_wc__db_status_excluded:
+        /* Locally marked as excluded. No conflicts wanted. */
+      case svn_wc__db_status_not_present:
+        /* A committed delete (but parent not updated). The delete is
+           committed, so no conflict possible during update. */
+        return SVN_NO_ERROR;
+
+      case svn_wc__db_status_base_deleted:
+        /* An internal status. Should never show up here. */
+        SVN_ERR_MALFUNCTION();
+        break;
+
+    }
+
+  if (reason == SVN_WC_CONFLICT_REASON_NONE)
+    /* No conflict with the current action. */
+    return SVN_NO_ERROR;
+
+
+  /* Sanity checks. Note that if there was no action on the node, this function
+   * would not have been called in the first place.*/
+  if (reason == svn_wc_conflict_reason_edited
+      || reason == svn_wc_conflict_reason_obstructed
+      || reason == svn_wc_conflict_reason_deleted
+      || reason == svn_wc_conflict_reason_moved_away
+      || reason == svn_wc_conflict_reason_replaced)
+    {
+      /* When the node existed before (it was locally deleted, replaced or
+       * edited), then 'update' cannot add it "again". So it can only send
+       * _action_edit, _delete or _replace. */
+    if (action != svn_wc_conflict_action_edit
+        && action != svn_wc_conflict_action_delete
+        && action != svn_wc_conflict_action_replace)
+      return svn_error_createf(SVN_ERR_WC_FOUND_CONFLICT, NULL,
+               _("Unexpected attempt to add a node at path '%s'"),
+               svn_dirent_local_style(local_abspath, scratch_pool));
+    }
+  else if (reason == svn_wc_conflict_reason_added ||
+           reason == svn_wc_conflict_reason_moved_here)
+    {
+      /* When the node did not exist before (it was locally added),
+       * then 'update' cannot want to modify it in any way.
+       * It can only send _action_add. */
+      if (action != svn_wc_conflict_action_add)
+        return svn_error_createf(SVN_ERR_WC_FOUND_CONFLICT, NULL,
+                 _("Unexpected attempt to edit, delete, or replace "
+                   "a node at path '%s'"),
+                 svn_dirent_local_style(local_abspath, scratch_pool));
+
+    }
+
+
+  /* A conflict was detected. Create a conflict skel to record it. */
+  *pconflict = svn_wc__conflict_skel_create(result_pool);
+
+  SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(*pconflict,
+                                                  eb->db, local_abspath,
+                                                  reason,
+                                                  action,
+                                                  move_src_op_root_abspath,
+                                                  result_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* If LOCAL_ABSPATH is inside a conflicted tree and the conflict is
+ * not a moved-away-edit conflict, set *CONFLICTED to TRUE.  Otherwise
+ * set *CONFLICTED to FALSE.
+ */
+static svn_error_t *
+already_in_a_tree_conflict(svn_boolean_t *conflicted,
+                           svn_boolean_t *ignored,
+                           svn_wc__db_t *db,
+                           const char *local_abspath,
+                           apr_pool_t *scratch_pool)
+{
+  const char *ancestor_abspath = local_abspath;
+  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+
+  SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
+
+  *conflicted = *ignored = FALSE;
+
+  while (TRUE)
+    {
+      svn_boolean_t is_wc_root;
+
+      svn_pool_clear(iterpool);
+
+      SVN_ERR(svn_wc__conflicted_for_update_p(conflicted, ignored, db,
+                                              ancestor_abspath, TRUE,
+                                              scratch_pool));
+      if (*conflicted || *ignored)
+        break;
+
+      SVN_ERR(svn_wc__db_is_wcroot(&is_wc_root, db, ancestor_abspath,
+                                   iterpool));
+      if (is_wc_root)
+        break;
+
+      ancestor_abspath = svn_dirent_dirname(ancestor_abspath, scratch_pool);
+    }
+
+  svn_pool_destroy(iterpool);
+
+  return SVN_NO_ERROR;
+}
+
+/* Temporary helper until the new conflict handling is in place */
+static svn_error_t *
+node_already_conflicted(svn_boolean_t *conflicted,
+                        svn_boolean_t *conflict_ignored,
+                        svn_wc__db_t *db,
+                        const char *local_abspath,
+                        apr_pool_t *scratch_pool)
+{
+  SVN_ERR(svn_wc__conflicted_for_update_p(conflicted, conflict_ignored, db,
+                                          local_abspath, FALSE,
+                                          scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+delete_entry(const char *path,
+             svn_revnum_t revision,
+             void *parent_baton,
+             apr_pool_t *pool)
+{
+  struct dir_baton *pb = parent_baton;
+  struct edit_baton *eb = pb->edit_baton;
+  const char *base = svn_relpath_basename(path, NULL);
+  const char *local_abspath;
+  const char *repos_relpath;
+  svn_node_kind_t kind, base_kind;
+  svn_revnum_t old_revision;
+  svn_boolean_t conflicted;
+  svn_boolean_t have_work;
+  svn_skel_t *tree_conflict = NULL;
+  svn_wc__db_status_t status;
+  svn_wc__db_status_t base_status;
+  apr_pool_t *scratch_pool;
+  svn_boolean_t deleting_target;
+  svn_boolean_t deleting_switched;
+  svn_boolean_t keep_as_working = FALSE;
+  svn_boolean_t queue_deletes = TRUE;
+
+  if (pb->skip_this)
+    return SVN_NO_ERROR;
+
+  scratch_pool = svn_pool_create(pb->pool);
+
+  SVN_ERR(mark_directory_edited(pb, scratch_pool));
+
+  SVN_ERR(path_join_under_root(&local_abspath, pb->local_abspath, base,
+                               scratch_pool));
+
+  deleting_target =  (strcmp(local_abspath, eb->target_abspath) == 0);
+
+  /* Detect obstructing working copies */
+  {
+    svn_boolean_t is_root;
+
+    SVN_ERR(svn_wc__db_is_wcroot(&is_root, eb->db, local_abspath,
+                                 scratch_pool));
+
+    if (is_root)
+      {
+        /* Just skip this node; a future update will handle it */
+        SVN_ERR(remember_skipped_tree(eb, local_abspath, pool));
+        do_notification(eb, local_abspath, svn_node_unknown,
+                        svn_wc_notify_update_skip_obstruction, scratch_pool);
+
+        svn_pool_destroy(scratch_pool);
+
+        return SVN_NO_ERROR;
+      }
+  }
+
+  SVN_ERR(svn_wc__db_read_info(&status, &kind, &old_revision, &repos_relpath,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               &conflicted, NULL, NULL, NULL,
+                               NULL, NULL, &have_work,
+                               eb->db, local_abspath,
+                               scratch_pool, scratch_pool));
+
+  if (!have_work)
+    {
+      base_status = status;
+      base_kind = kind;
+    }
+  else
+    SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind, &old_revision,
+                                     &repos_relpath,
+                                     NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                     NULL, NULL, NULL, NULL, NULL,
+                                     eb->db, local_abspath,
+                                     scratch_pool, scratch_pool));
+
+  if (pb->old_repos_relpath && repos_relpath)
+    {
+      const char *expected_name;
+
+      expected_name = svn_relpath_skip_ancestor(pb->old_repos_relpath,
+                                                repos_relpath);
+
+      deleting_switched = (!expected_name || strcmp(expected_name, base) != 0);
+    }
+  else
+    deleting_switched = FALSE;
+
+  /* Is this path a conflict victim? */
+  if (pb->shadowed)
+    conflicted = FALSE; /* Conflict applies to WORKING */
+  else if (conflicted)
+    SVN_ERR(node_already_conflicted(&conflicted, NULL,
+                                    eb->db, local_abspath, scratch_pool));
+  if (conflicted)
+    {
+      SVN_ERR(remember_skipped_tree(eb, local_abspath, scratch_pool));
+
+      do_notification(eb, local_abspath, svn_node_unknown,
+                      svn_wc_notify_skip_conflicted,
+                      scratch_pool);
+
+      svn_pool_destroy(scratch_pool);
+
+      return SVN_NO_ERROR;
+    }
+
+
+  /* Receive the remote removal of excluded/server-excluded/not present node.
+     Do not notify, but perform the change even when the node is shadowed */
+  if (base_status == svn_wc__db_status_not_present
+      || base_status == svn_wc__db_status_excluded
+      || base_status == svn_wc__db_status_server_excluded)
+    {
+      SVN_ERR(svn_wc__db_base_remove(eb->db, local_abspath,
+                                     FALSE /* keep_as_working */,
+                                     FALSE /* queue_deletes */,
+                                     SVN_INVALID_REVNUM /* not_present_rev */,
+                                     NULL, NULL,
+                                     scratch_pool));
+
+      if (deleting_target)
+        eb->target_deleted = TRUE;
+
+      svn_pool_destroy(scratch_pool);
+
+      return SVN_NO_ERROR;
+    }
+
+  /* Is this path the victim of a newly-discovered tree conflict?  If so,
+   * remember it and notify the client. Then (if it was existing and
+   * modified), re-schedule the node to be added back again, as a (modified)
+   * copy of the previous base version.  */
+
+  /* Check for conflicts only when we haven't already recorded
+   * a tree-conflict on a parent node. */
+  if (!pb->shadowed && !pb->edit_obstructed)
+    {
+      SVN_ERR(check_tree_conflict(&tree_conflict, eb, local_abspath,
+                                  status, TRUE,
+                                  (kind == svn_node_dir)
+                                        ? svn_node_dir
+                                        : svn_node_file,
+                                  svn_wc_conflict_action_delete,
+                                  pb->pool, scratch_pool));
+    }
+  else
+    queue_deletes = FALSE; /* There is no in-wc representation */
+
+  if (tree_conflict != NULL)
+    {
+      svn_wc_conflict_reason_t reason;
+      /* When we raise a tree conflict on a node, we don't want to mark the
+       * node as skipped, to allow a replacement to continue doing at least
+       * a bit of its work (possibly adding a not present node, for the
+       * next update) */
+      if (!pb->deletion_conflicts)
+        pb->deletion_conflicts = apr_hash_make(pb->pool);
+
+      svn_hash_sets(pb->deletion_conflicts, apr_pstrdup(pb->pool, base),
+                    tree_conflict);
+
+      SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, NULL, NULL,
+                                                  eb->db, local_abspath,
+                                                  tree_conflict,
+                                                  scratch_pool, scratch_pool));
+
+      if (reason == svn_wc_conflict_reason_edited
+          || reason == svn_wc_conflict_reason_obstructed)
+        {
+          /* The item exists locally and has some sort of local mod.
+           * It no longer exists in the repository at its target URL@REV.
+           *
+           * To prepare the "accept mine" resolution for the tree conflict,
+           * we must schedule the existing content for re-addition as a copy
+           * of what it was, but with its local modifications preserved. */
+          keep_as_working = TRUE;
+
+          /* Fall through to remove the BASE_NODEs properly, with potentially
+             keeping a not-present marker */
+        }
+      else if (reason == svn_wc_conflict_reason_deleted
+               || reason == svn_wc_conflict_reason_moved_away
+               || reason == svn_wc_conflict_reason_replaced)
+        {
+          /* The item does not exist locally because it was already shadowed.
+           * We must complete the deletion, leaving the tree conflict info
+           * as the only difference from a normal deletion. */
+
+          /* Fall through to the normal "delete" code path. */
+        }
+      else
+        SVN_ERR_MALFUNCTION();  /* other reasons are not expected here */
+    }
+
+  SVN_ERR(complete_conflict(tree_conflict, eb, local_abspath, repos_relpath,
+                            old_revision, NULL,
+                            (kind == svn_node_dir)
+                                ? svn_node_dir
+                                : svn_node_file,
+                            svn_node_none,
+                            pb->pool, scratch_pool));
+
+  /* Issue a wq operation to delete the BASE_NODE data and to delete actual
+     nodes based on that from disk, but leave any WORKING_NODEs on disk.
+
+     Local modifications are already turned into copies at this point.
+
+     If the thing being deleted is the *target* of this update, then
+     we need to recreate a 'deleted' entry, so that the parent can give
+     accurate reports about itself in the future. */
+  if (! deleting_target && ! deleting_switched)
+    {
+      /* Delete, and do not leave a not-present node.  */
+      SVN_ERR(svn_wc__db_base_remove(eb->db, local_abspath,
+                                     keep_as_working, queue_deletes,
+                                     SVN_INVALID_REVNUM /* not_present_rev */,
+                                     tree_conflict, NULL,
+                                     scratch_pool));
+    }
+  else
+    {
+      /* Delete, leaving a not-present node.  */
+      SVN_ERR(svn_wc__db_base_remove(eb->db, local_abspath,
+                                     keep_as_working, queue_deletes,
+                                     *eb->target_revision,
+                                     tree_conflict, NULL,
+                                     scratch_pool));
+      if (deleting_target)
+        eb->target_deleted = TRUE;
+      else
+        {
+          /* Don't remove the not-present marker at the final bump */
+          SVN_ERR(remember_skipped_tree(eb, local_abspath, pool));
+        }
+    }
+
+  SVN_ERR(svn_wc__wq_run(eb->db, pb->local_abspath,
+                         eb->cancel_func, eb->cancel_baton,
+                         scratch_pool));
+
+  /* Notify. */
+  if (tree_conflict)
+    do_notification(eb, local_abspath, svn_node_unknown,
+                    svn_wc_notify_tree_conflict, scratch_pool);
+  else
+    {
+      svn_wc_notify_action_t action = svn_wc_notify_update_delete;
+      svn_node_kind_t node_kind;
+
+      if (pb->shadowed || pb->edit_obstructed)
+        action = svn_wc_notify_update_shadowed_delete;
+
+      if (kind == svn_node_dir)
+        node_kind = svn_node_dir;
+      else
+        node_kind = svn_node_file;
+
+      do_notification(eb, local_abspath, node_kind, action, scratch_pool);
+    }
+
+  svn_pool_destroy(scratch_pool);
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+add_directory(const char *path,
+              void *parent_baton,
+              const char *copyfrom_path,
+              svn_revnum_t copyfrom_rev,
+              apr_pool_t *pool,
+              void **child_baton)
+{
+  struct dir_baton *pb = parent_baton;
+  struct edit_baton *eb = pb->edit_baton;
+  struct dir_baton *db;
+  svn_node_kind_t kind;
+  svn_wc__db_status_t status;
+  svn_node_kind_t wc_kind;
+  svn_boolean_t conflicted;
+  svn_boolean_t conflict_ignored = FALSE;
+  svn_boolean_t versioned_locally_and_present;
+  svn_skel_t *tree_conflict = NULL;
+  svn_error_t *err;
+
+  SVN_ERR_ASSERT(! (copyfrom_path || SVN_IS_VALID_REVNUM(copyfrom_rev)));
+
+  SVN_ERR(make_dir_baton(&db, path, eb, pb, TRUE, pool));
+  *child_baton = db;
+
+  if (db->skip_this)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(mark_directory_edited(db, pool));
+
+  if (strcmp(eb->target_abspath, db->local_abspath) == 0)
+    {
+      /* The target of the edit is being added, give it the requested
+         depth of the edit (but convert svn_depth_unknown to
+         svn_depth_infinity). */
+      db->ambient_depth = (eb->requested_depth == svn_depth_unknown)
+        ? svn_depth_infinity : eb->requested_depth;
+    }
+  else if (eb->requested_depth == svn_depth_immediates
+           || (eb->requested_depth == svn_depth_unknown
+               && pb->ambient_depth == svn_depth_immediates))
+    {
+      db->ambient_depth = svn_depth_empty;
+    }
+  else
+    {
+      db->ambient_depth = svn_depth_infinity;
+    }
+
+  /* It may not be named the same as the administrative directory. */
+  if (svn_wc_is_adm_dir(db->name, pool))
+    return svn_error_createf(
+       SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
+       _("Failed to add directory '%s': object of the same name as the "
+         "administrative directory"),
+       svn_dirent_local_style(db->local_abspath, pool));
+
+  SVN_ERR(svn_io_check_path(db->local_abspath, &kind, db->pool));
+
+  err = svn_wc__db_read_info(&status, &wc_kind, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL,
+                             &conflicted, NULL, NULL, NULL, NULL, NULL, NULL,
+                             eb->db, db->local_abspath, db->pool, db->pool);
+  if (err)
+    {
+      if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+        return svn_error_trace(err);
+
+      svn_error_clear(err);
+      wc_kind = svn_node_unknown;
+      status = svn_wc__db_status_normal;
+      conflicted = FALSE;
+
+      versioned_locally_and_present = FALSE;
+    }
+  else if (wc_kind == svn_node_dir
+           && status == svn_wc__db_status_normal)
+    {
+      /* !! We found the root of a separate working copy obstructing the wc !!
+
+         If the directory would be part of our own working copy then
+         we wouldn't have been called as an add_directory().
+
+         The only thing we can do is add a not-present node, to allow
+         a future update to bring in the new files when the problem is
+         resolved.  Note that svn_wc__db_base_add_not_present_node()
+         explicitly adds the node into the parent's node database. */
+
+      SVN_ERR(svn_wc__db_base_add_not_present_node(eb->db, db->local_abspath,
+                                                   db->new_relpath,
+                                                   eb->repos_root,
+                                                   eb->repos_uuid,
+                                                   *eb->target_revision,
+                                                   svn_node_file,
+                                                   NULL, NULL,
+                                                   pool));
+
+      SVN_ERR(remember_skipped_tree(eb, db->local_abspath, pool));
+      db->skip_this = TRUE;
+      db->already_notified = TRUE;
+
+      do_notification(eb, db->local_abspath, svn_node_dir,
+                      svn_wc_notify_update_skip_obstruction, pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (status == svn_wc__db_status_normal
+           && (wc_kind == svn_node_file
+               || wc_kind == svn_node_symlink))
+    {
+      /* We found a file external occupating the place we need in BASE.
+
+         We can't add a not-present node in this case as that would overwrite
+         the file external. Luckily the file external itself stops us from
+         forgetting a child of this parent directory like an obstructing
+         working copy would.
+
+         The reason we get here is that the adm crawler doesn't report
+         file externals.
+      */
+
+      SVN_ERR(remember_skipped_tree(eb, db->local_abspath, pool));
+      db->skip_this = TRUE;
+      db->already_notified = TRUE;
+
+      do_notification(eb, db->local_abspath, svn_node_file,
+                      svn_wc_notify_update_skip_obstruction, pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (wc_kind == svn_node_unknown)
+    versioned_locally_and_present = FALSE; /* Tree conflict ACTUAL-only node */
+  else
+    versioned_locally_and_present = IS_NODE_PRESENT(status);
+
+  /* Is this path a conflict victim? */
+  if (conflicted)
+    {
+      if (pb->deletion_conflicts)
+        tree_conflict = svn_hash_gets(pb->deletion_conflicts, db->name);
+
+      if (tree_conflict)
+        {
+          svn_wc_conflict_reason_t reason;
+          /* So this deletion wasn't just a deletion, it is actually a
+             replacement. Let's install a better tree conflict. */
+
+          /* ### Should store the conflict in DB to allow reinstalling
+             ### with theoretically more data in close_directory() */
+
+          SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, NULL, NULL,
+                                                      eb->db,
+                                                      db->local_abspath,
+                                                      tree_conflict,
+                                                      db->pool, db->pool));
+
+          tree_conflict = svn_wc__conflict_skel_create(db->pool);
+
+          SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+                                        tree_conflict,
+                                        eb->db, db->local_abspath,
+                                        reason, svn_wc_conflict_action_replace,
+                                        NULL,
+                                        db->pool, db->pool));
+
+          /* And now stop checking for conflicts here and just perform
+             a shadowed update */
+          db->edit_conflict = tree_conflict; /* Cache for close_directory */
+          tree_conflict = NULL; /* No direct notification */
+          db->shadowed = TRUE; /* Just continue */
+          conflicted = FALSE; /* No skip */
+        }
+      else
+        SVN_ERR(node_already_conflicted(&conflicted, &conflict_ignored,
+                                        eb->db, db->local_abspath, pool));
+    }
+
+  /* Now the "usual" behaviour if already conflicted. Skip it. */
+  if (conflicted)
+    {
+      /* Record this conflict so that its descendants are skipped silently. */
+      SVN_ERR(remember_skipped_tree(eb, db->local_abspath, pool));
+
+      db->skip_this = TRUE;
+      db->already_notified = TRUE;
+
+      /* We skip this node, but once the update completes the parent node will
+         be updated to the new revision. So a future recursive update of the
+         parent will not bring in this new node as the revision of the parent
+         describes to the repository that all children are available.
+
+         To resolve this problem, we add a not-present node to allow bringing
+         the node in once this conflict is resolved.
+
+         Note that we can safely assume that no present base node exists,
+         because then we would not have received an add_directory.
+       */
+      SVN_ERR(svn_wc__db_base_add_not_present_node(eb->db, db->local_abspath,
+                                                   db->new_relpath,
+                                                   eb->repos_root,
+                                                   eb->repos_uuid,
+                                                   *eb->target_revision,
+                                                   svn_node_dir,
+                                                   NULL, NULL,
+                                                   pool));
+
+      /* ### TODO: Also print victim_path in the skip msg. */
+      do_notification(eb, db->local_abspath, svn_node_dir,
+                      svn_wc_notify_skip_conflicted, pool);
+      return SVN_NO_ERROR;
+    }
+  else if (conflict_ignored)
+    {
+      db->shadowed = TRUE;
+    }
+
+  if (db->shadowed)
+    {
+      /* Nothing to check; does not and will not exist in working copy */
+    }
+  else if (versioned_locally_and_present)
+    {
+      /* What to do with a versioned or schedule-add dir:
+
+         A dir already added without history is OK.  Set add_existed
+         so that user notification is delayed until after any prop
+         conflicts have been found.
+
+         An existing versioned dir is an error.  In the future we may
+         relax this restriction and simply update such dirs.
+
+         A dir added with history is a tree conflict. */
+
+      svn_boolean_t local_is_non_dir;
+      svn_wc__db_status_t add_status = svn_wc__db_status_normal;
+
+      /* Is the local add a copy? */
+      if (status == svn_wc__db_status_added)
+        SVN_ERR(svn_wc__db_scan_addition(&add_status, NULL, NULL, NULL, NULL,
+                                         NULL, NULL, NULL, NULL,
+                                         eb->db, db->local_abspath,
+                                         pool, pool));
+
+
+      /* Is there *something* that is not a dir? */
+      local_is_non_dir = (wc_kind != svn_node_dir
+                          && status != svn_wc__db_status_deleted);
+
+      /* Do tree conflict checking if
+       *  - if there is a local copy.
+       *  - if this is a switch operation
+       *  - the node kinds mismatch
+       *
+       * During switch, local adds at the same path as incoming adds get
+       * "lost" in that switching back to the original will no longer have the
+       * local add. So switch always alerts the user with a tree conflict. */
+      if (!eb->adds_as_modification
+          || local_is_non_dir
+          || add_status != svn_wc__db_status_added)
+        {
+          SVN_ERR(check_tree_conflict(&tree_conflict, eb,
+                                      db->local_abspath,
+                                      status, FALSE, svn_node_none,
+                                      svn_wc_conflict_action_add,
+                                      pool, pool));
+        }
+
+      if (tree_conflict == NULL)
+        db->add_existed = TRUE; /* Take over WORKING */
+      else
+        db->shadowed = TRUE; /* Only update BASE */
+    }
+  else if (kind != svn_node_none)
+    {
+      /* There's an unversioned node at this path. */
+      db->obstruction_found = TRUE;
+
+      /* Unversioned, obstructing dirs are handled by prop merge/conflict,
+       * if unversioned obstructions are allowed. */
+      if (! (kind == svn_node_dir && eb->allow_unver_obstructions))
+        {
+          /* Bring in the node as deleted */ /* ### Obstructed Conflict */
+          db->shadowed = TRUE;
+
+          /* Mark a conflict */
+          tree_conflict = svn_wc__conflict_skel_create(db->pool);
+
+          SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+                                        tree_conflict,
+                                        eb->db, db->local_abspath,
+                                        svn_wc_conflict_reason_unversioned,
+                                        svn_wc_conflict_action_add, NULL,
+                                        db->pool, pool));
+          db->edit_conflict = tree_conflict;
+        }
+    }
+
+  if (tree_conflict)
+    SVN_ERR(complete_conflict(tree_conflict, eb, db->local_abspath,
+                              db->old_repos_relpath, db->old_revision,
+                              db->new_relpath,
+                              wc_kind,
+                              svn_node_dir,
+                              db->pool, pool));
+
+  SVN_ERR(svn_wc__db_base_add_incomplete_directory(
+                                     eb->db, db->local_abspath,
+                                     db->new_relpath,
+                                     eb->repos_root,
+                                     eb->repos_uuid,
+                                     *eb->target_revision,
+                                     db->ambient_depth,
+                                     (db->shadowed && db->obstruction_found),
+                                     (! db->shadowed
+                                      && status == svn_wc__db_status_added),
+                                     tree_conflict, NULL,
+                                     pool));
+
+  /* Make sure there is a real directory at LOCAL_ABSPATH, unless we are just
+     updating the DB */
+  if (!db->shadowed)
+    SVN_ERR(svn_wc__ensure_directory(db->local_abspath, pool));
+
+  if (tree_conflict != NULL)
+    {
+      db->already_notified = TRUE;
+      do_notification(eb, db->local_abspath, svn_node_dir,
+                      svn_wc_notify_tree_conflict, pool);
+    }
+
+
+  /* If this add was obstructed by dir scheduled for addition without
+     history let close_directory() handle the notification because there
+     might be properties to deal with.  If PATH was added inside a locally
+     deleted tree, then suppress notification, a tree conflict was already
+     issued. */
+  if (eb->notify_func && !db->already_notified && !db->add_existed)
+    {
+      svn_wc_notify_action_t action;
+
+      if (db->shadowed)
+        action = svn_wc_notify_update_shadowed_add;
+      else if (db->obstruction_found || db->add_existed)
+        action = svn_wc_notify_exists;
+      else
+        action = svn_wc_notify_update_add;
+
+      db->already_notified = TRUE;
+
+      do_notification(eb, db->local_abspath, svn_node_dir, action, pool);
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+open_directory(const char *path,
+               void *parent_baton,
+               svn_revnum_t base_revision,
+               apr_pool_t *pool,
+               void **child_baton)
+{
+  struct dir_baton *db, *pb = parent_baton;
+  struct edit_baton *eb = pb->edit_baton;
+  svn_boolean_t have_work;
+  svn_boolean_t conflicted;
+  svn_boolean_t conflict_ignored = FALSE;
+  svn_skel_t *tree_conflict = NULL;
+  svn_wc__db_status_t status, base_status;
+  svn_node_kind_t wc_kind;
+
+  SVN_ERR(make_dir_baton(&db, path, eb, pb, FALSE, pool));
+  *child_baton = db;
+
+  if (db->skip_this)
+    return SVN_NO_ERROR;
+
+  /* Detect obstructing working copies */
+  {
+    svn_boolean_t is_root;
+
+    SVN_ERR(svn_wc__db_is_wcroot(&is_root, eb->db, db->local_abspath,
+                                 pool));
+
+    if (is_root)
+      {
+        /* Just skip this node; a future update will handle it */
+        SVN_ERR(remember_skipped_tree(eb, db->local_abspath, pool));
+        db->skip_this = TRUE;
+        db->already_notified = TRUE;
+
+        do_notification(eb, db->local_abspath, svn_node_dir,
+                        svn_wc_notify_update_skip_obstruction, pool);
+
+        return SVN_NO_ERROR;
+      }
+  }
+
+  /* We should have a write lock on every directory touched.  */
+  SVN_ERR(svn_wc__write_check(eb->db, db->local_abspath, pool));
+
+  SVN_ERR(svn_wc__db_read_info(&status, &wc_kind, &db->old_revision,
+                               &db->old_repos_relpath, NULL, NULL,
+                               &db->changed_rev, &db->changed_date,
+                               &db->changed_author, &db->ambient_depth,
+                               NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL,
+                               &conflicted, NULL, NULL, NULL,
+                               NULL, NULL, &have_work,
+                               eb->db, db->local_abspath,
+                               db->pool, pool));
+
+  if (!have_work)
+    base_status = status;
+  else
+    SVN_ERR(svn_wc__db_base_get_info(&base_status, NULL, &db->old_revision,
+                                     &db->old_repos_relpath, NULL, NULL,
+                                     &db->changed_rev, &db->changed_date,
+                                     &db->changed_author, &db->ambient_depth,
+                                     NULL, NULL, NULL, NULL, NULL, NULL,
+                                     eb->db, db->local_abspath,
+                                     db->pool, pool));
+
+  db->was_incomplete = (base_status == svn_wc__db_status_incomplete);
+
+  /* Is this path a conflict victim? */
+  if (db->shadowed)
+    conflicted = FALSE; /* Conflict applies to WORKING */
+  else if (conflicted)
+    SVN_ERR(node_already_conflicted(&conflicted, &conflict_ignored,
+                                    eb->db, db->local_abspath, pool));
+  if (conflicted)
+    {
+      SVN_ERR(remember_skipped_tree(eb, db->local_abspath, pool));
+
+      db->skip_this = TRUE;
+      db->already_notified = TRUE;
+
+      do_notification(eb, db->local_abspath, svn_node_unknown,
+                      svn_wc_notify_skip_conflicted, pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (conflict_ignored)
+    {
+      db->shadowed = TRUE;
+    }
+
+  /* Is this path a fresh tree conflict victim?  If so, skip the tree
+     with one notification. */
+
+  /* Check for conflicts only when we haven't already recorded
+   * a tree-conflict on a parent node. */
+  if (!db->shadowed)
+    SVN_ERR(check_tree_conflict(&tree_conflict, eb, db->local_abspath,
+                                status, TRUE, svn_node_dir,
+                                svn_wc_conflict_action_edit,
+                                db->pool, pool));
+
+  /* Remember the roots of any locally deleted trees. */
+  if (tree_conflict != NULL)
+    {
+      svn_wc_conflict_reason_t reason;
+      db->edit_conflict = tree_conflict;
+      /* Other modifications wouldn't be a tree conflict */
+
+      SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, NULL, NULL,
+                                                  eb->db, db->local_abspath,
+                                                  tree_conflict,
+                                                  db->pool, db->pool));
+      SVN_ERR_ASSERT(reason == svn_wc_conflict_reason_deleted
+                     || reason == svn_wc_conflict_reason_moved_away
+                     || reason == svn_wc_conflict_reason_replaced
+                     || reason == svn_wc_conflict_reason_obstructed);
+
+      /* Continue updating BASE */
+      if (reason == svn_wc_conflict_reason_obstructed)
+        db->edit_obstructed = TRUE;
+      else
+        db->shadowed = TRUE;
+    }
+
+  /* Mark directory as being at target_revision and URL, but incomplete. */
+  SVN_ERR(svn_wc__db_temp_op_start_directory_update(eb->db, db->local_abspath,
+                                                    db->new_relpath,
+                                                    *eb->target_revision,
+                                                    pool));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+change_dir_prop(void *dir_baton,
+                const char *name,
+                const svn_string_t *value,
+                apr_pool_t *pool)
+{
+  svn_prop_t *propchange;
+  struct dir_baton *db = dir_baton;
+
+  if (db->skip_this)
+    return SVN_NO_ERROR;
+
+  propchange = apr_array_push(db->propchanges);
+  propchange->name = apr_pstrdup(db->pool, name);
+  propchange->value = value ? svn_string_dup(value, db->pool) : NULL;
+
+  if (!db->edited && svn_property_kind2(name) == svn_prop_regular_kind)
+    SVN_ERR(mark_directory_edited(db, pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* If any of the svn_prop_t objects in PROPCHANGES represents a change
+   to the SVN_PROP_EXTERNALS property, return that change, else return
+   null.  If PROPCHANGES contains more than one such change, return
+   the first. */
+static const svn_prop_t *
+externals_prop_changed(const apr_array_header_t *propchanges)
+{
+  int i;
+
+  for (i = 0; i < propchanges->nelts; i++)
+    {
+      const svn_prop_t *p = &(APR_ARRAY_IDX(propchanges, i, svn_prop_t));
+      if (strcmp(p->name, SVN_PROP_EXTERNALS) == 0)
+        return p;
+    }
+
+  return NULL;
+}
+
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+close_directory(void *dir_baton,
+                apr_pool_t *pool)
+{
+  struct dir_baton *db = dir_baton;
+  struct edit_baton *eb = db->edit_baton;
+  svn_wc_notify_state_t prop_state = svn_wc_notify_state_unknown;
+  apr_array_header_t *entry_prop_changes;
+  apr_array_header_t *dav_prop_changes;
+  apr_array_header_t *regular_prop_changes;
+  apr_hash_t *base_props;
+  apr_hash_t *actual_props;
+  apr_hash_t *new_base_props = NULL;
+  apr_hash_t *new_actual_props = NULL;
+  svn_revnum_t new_changed_rev = SVN_INVALID_REVNUM;
+  apr_time_t new_changed_date = 0;
+  const char *new_changed_author = NULL;
+  apr_pool_t *scratch_pool = db->pool;
+  svn_skel_t *all_work_items = NULL;
+  svn_skel_t *conflict_skel = NULL;
+
+  /* Skip if we're in a conflicted tree. */
+  if (db->skip_this)
+    {
+      /* Allow the parent to complete its update. */
+      SVN_ERR(maybe_release_dir_info(db));
+
+      return SVN_NO_ERROR;
+    }
+
+  if (db->edited)
+    conflict_skel = db->edit_conflict;
+
+  SVN_ERR(svn_categorize_props(db->propchanges, &entry_prop_changes,
+                               &dav_prop_changes, &regular_prop_changes, pool));
+
+  /* Fetch the existing properties.  */
+  if ((!db->adding_dir || db->add_existed)
+      && !db->shadowed)
+    {
+      SVN_ERR(svn_wc__get_actual_props(&actual_props,
+                                       eb->db, db->local_abspath,
+                                       scratch_pool, scratch_pool));
+    }
+  else
+    actual_props = apr_hash_make(pool);
+
+  if (db->add_existed)
+    {
+      /* This node already exists. Grab the current pristine properties. */
+      SVN_ERR(svn_wc__db_read_pristine_props(&base_props,
+                                             eb->db, db->local_abspath,
+                                             scratch_pool, scratch_pool));
+    }
+  else if (!db->adding_dir)
+    {
+      /* Get the BASE properties for proper merging. */
+      SVN_ERR(svn_wc__db_base_get_props(&base_props,
+                                        eb->db, db->local_abspath,
+                                        scratch_pool, scratch_pool));
+    }
+  else
+    base_props = apr_hash_make(pool);
+
+  /* An incomplete directory might have props which were supposed to be
+     deleted but weren't.  Because the server sent us all the props we're
+     supposed to have, any previous base props not in this list must be
+     deleted (issue #1672). */
+  if (db->was_incomplete)
+    {
+      int i;
+      apr_hash_t *props_to_delete;
+      apr_hash_index_t *hi;
+
+      /* In a copy of the BASE props, remove every property that we see an
+         incoming change for. The remaining unmentioned properties are those
+         which need to be deleted.  */
+      props_to_delete = apr_hash_copy(pool, base_props);
+      for (i = 0; i < regular_prop_changes->nelts; i++)
+        {
+          const svn_prop_t *prop;
+          prop = &APR_ARRAY_IDX(regular_prop_changes, i, svn_prop_t);
+          svn_hash_sets(props_to_delete, prop->name, NULL);
+        }
+
+      /* Add these props to the incoming propchanges (in
+       * regular_prop_changes).  */
+      for (hi = apr_hash_first(pool, props_to_delete);
+           hi != NULL;
+           hi = apr_hash_next(hi))
+        {
+          const char *propname = svn__apr_hash_index_key(hi);
+          svn_prop_t *prop = apr_array_push(regular_prop_changes);
+
+          /* Record a deletion for PROPNAME.  */
+          prop->name = propname;
+          prop->value = NULL;
+        }
+    }
+
+  /* If this directory has property changes stored up, now is the time
+     to deal with them. */
+  if (regular_prop_changes->nelts)
+    {
+      /* If recording traversal info, then see if the
+         SVN_PROP_EXTERNALS property on this directory changed,
+         and record before and after for the change. */
+      if (eb->external_func)
+        {
+          const svn_prop_t *change
+            = externals_prop_changed(regular_prop_changes);
+
+          if (change)
+            {
+              const svn_string_t *new_val_s = change->value;
+              const svn_string_t *old_val_s;
+
+              old_val_s = svn_hash_gets(base_props, SVN_PROP_EXTERNALS);
+
+              if ((new_val_s == NULL) && (old_val_s == NULL))
+                ; /* No value before, no value after... so do nothing. */
+              else if (new_val_s && old_val_s
+                       && (svn_string_compare(old_val_s, new_val_s)))
+                ; /* Value did not change... so do nothing. */
+              else if (old_val_s || new_val_s)
+                /* something changed, record the change */
+                {
+                  SVN_ERR((eb->external_func)(
+                                       eb->external_baton,
+                                       db->local_abspath,
+                                       old_val_s,
+                                       new_val_s,
+                                       db->ambient_depth,
+                                       db->pool));
+                }
+            }
+        }
+
+      if (db->shadowed)
+        {
+          /* We don't have a relevant actual row, but we need actual properties
+             to allow property merging without conflicts. */
+          if (db->adding_dir)
+            actual_props = apr_hash_make(scratch_pool);
+          else
+            actual_props = base_props;
+        }
+
+      /* Merge pending properties. */
+      new_base_props = svn_prop__patch(base_props, regular_prop_changes,
+                                       db->pool);
+      SVN_ERR_W(svn_wc__merge_props(&conflict_skel,
+                                    &prop_state,
+                                    &new_actual_props,
+                                    eb->db,
+                                    db->local_abspath,
+                                    NULL /* use baseprops */,
+                                    base_props,
+                                    actual_props,
+                                    regular_prop_changes,
+                                    db->pool,
+                                    scratch_pool),
+                _("Couldn't do property merge"));
+      /* After a (not-dry-run) merge, we ALWAYS have props to save.  */
+      SVN_ERR_ASSERT(new_base_props != NULL && new_actual_props != NULL);
+    }
+
+  SVN_ERR(accumulate_last_change(&new_changed_rev, &new_changed_date,
+                                 &new_changed_author, entry_prop_changes,
+                                 scratch_pool, scratch_pool));
+
+  /* Check if we should add some not-present markers before marking the
+     directory complete (Issue #3569) */
+  {
+    apr_hash_t *new_children = svn_hash_gets(eb->dir_dirents, db->new_relpath);
+
+    if (new_children != NULL)
+      {
+        apr_hash_index_t *hi;
+        apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+
+        for (hi = apr_hash_first(scratch_pool, new_children);
+             hi;
+             hi = apr_hash_next(hi))
+          {
+            const char *child_name;
+            const char *child_abspath;
+            const char *child_relpath;
+            const svn_dirent_t *dirent;
+            svn_wc__db_status_t status;
+            svn_node_kind_t child_kind;
+            svn_error_t *err;
+
+            svn_pool_clear(iterpool);
+
+            child_name = svn__apr_hash_index_key(hi);
+            child_abspath = svn_dirent_join(db->local_abspath, child_name,
+                                            iterpool);
+
+            dirent = svn__apr_hash_index_val(hi);
+            child_kind = (dirent->kind == svn_node_dir)
+                                        ? svn_node_dir
+                                        : svn_node_file;
+
+            if (db->ambient_depth < svn_depth_immediates
+                && child_kind == svn_node_dir)
+              continue; /* We don't need the subdirs */
+
+            /* ### We just check if there is some node in BASE at this path */
+            err = svn_wc__db_base_get_info(&status, NULL, NULL, NULL, NULL,
+                                           NULL, NULL, NULL, NULL, NULL, NULL,
+                                           NULL, NULL, NULL, NULL, NULL,
+                                           eb->db, child_abspath,
+                                           iterpool, iterpool);
+
+            if (!err)
+              {
+                svn_boolean_t is_wcroot;
+                SVN_ERR(svn_wc__db_is_wcroot(&is_wcroot, eb->db, child_abspath,
+                                             iterpool));
+
+                if (!is_wcroot)
+                  continue; /* Everything ok... Nothing to do here */
+                /* Fall through to allow recovering later */
+              }
+            else if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+              return svn_error_trace(err);
+
+            svn_error_clear(err);
+
+            child_relpath = svn_relpath_join(db->new_relpath, child_name,
+                                             iterpool);
+
+            SVN_ERR(svn_wc__db_base_add_not_present_node(eb->db,
+                                                         child_abspath,
+                                                         child_relpath,
+                                                         eb->repos_root,
+                                                         eb->repos_uuid,
+                                                         *eb->target_revision,
+                                                         child_kind,
+                                                         NULL, NULL,
+                                                         iterpool));
+          }
+
+        svn_pool_destroy(iterpool);
+      }
+  }
+
+  if (apr_hash_count(db->not_present_files))
+    {
+      apr_hash_index_t *hi;
+      apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+
+      /* This should call some new function (which could also be used
+         for new_children above) to add all the names in single
+         transaction, but I can't even trigger it.  I've tried
+         ra_local, ra_svn, ra_neon, ra_serf and they all call
+         close_file before close_dir. */
+      for (hi = apr_hash_first(scratch_pool, db->not_present_files);
+           hi;
+           hi = apr_hash_next(hi))
+        {
+          const char *child = svn__apr_hash_index_key(hi);
+          const char *child_abspath, *child_relpath;
+
+          svn_pool_clear(iterpool);
+
+          child_abspath = svn_dirent_join(db->local_abspath, child, iterpool);
+          child_relpath = svn_dirent_join(db->new_relpath, child, iterpool);
+
+          SVN_ERR(svn_wc__db_base_add_not_present_node(eb->db,
+                                                       child_abspath,
+                                                       child_relpath,
+                                                       eb->repos_root,
+                                                       eb->repos_uuid,
+                                                       *eb->target_revision,
+                                                       svn_node_file,
+                                                       NULL, NULL,
+                                                       iterpool));
+        }
+      svn_pool_destroy(iterpool);
+    }
+
+  /* If this directory is merely an anchor for a targeted child, then we
+     should not be updating the node at all.  */
+  if (db->parent_baton == NULL
+      && *eb->target_basename != '\0')
+    {
+      /* And we should not have received any changes!  */
+      SVN_ERR_ASSERT(db->propchanges->nelts == 0);
+      /* ... which also implies NEW_CHANGED_* are not set,
+         and NEW_BASE_PROPS == NULL.  */
+    }
+  else
+    {
+      apr_hash_t *props;
+      apr_array_header_t *iprops = NULL;
+
+      /* ### we know a base node already exists. it was created in
+         ### open_directory or add_directory.  let's just preserve the
+         ### existing DEPTH value, and possibly CHANGED_*.  */
+      /* If we received any changed_* values, then use them.  */
+      if (SVN_IS_VALID_REVNUM(new_changed_rev))
+        db->changed_rev = new_changed_rev;
+      if (new_changed_date != 0)
+        db->changed_date = new_changed_date;
+      if (new_changed_author != NULL)
+        db->changed_author = new_changed_author;
+
+      /* If no depth is set yet, set to infinity. */
+      if (db->ambient_depth == svn_depth_unknown)
+        db->ambient_depth = svn_depth_infinity;
+
+      if (eb->depth_is_sticky
+          && db->ambient_depth != eb->requested_depth)
+        {
+          /* After a depth upgrade the entry must reflect the new depth.
+             Upgrading to infinity changes the depth of *all* directories,
+             upgrading to something else only changes the target. */
+
+          if (eb->requested_depth == svn_depth_infinity
+              || (strcmp(db->local_abspath, eb->target_abspath) == 0
+                  && eb->requested_depth > db->ambient_depth))
+            {
+              db->ambient_depth = eb->requested_depth;
+            }
+        }
+
+      /* Do we have new properties to install? Or shall we simply retain
+         the prior set of properties? If we're installing new properties,
+         then we also want to write them to an old-style props file.  */
+      props = new_base_props;
+      if (props == NULL)
+        props = base_props;
+
+      if (conflict_skel)
+        {
+          svn_skel_t *work_item;
+
+          SVN_ERR(complete_conflict(conflict_skel,
+                                    db->edit_baton,
+                                    db->local_abspath,
+                                    db->old_repos_relpath,
+                                    db->old_revision,
+                                    db->new_relpath,
+                                    svn_node_dir, svn_node_dir,
+                                    db->pool, scratch_pool));
+
+          SVN_ERR(svn_wc__conflict_create_markers(&work_item,
+                                                  eb->db, db->local_abspath,
+                                                  conflict_skel,
+                                                  scratch_pool, scratch_pool));
+
+          all_work_items = svn_wc__wq_merge(all_work_items, work_item,
+                                            scratch_pool);
+        }
+
+      /* Any inherited props to be set set for this base node? */
+      if (eb->wcroot_iprops)
+        {
+          iprops = svn_hash_gets(eb->wcroot_iprops, db->local_abspath);
+
+          /* close_edit may also update iprops for switched nodes, catching
+             those for which close_directory is never called (e.g. a switch
+             with no changes).  So as a minor optimization we remove any
+             iprops from the hash so as not to set them again in
+             close_edit. */
+          if (iprops)
+            svn_hash_sets(eb->wcroot_iprops, db->local_abspath, NULL);
+        }
+
+      /* Update the BASE data for the directory and mark the directory
+         complete */
+      SVN_ERR(svn_wc__db_base_add_directory(
+                eb->db, db->local_abspath,
+                eb->wcroot_abspath,
+                db->new_relpath,
+                eb->repos_root, eb->repos_uuid,
+                *eb->target_revision,
+                props,
+                db->changed_rev, db->changed_date, db->changed_author,
+                NULL /* children */,
+                db->ambient_depth,
+                (dav_prop_changes->nelts > 0)
+                    ? svn_prop_array_to_hash(dav_prop_changes, pool)
+                    : NULL,
+                conflict_skel,
+                (! db->shadowed) && new_base_props != NULL,
+                new_actual_props,
+                iprops, all_work_items,
+                scratch_pool));
+    }
+
+  /* Process all of the queued work items for this directory.  */
+  SVN_ERR(svn_wc__wq_run(eb->db, db->local_abspath,
+                         eb->cancel_func, eb->cancel_baton,
+                         scratch_pool));
+
+  if (conflict_skel && eb->conflict_func)
+    SVN_ERR(svn_wc__conflict_invoke_resolver(eb->db, db->local_abspath,
+                                             conflict_skel,
+                                             NULL /* merge_options */,
+                                             eb->conflict_func,
+                                             eb->conflict_baton,
+                                             eb->cancel_func,
+                                             eb->conflict_baton,
+                                             scratch_pool));
+
+  /* Notify of any prop changes on this directory -- but do nothing if
+     it's an added or skipped directory, because notification has already
+     happened in that case - unless the add was obstructed by a dir
+     scheduled for addition without history, in which case we handle
+     notification here). */
+  if (!db->already_notified && eb->notify_func && db->edited)
+    {
+      svn_wc_notify_t *notify;
+      svn_wc_notify_action_t action;
+
+      if (db->shadowed || db->edit_obstructed)
+        action = svn_wc_notify_update_shadowed_update;
+      else if (db->obstruction_found || db->add_existed)
+        action = svn_wc_notify_exists;
+      else
+        action = svn_wc_notify_update_update;
+
+      notify = svn_wc_create_notify(db->local_abspath, action, pool);
+      notify->kind = svn_node_dir;
+      notify->prop_state = prop_state;
+      notify->revision = *eb->target_revision;
+      notify->old_revision = db->old_revision;
+
+      eb->notify_func(eb->notify_baton, notify, scratch_pool);
+    }
+
+  /* We're done with this directory, so remove one reference from the
+     bump information. */
+  SVN_ERR(maybe_release_dir_info(db));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* Common code for 'absent_file' and 'absent_directory'. */
+static svn_error_t *
+absent_node(const char *path,
+            svn_node_kind_t absent_kind,
+            void *parent_baton,
+            apr_pool_t *pool)
+{
+  struct dir_baton *pb = parent_baton;
+  struct edit_baton *eb = pb->edit_baton;
+  apr_pool_t *scratch_pool = svn_pool_create(pool);
+  const char *name = svn_dirent_basename(path, NULL);
+  const char *local_abspath;
+  svn_error_t *err;
+  svn_wc__db_status_t status;
+  svn_node_kind_t kind;
+
+  if (pb->skip_this)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(mark_directory_edited(pb, scratch_pool));
+
+  local_abspath = svn_dirent_join(pb->local_abspath, name, scratch_pool);
+
+  /* If an item by this name is scheduled for addition that's a
+     genuine tree-conflict.  */
+  err = svn_wc__db_read_info(&status, &kind, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL,
+                             eb->db, local_abspath,
+                             scratch_pool, scratch_pool);
+
+  if (err)
+    {
+      if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+        return svn_error_trace(err);
+
+      svn_error_clear(err);
+      status = svn_wc__db_status_not_present;
+      kind = svn_node_unknown;
+    }
+
+  if (status == svn_wc__db_status_normal
+      && kind == svn_node_dir)
+    {
+      /* We found an obstructing working copy!
+
+         We can do two things now:
+            1) notify the user, record a skip, etc.
+            2) Just record the absent node in BASE in the parent
+               working copy.
+
+         As option 2 happens to be exactly what we do anyway, lets do that.
+      */
+    }
+  else if (status == svn_wc__db_status_not_present
+           || status == svn_wc__db_status_server_excluded
+           || status == svn_wc__db_status_excluded)
+    {
+      /* The BASE node is not actually there, so we can safely turn it into
+         an absent node */
+    }
+  else
+    {
+      /* We have a local addition. If this would be a BASE node it would have
+         been deleted before we get here. (Which might have turned it into
+         a copy).
+
+         ### This should be recorded as a tree conflict and the update
+         ### can just continue, as we can just record the absent status
+         ### in BASE.
+       */
+      SVN_ERR_ASSERT(status != svn_wc__db_status_normal);
+
+      return svn_error_createf(
+         SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
+         _("Failed to mark '%s' absent: item of the same name is already "
+           "scheduled for addition"),
+         svn_dirent_local_style(local_abspath, pool));
+    }
+
+  {
+    const char *repos_relpath;
+    repos_relpath = svn_relpath_join(pb->new_relpath, name, scratch_pool);
+
+    /* Insert an excluded node below the parent node to note that this child
+       is absent. (This puts it in the parent db if the child is obstructed) */
+    SVN_ERR(svn_wc__db_base_add_excluded_node(eb->db, local_abspath,
+                                              repos_relpath, eb->repos_root,
+                                              eb->repos_uuid,
+                                              *(eb->target_revision),
+                                              absent_kind,
+                                              svn_wc__db_status_server_excluded,
+                                              NULL, NULL,
+                                              scratch_pool));
+  }
+
+  svn_pool_destroy(scratch_pool);
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+absent_file(const char *path,
+            void *parent_baton,
+            apr_pool_t *pool)
+{
+  return absent_node(path, svn_node_file, parent_baton, pool);
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+absent_directory(const char *path,
+                 void *parent_baton,
+                 apr_pool_t *pool)
+{
+  return absent_node(path, svn_node_dir, parent_baton, pool);
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+add_file(const char *path,
+         void *parent_baton,
+         const char *copyfrom_path,
+         svn_revnum_t copyfrom_rev,
+         apr_pool_t *pool,
+         void **file_baton)
+{
+  struct dir_baton *pb = parent_baton;
+  struct edit_baton *eb = pb->edit_baton;
+  struct file_baton *fb;
+  svn_node_kind_t kind = svn_node_none;
+  svn_node_kind_t wc_kind = svn_node_unknown;
+  svn_wc__db_status_t status = svn_wc__db_status_normal;
+  apr_pool_t *scratch_pool;
+  svn_boolean_t conflicted = FALSE;
+  svn_boolean_t conflict_ignored = FALSE;
+  svn_boolean_t versioned_locally_and_present = FALSE;
+  svn_skel_t *tree_conflict = NULL;
+  svn_error_t *err = SVN_NO_ERROR;
+
+  SVN_ERR_ASSERT(! (copyfrom_path || SVN_IS_VALID_REVNUM(copyfrom_rev)));
+
+  SVN_ERR(make_file_baton(&fb, pb, path, TRUE, pool));
+  *file_baton = fb;
+
+  if (fb->skip_this)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(mark_file_edited(fb, pool));
+
+  /* The file_pool can stick around for a *long* time, so we want to
+     use a subpool for any temporary allocations. */
+  scratch_pool = svn_pool_create(pool);
+
+
+  /* It may not be named the same as the administrative directory. */
+  if (svn_wc_is_adm_dir(fb->name, pool))
+    return svn_error_createf(
+       SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
+       _("Failed to add file '%s': object of the same name as the "
+         "administrative directory"),
+       svn_dirent_local_style(fb->local_abspath, pool));
+
+  if (!eb->clean_checkout)
+    {
+      SVN_ERR(svn_io_check_path(fb->local_abspath, &kind, scratch_pool));
+
+      err = svn_wc__db_read_info(&status, &wc_kind, NULL, NULL, NULL, NULL, NULL,
+                                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                NULL, NULL, NULL, NULL, NULL,
+                                &conflicted, NULL, NULL, NULL, NULL, NULL, NULL,
+                                eb->db, fb->local_abspath,
+                                scratch_pool, scratch_pool);
+    }
+
+  if (err)
+    {
+      if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+        return svn_error_trace(err);
+
+      svn_error_clear(err);
+      wc_kind = svn_node_unknown;
+      conflicted = FALSE;
+
+      versioned_locally_and_present = FALSE;
+    }
+  else if (wc_kind == svn_node_dir
+           && status == svn_wc__db_status_normal)
+    {
+      /* !! We found the root of a separate working copy obstructing the wc !!
+
+         If the directory would be part of our own working copy then
+         we wouldn't have been called as an add_file().
+
+         The only thing we can do is add a not-present node, to allow
+         a future update to bring in the new files when the problem is
+         resolved. */
+      svn_hash_sets(pb->not_present_files, apr_pstrdup(pb->pool, fb->name),
+                    (void *)1);
+
+      SVN_ERR(remember_skipped_tree(eb, fb->local_abspath, pool));
+      fb->skip_this = TRUE;
+      fb->already_notified = TRUE;
+
+      do_notification(eb, fb->local_abspath, svn_node_file,
+                      svn_wc_notify_update_skip_obstruction, scratch_pool);
+
+      svn_pool_destroy(scratch_pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (status == svn_wc__db_status_normal
+           && (wc_kind == svn_node_file
+               || wc_kind == svn_node_symlink))
+    {
+      /* We found a file external occupating the place we need in BASE.
+
+         We can't add a not-present node in this case as that would overwrite
+         the file external. Luckily the file external itself stops us from
+         forgetting a child of this parent directory like an obstructing
+         working copy would.
+
+         The reason we get here is that the adm crawler doesn't report
+         file externals.
+      */
+      SVN_ERR(remember_skipped_tree(eb, fb->local_abspath, pool));
+      fb->skip_this = TRUE;
+      fb->already_notified = TRUE;
+
+      do_notification(eb, fb->local_abspath, svn_node_file,
+                      svn_wc_notify_update_skip_obstruction, scratch_pool);
+
+      svn_pool_destroy(scratch_pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (wc_kind == svn_node_unknown)
+    versioned_locally_and_present = FALSE; /* Tree conflict ACTUAL-only node */
+  else
+    versioned_locally_and_present = IS_NODE_PRESENT(status);
+
+
+  /* Is this path a conflict victim? */
+  if (fb->shadowed)
+    conflicted = FALSE; /* Conflict applies to WORKING */
+  else if (conflicted)
+    {
+      if (pb->deletion_conflicts)
+        tree_conflict = svn_hash_gets(pb->deletion_conflicts, fb->name);
+
+      if (tree_conflict)
+        {
+          svn_wc_conflict_reason_t reason;
+          /* So this deletion wasn't just a deletion, it is actually a
+             replacement. Let's install a better tree conflict. */
+
+          /* ### Should store the conflict in DB to allow reinstalling
+             ### with theoretically more data in close_directory() */
+
+          SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, NULL, NULL,
+                                                      eb->db,
+                                                      fb->local_abspath,
+                                                      tree_conflict,
+                                                      fb->pool, fb->pool));
+
+          tree_conflict = svn_wc__conflict_skel_create(fb->pool);
+
+          SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+                                        tree_conflict,
+                                        eb->db, fb->local_abspath,
+                                        reason, svn_wc_conflict_action_replace,
+                                        NULL,
+                                        fb->pool, fb->pool));
+
+          /* And now stop checking for conflicts here and just perform
+             a shadowed update */
+          fb->edit_conflict = tree_conflict; /* Cache for close_file */
+          tree_conflict = NULL; /* No direct notification */
+          fb->shadowed = TRUE; /* Just continue */
+          conflicted = FALSE; /* No skip */
+        }
+      else
+        SVN_ERR(node_already_conflicted(&conflicted, &conflict_ignored,
+                                        eb->db, fb->local_abspath, pool));
+    }
+
+  /* Now the usual conflict handling: skip. */
+  if (conflicted)
+    {
+      SVN_ERR(remember_skipped_tree(eb, fb->local_abspath, pool));
+
+      fb->skip_this = TRUE;
+      fb->already_notified = TRUE;
+
+      /* We skip this node, but once the update completes the parent node will
+         be updated to the new revision. So a future recursive update of the
+         parent will not bring in this new node as the revision of the parent
+         describes to the repository that all children are available.
+
+         To resolve this problem, we add a not-present node to allow bringing
+         the node in once this conflict is resolved.
+
+         Note that we can safely assume that no present base node exists,
+         because then we would not have received an add_file.
+       */
+      svn_hash_sets(pb->not_present_files, apr_pstrdup(pb->pool, fb->name),
+                    (void *)1);
+
+      do_notification(eb, fb->local_abspath, svn_node_unknown,
+                      svn_wc_notify_skip_conflicted, scratch_pool);
+
+      svn_pool_destroy(scratch_pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (conflict_ignored)
+    {
+      fb->shadowed = TRUE;
+    }
+
+  if (fb->shadowed)
+    {
+      /* Nothing to check; does not and will not exist in working copy */
+    }
+  else if (versioned_locally_and_present)
+    {
+      /* What to do with a versioned or schedule-add file:
+
+         If the UUID doesn't match the parent's, or the URL isn't a child of
+         the parent dir's URL, it's an error.
+
+         Set add_existed so that user notification is delayed until after any
+         text or prop conflicts have been found.
+
+         Whether the incoming add is a symlink or a file will only be known in
+         close_file(), when the props are known. So with a locally added file
+         or symlink, let close_file() check for a tree conflict.
+
+         We will never see missing files here, because these would be
+         re-added during the crawler phase. */
+      svn_boolean_t local_is_file;
+
+      /* Is the local node a copy or move */
+      if (status == svn_wc__db_status_added)
+        SVN_ERR(svn_wc__db_scan_addition(&status, NULL, NULL, NULL, NULL, NULL,
+                                         NULL, NULL, NULL,
+                                         eb->db, fb->local_abspath,
+                                         scratch_pool, scratch_pool));
+
+      /* Is there something that is a file? */
+      local_is_file = (wc_kind == svn_node_file
+                       || wc_kind == svn_node_symlink);
+
+      /* Do tree conflict checking if
+       *  - if there is a local copy.
+       *  - if this is a switch operation
+       *  - the node kinds mismatch
+       *
+       * During switch, local adds at the same path as incoming adds get
+       * "lost" in that switching back to the original will no longer have the
+       * local add. So switch always alerts the user with a tree conflict. */
+      if (!eb->adds_as_modification
+          || !local_is_file
+          || status != svn_wc__db_status_added)
+        {
+          SVN_ERR(check_tree_conflict(&tree_conflict, eb,
+                                      fb->local_abspath,
+                                      status, FALSE, svn_node_none,
+                                      svn_wc_conflict_action_add,
+                                      scratch_pool, scratch_pool));
+        }
+
+      if (tree_conflict == NULL)
+        fb->add_existed = TRUE; /* Take over WORKING */
+      else
+        fb->shadowed = TRUE; /* Only update BASE */
+
+    }
+  else if (kind != svn_node_none)
+    {
+      /* There's an unversioned node at this path. */
+      fb->obstruction_found = TRUE;
+
+      /* Unversioned, obstructing files are handled by text merge/conflict,
+       * if unversioned obstructions are allowed. */
+      if (! (kind == svn_node_file && eb->allow_unver_obstructions))
+        {
+          /* Bring in the node as deleted */ /* ### Obstructed Conflict */
+          fb->shadowed = TRUE;
+
+          /* Mark a conflict */
+          tree_conflict = svn_wc__conflict_skel_create(fb->pool);
+
+          SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+                                        tree_conflict,
+                                        eb->db, fb->local_abspath,
+                                        svn_wc_conflict_reason_unversioned,
+                                        svn_wc_conflict_action_add,
+                                        NULL,
+                                        fb->pool, scratch_pool));
+        }
+    }
+
+  /* When this is not the update target add a not-present BASE node now,
+     to allow marking the parent directory complete in its close_edit() call.
+     This resolves issues when that occurs before the close_file(). */
+  if (pb->parent_baton
+      || *eb->target_basename == '\0'
+      || (strcmp(fb->local_abspath, eb->target_abspath) != 0))
+    {
+      svn_hash_sets(pb->not_present_files, apr_pstrdup(pb->pool, fb->name),
+                    (void *)1);
+    }
+
+  if (tree_conflict != NULL)
+    {
+      SVN_ERR(complete_conflict(tree_conflict,
+                                fb->edit_baton,
+                                fb->local_abspath,
+                                fb->old_repos_relpath,
+                                fb->old_revision,
+                                fb->new_relpath,
+                                wc_kind,
+                                svn_node_file,
+                                fb->pool, scratch_pool));
+
+      SVN_ERR(svn_wc__db_op_mark_conflict(eb->db,
+                                          fb->local_abspath,
+                                          tree_conflict, NULL,
+                                          scratch_pool));
+
+      fb->already_notified = TRUE;
+      do_notification(eb, fb->local_abspath, svn_node_file,
+                      svn_wc_notify_tree_conflict, scratch_pool);
+    }
+
+  svn_pool_destroy(scratch_pool);
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+open_file(const char *path,
+          void *parent_baton,
+          svn_revnum_t base_revision,
+          apr_pool_t *pool,
+          void **file_baton)
+{
+  struct dir_baton *pb = parent_baton;
+  struct edit_baton *eb = pb->edit_baton;
+  struct file_baton *fb;
+  svn_boolean_t conflicted;
+  svn_boolean_t conflict_ignored = FALSE;
+  svn_boolean_t have_work;
+  svn_wc__db_status_t status;
+  svn_node_kind_t wc_kind;
+  svn_skel_t *tree_conflict = NULL;
+
+  /* the file_pool can stick around for a *long* time, so we want to use
+     a subpool for any temporary allocations. */
+  apr_pool_t *scratch_pool = svn_pool_create(pool);
+
+  SVN_ERR(make_file_baton(&fb, pb, path, FALSE, pool));
+  *file_baton = fb;
+
+  if (fb->skip_this)
+    return SVN_NO_ERROR;
+
+  /* Detect obstructing working copies */
+  {
+    svn_boolean_t is_root;
+
+    SVN_ERR(svn_wc__db_is_wcroot(&is_root, eb->db, fb->local_abspath,
+                                 pool));
+
+    if (is_root)
+      {
+        /* Just skip this node; a future update will handle it */
+        SVN_ERR(remember_skipped_tree(eb, fb->local_abspath, pool));
+        fb->skip_this = TRUE;
+        fb->already_notified = TRUE;
+
+        do_notification(eb, fb->local_abspath, svn_node_file,
+                        svn_wc_notify_update_skip_obstruction, pool);
+
+        return SVN_NO_ERROR;
+      }
+  }
+
+  /* Sanity check. */
+
+  /* If replacing, make sure the .svn entry already exists. */
+  SVN_ERR(svn_wc__db_read_info(&status, &wc_kind, &fb->old_revision,
+                               &fb->old_repos_relpath, NULL, NULL,
+                               &fb->changed_rev, &fb->changed_date,
+                               &fb->changed_author, NULL,
+                               &fb->original_checksum, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL,
+                               &conflicted, NULL, NULL, &fb->local_prop_mods,
+                               NULL, NULL, &have_work,
+                               eb->db, fb->local_abspath,
+                               fb->pool, scratch_pool));
+
+  if (have_work)
+    SVN_ERR(svn_wc__db_base_get_info(NULL, NULL, &fb->old_revision,
+                                     &fb->old_repos_relpath, NULL, NULL,
+                                     &fb->changed_rev, &fb->changed_date,
+                                     &fb->changed_author, NULL,
+                                     &fb->original_checksum, NULL, NULL,
+                                     NULL, NULL, NULL,
+                                     eb->db, fb->local_abspath,
+                                     fb->pool, scratch_pool));
+
+  /* Is this path a conflict victim? */
+  if (fb->shadowed)
+    conflicted = FALSE; /* Conflict applies to WORKING */
+  else if (conflicted)
+    SVN_ERR(node_already_conflicted(&conflicted, &conflict_ignored,
+                                    eb->db, fb->local_abspath, pool));
+  if (conflicted)
+    {
+      SVN_ERR(remember_skipped_tree(eb, fb->local_abspath, pool));
+
+      fb->skip_this = TRUE;
+      fb->already_notified = TRUE;
+
+      do_notification(eb, fb->local_abspath, svn_node_unknown,
+                      svn_wc_notify_skip_conflicted, scratch_pool);
+
+      svn_pool_destroy(scratch_pool);
+
+      return SVN_NO_ERROR;
+    }
+  else if (conflict_ignored)
+    {
+      fb->shadowed = TRUE;
+    }
+
+  /* Check for conflicts only when we haven't already recorded
+   * a tree-conflict on a parent node. */
+  if (!fb->shadowed)
+    SVN_ERR(check_tree_conflict(&tree_conflict, eb, fb->local_abspath,
+                                status, TRUE, svn_node_file,
+                                svn_wc_conflict_action_edit,
+                                fb->pool, scratch_pool));
+
+  /* Is this path the victim of a newly-discovered tree conflict? */
+  if (tree_conflict != NULL)
+    {
+      svn_wc_conflict_reason_t reason;
+      fb->edit_conflict = tree_conflict;
+      /* Other modifications wouldn't be a tree conflict */
+
+      SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason, NULL, NULL,
+                                                  eb->db, fb->local_abspath,
+                                                  tree_conflict,
+                                                  scratch_pool, scratch_pool));
+      SVN_ERR_ASSERT(reason == svn_wc_conflict_reason_deleted
+                     || reason == svn_wc_conflict_reason_moved_away
+                     || reason == svn_wc_conflict_reason_replaced
+                     || reason == svn_wc_conflict_reason_obstructed);
+
+      /* Continue updating BASE */
+      if (reason == svn_wc_conflict_reason_obstructed)
+        fb->edit_obstructed = TRUE;
+      else
+        fb->shadowed = TRUE;
+    }
+
+  svn_pool_destroy(scratch_pool);
+
+  return SVN_NO_ERROR;
+}
+
+/* Implements svn_stream_lazyopen_func_t. */
+static svn_error_t *
+lazy_open_source(svn_stream_t **stream,
+                 void *baton,
+                 apr_pool_t *result_pool,
+                 apr_pool_t *scratch_pool)
+{
+  struct file_baton *fb = baton;
+
+  SVN_ERR(svn_wc__db_pristine_read(stream, NULL, fb->edit_baton->db,
+                                   fb->local_abspath,
+                                   fb->original_checksum,
+                                   result_pool, scratch_pool));
+
+
+  return SVN_NO_ERROR;
+}
+
+struct lazy_target_baton {
+  struct file_baton *fb;
+  struct handler_baton *hb;
+  struct edit_baton *eb;
+};
+
+/* Implements svn_stream_lazyopen_func_t. */
+static svn_error_t *
+lazy_open_target(svn_stream_t **stream,
+                 void *baton,
+                 apr_pool_t *result_pool,
+                 apr_pool_t *scratch_pool)
+{
+  struct lazy_target_baton *tb = baton;
+
+  SVN_ERR(svn_wc__open_writable_base(stream, &tb->hb->new_text_base_tmp_abspath,
+                                     NULL, &tb->hb->new_text_base_sha1_checksum,
+                                     tb->fb->edit_baton->db,
+                                     tb->eb->wcroot_abspath,
+                                     result_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+apply_textdelta(void *file_baton,
+                const char *expected_checksum,
+                apr_pool_t *pool,
+                svn_txdelta_window_handler_t *handler,
+                void **handler_baton)
+{
+  struct file_baton *fb = file_baton;
+  apr_pool_t *handler_pool = svn_pool_create(fb->pool);
+  struct handler_baton *hb = apr_pcalloc(handler_pool, sizeof(*hb));
+  struct edit_baton *eb = fb->edit_baton;
+  const svn_checksum_t *recorded_base_checksum;
+  svn_checksum_t *expected_base_checksum;
+  svn_stream_t *source;
+  struct lazy_target_baton *tb;
+  svn_stream_t *target;
+
+  if (fb->skip_this)
+    {
+      *handler = svn_delta_noop_window_handler;
+      *handler_baton = NULL;
+      return SVN_NO_ERROR;
+    }
+
+  SVN_ERR(mark_file_edited(fb, pool));
+
+  /* Parse checksum or sets expected_base_checksum to NULL */
+  SVN_ERR(svn_checksum_parse_hex(&expected_base_checksum, svn_checksum_md5,
+                                 expected_checksum, pool));
+
+  /* Before applying incoming svndiff data to text base, make sure
+     text base hasn't been corrupted, and that its checksum
+     matches the expected base checksum. */
+
+  /* The incoming delta is targeted against EXPECTED_BASE_CHECKSUM. Find and
+     check our RECORDED_BASE_CHECKSUM.  (In WC-1, we could not do this test
+     for replaced nodes because we didn't store the checksum of the "revert
+     base".  In WC-NG, we do and we can.) */
+  recorded_base_checksum = fb->original_checksum;
+
+  /* If we have a checksum that we want to compare to a MD5 checksum,
+     ensure that it is a MD5 checksum */
+  if (recorded_base_checksum
+      && expected_base_checksum
+      && recorded_base_checksum->kind != svn_checksum_md5)
+    SVN_ERR(svn_wc__db_pristine_get_md5(&recorded_base_checksum,
+                                        eb->db, eb->wcroot_abspath,
+                                        recorded_base_checksum, pool, pool));
+
+
+  if (!svn_checksum_match(expected_base_checksum, recorded_base_checksum))
+      return svn_error_createf(SVN_ERR_WC_CORRUPT_TEXT_BASE, NULL,
+                     _("Checksum mismatch for '%s':\n"
+                       "   expected:  %s\n"
+                       "   recorded:  %s\n"),
+                     svn_dirent_local_style(fb->local_abspath, pool),
+                     svn_checksum_to_cstring_display(expected_base_checksum,
+                                                     pool),
+                     svn_checksum_to_cstring_display(recorded_base_checksum,
+                                                     pool));
+
+  /* Open the text base for reading, unless this is an added file. */
+
+  /*
+     kff todo: what we really need to do here is:
+
+     1. See if there's a file or dir by this name already here.
+     2. See if it's under revision control.
+     3. If both are true, open text-base.
+     4. If only 1 is true, bail, because we can't go destroying user's
+        files (or as an alternative to bailing, move it to some tmp
+        name and somehow tell the user, but communicating with the
+        user without erroring is a whole callback system we haven't
+        finished inventing yet.)
+  */
+
+  if (! fb->adding_file)
+    {
+      SVN_ERR_ASSERT(!fb->original_checksum
+                     || fb->original_checksum->kind == svn_checksum_sha1);
+
+      source = svn_stream_lazyopen_create(lazy_open_source, fb, FALSE,
+                                          handler_pool);
+    }
+  else
+    {
+      source = svn_stream_empty(handler_pool);
+    }
+
+  /* If we don't have a recorded checksum, use the ra provided checksum */
+  if (!recorded_base_checksum)
+    recorded_base_checksum = expected_base_checksum;
+
+  /* Checksum the text base while applying deltas */
+  if (recorded_base_checksum)
+    {
+      hb->expected_source_checksum = svn_checksum_dup(recorded_base_checksum,
+                                                      handler_pool);
+
+      /* Wrap stream and store reference to allow calculating the
+         checksum. */
+      source = svn_stream_checksummed2(source,
+                                       &hb->actual_source_checksum,
+                                       NULL, recorded_base_checksum->kind,
+                                       TRUE, handler_pool);
+      hb->source_checksum_stream = source;
+    }
+
+  tb = apr_palloc(handler_pool, sizeof(struct lazy_target_baton));
+  tb->hb = hb;
+  tb->fb = fb;
+  tb->eb = eb;
+  target = svn_stream_lazyopen_create(lazy_open_target, tb, TRUE, handler_pool);
+
+  /* Prepare to apply the delta.  */
+  svn_txdelta_apply(source, target,
+                    hb->new_text_base_md5_digest,
+                    hb->new_text_base_tmp_abspath /* error_info */,
+                    handler_pool,
+                    &hb->apply_handler, &hb->apply_baton);
+
+  hb->pool = handler_pool;
+  hb->fb = fb;
+
+  /* We're all set.  */
+  *handler_baton = hb;
+  *handler = window_handler;
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+change_file_prop(void *file_baton,
+                 const char *name,
+                 const svn_string_t *value,
+                 apr_pool_t *scratch_pool)
+{
+  struct file_baton *fb = file_baton;
+  svn_prop_t *propchange;
+
+  if (fb->skip_this)
+    return SVN_NO_ERROR;
+
+  /* Push a new propchange to the file baton's array of propchanges */
+  propchange = apr_array_push(fb->propchanges);
+  propchange->name = apr_pstrdup(fb->pool, name);
+  propchange->value = value ? svn_string_dup(value, fb->pool) : NULL;
+
+  if (!fb->edited && svn_property_kind2(name) == svn_prop_regular_kind)
+    SVN_ERR(mark_file_edited(fb, scratch_pool));
+
+  if (! fb->shadowed
+      && strcmp(name, SVN_PROP_SPECIAL) == 0)
+    {
+      struct edit_baton *eb = fb->edit_baton;
+      svn_boolean_t modified = FALSE;
+      svn_boolean_t becomes_symlink;
+      svn_boolean_t was_symlink;
+
+      /* Let's see if we have a change as in some scenarios servers report
+         non-changes of properties. */
+      becomes_symlink = (value != NULL);
+
+      if (fb->adding_file)
+        was_symlink = becomes_symlink; /* No change */
+      else
+        {
+          apr_hash_t *props;
+
+          /* We read the server-props, not the ACTUAL props here as we just
+             want to see if this is really an incoming prop change. */
+          SVN_ERR(svn_wc__db_base_get_props(&props, eb->db,
+                                            fb->local_abspath,
+                                            scratch_pool, scratch_pool));
+
+          was_symlink = ((props
+                              && svn_hash_gets(props, SVN_PROP_SPECIAL) != NULL)
+                              ? svn_tristate_true
+                              : svn_tristate_false);
+        }
+
+      if (was_symlink != becomes_symlink)
+        {
+          /* If the local node was not modified, we continue as usual, if
+             modified we want a tree conflict just like how we would handle
+             it when receiving a delete + add (aka "replace") */
+          if (fb->local_prop_mods)
+            modified = TRUE;
+          else
+            SVN_ERR(svn_wc__internal_file_modified_p(&modified, eb->db,
+                                                     fb->local_abspath,
+                                                     FALSE, scratch_pool));
+        }
+
+      if (modified)
+        {
+          if (!fb->edit_conflict)
+            fb->edit_conflict = svn_wc__conflict_skel_create(fb->pool);
+
+          SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+                                     fb->edit_conflict,
+                                     eb->db, fb->local_abspath,
+                                     svn_wc_conflict_reason_edited,
+                                     svn_wc_conflict_action_replace,
+                                     NULL,
+                                     fb->pool, scratch_pool));
+
+          SVN_ERR(complete_conflict(fb->edit_conflict, fb->edit_baton,
+                                    fb->local_abspath, fb->old_repos_relpath,
+                                    fb->old_revision, fb->new_relpath,
+                                    svn_node_file, svn_node_file,
+                                    fb->pool, scratch_pool));
+
+          /* Create a copy of the existing (pre update) BASE node in WORKING,
+             mark a tree conflict and handle the rest of the update as
+             shadowed */
+          SVN_ERR(svn_wc__db_op_make_copy(eb->db, fb->local_abspath,
+                                          fb->edit_conflict, NULL,
+                                          scratch_pool));
+
+          do_notification(eb, fb->local_abspath, svn_node_file,
+                          svn_wc_notify_tree_conflict, scratch_pool);
+
+          /* Ok, we introduced a replacement, so we can now handle the rest
+             as a normal shadowed update */
+          fb->shadowed = TRUE;
+          fb->add_existed = FALSE;
+          fb->already_notified = TRUE;
+      }
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* Perform the actual merge of file changes between an original file,
+   identified by ORIGINAL_CHECKSUM (an empty file if NULL) to a new file
+   identified by NEW_CHECKSUM.
+
+   Merge the result into LOCAL_ABSPATH, which is part of the working copy
+   identified by WRI_ABSPATH. Use OLD_REVISION and TARGET_REVISION for naming
+   the intermediate files.
+
+   The rest of the arguments are passed to svn_wc__internal_merge().
+ */
+svn_error_t *
+svn_wc__perform_file_merge(svn_skel_t **work_items,
+                           svn_skel_t **conflict_skel,
+                           svn_boolean_t *found_conflict,
+                           svn_wc__db_t *db,
+                           const char *local_abspath,
+                           const char *wri_abspath,
+                           const svn_checksum_t *new_checksum,
+                           const svn_checksum_t *original_checksum,
+                           apr_hash_t *old_actual_props,
+                           const apr_array_header_t *ext_patterns,
+                           svn_revnum_t old_revision,
+                           svn_revnum_t target_revision,
+                           const apr_array_header_t *propchanges,
+                           const char *diff3_cmd,
+                           svn_cancel_func_t cancel_func,
+                           void *cancel_baton,
+                           apr_pool_t *result_pool,
+                           apr_pool_t *scratch_pool)
+{
+  /* Actual file exists and has local mods:
+     Now we need to let loose svn_wc__internal_merge() to merge
+     the textual changes into the working file. */
+  const char *oldrev_str, *newrev_str, *mine_str;
+  const char *merge_left;
+  svn_boolean_t delete_left = FALSE;
+  const char *path_ext = "";
+  const char *new_text_base_tmp_abspath;
+  enum svn_wc_merge_outcome_t merge_outcome = svn_wc_merge_unchanged;
+  svn_skel_t *work_item;
+
+  *work_items = NULL;
+
+  SVN_ERR(svn_wc__db_pristine_get_path(&new_text_base_tmp_abspath,
+                                       db, wri_abspath, new_checksum,
+                                       scratch_pool, scratch_pool));
+
+  /* If we have any file extensions we're supposed to
+     preserve in generated conflict file names, then find
+     this path's extension.  But then, if it isn't one of
+     the ones we want to keep in conflict filenames,
+     pretend it doesn't have an extension at all. */
+  if (ext_patterns && ext_patterns->nelts)
+    {
+      svn_path_splitext(NULL, &path_ext, local_abspath, scratch_pool);
+      if (! (*path_ext && svn_cstring_match_glob_list(path_ext, ext_patterns)))
+        path_ext = "";
+    }
+
+  /* old_revision can be invalid when the conflict is against a
+     local addition */
+  if (!SVN_IS_VALID_REVNUM(old_revision))
+    old_revision = 0;
+
+  oldrev_str = apr_psprintf(scratch_pool, ".r%ld%s%s",
+                            old_revision,
+                            *path_ext ? "." : "",
+                            *path_ext ? path_ext : "");
+
+  newrev_str = apr_psprintf(scratch_pool, ".r%ld%s%s",
+                            target_revision,
+                            *path_ext ? "." : "",
+                            *path_ext ? path_ext : "");
+  mine_str = apr_psprintf(scratch_pool, ".mine%s%s",
+                          *path_ext ? "." : "",
+                          *path_ext ? path_ext : "");
+
+  if (! original_checksum)
+    {
+      SVN_ERR(get_empty_tmp_file(&merge_left, db, wri_abspath,
+                                 result_pool, scratch_pool));
+      delete_left = TRUE;
+    }
+  else
+    SVN_ERR(svn_wc__db_pristine_get_path(&merge_left, db, wri_abspath,
+                                         original_checksum,
+                                         result_pool, scratch_pool));
+
+  /* Merge the changes from the old textbase to the new
+     textbase into the file we're updating.
+     Remember that this function wants full paths! */
+  SVN_ERR(svn_wc__internal_merge(&work_item,
+                                 conflict_skel,
+                                 &merge_outcome,
+                                 db,
+                                 merge_left,
+                                 new_text_base_tmp_abspath,
+                                 local_abspath,
+                                 wri_abspath,
+                                 oldrev_str, newrev_str, mine_str,
+                                 old_actual_props,
+                                 FALSE /* dry_run */,
+                                 diff3_cmd, NULL, propchanges,
+                                 cancel_func, cancel_baton,
+                                 result_pool, scratch_pool));
+
+  *work_items = svn_wc__wq_merge(*work_items, work_item, result_pool);
+  *found_conflict = (merge_outcome == svn_wc_merge_conflict);
+
+  /* If we created a temporary left merge file, get rid of it. */
+  if (delete_left)
+    {
+      SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db, wri_abspath,
+                                           merge_left,
+                                           result_pool, scratch_pool));
+      *work_items = svn_wc__wq_merge(*work_items, work_item, result_pool);
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* This is the small planet.  It has the complex responsibility of
+ * "integrating" a new revision of a file into a working copy.
+ *
+ * Given a file_baton FB for a file either already under version control, or
+ * prepared (see below) to join version control, fully install a
+ * new revision of the file.
+ *
+ * ### transitional: installation of the working file will be handled
+ * ### by the *INSTALL_PRISTINE flag.
+ *
+ * By "install", we mean: create a new text-base and prop-base, merge
+ * any textual and property changes into the working file, and finally
+ * update all metadata so that the working copy believes it has a new
+ * working revision of the file.  All of this work includes being
+ * sensitive to eol translation, keyword substitution, and performing
+ * all actions accumulated the parent directory's work queue.
+ *
+ * Set *CONTENT_STATE to the state of the contents after the
+ * installation.
+ *
+ * Return values are allocated in RESULT_POOL and temporary allocations
+ * are performed in SCRATCH_POOL.
+ */
+static svn_error_t *
+merge_file(svn_skel_t **work_items,
+           svn_skel_t **conflict_skel,
+           svn_boolean_t *install_pristine,
+           const char **install_from,
+           svn_wc_notify_state_t *content_state,
+           struct file_baton *fb,
+           apr_hash_t *actual_props,
+           apr_time_t last_changed_date,
+           apr_pool_t *result_pool,
+           apr_pool_t *scratch_pool)
+{
+  struct edit_baton *eb = fb->edit_baton;
+  struct dir_baton *pb = fb->dir_baton;
+  svn_boolean_t is_locally_modified;
+  svn_boolean_t found_text_conflict = FALSE;
+
+  SVN_ERR_ASSERT(! fb->shadowed
+                 && ! fb->obstruction_found
+                 && ! fb->edit_obstructed);
+
+  /*
+     When this function is called on file F, we assume the following
+     things are true:
+
+         - The new pristine text of F is present in the pristine store
+           iff FB->NEW_TEXT_BASE_SHA1_CHECKSUM is not NULL.
+
+         - The WC metadata still reflects the old version of F.
+           (We can still access the old pristine base text of F.)
+
+     The goal is to update the local working copy of F to reflect
+     the changes received from the repository, preserving any local
+     modifications.
+  */
+
+  *work_items = NULL;
+  *install_pristine = FALSE;
+  *install_from = NULL;
+
+  /* Start by splitting the file path, getting an access baton for the parent,
+     and an entry for the file if any. */
+
+  /* Has the user made local mods to the working file?
+     Note that this compares to the current pristine file, which is
+     different from fb->old_text_base_path if we have a replaced-with-history
+     file.  However, in the case we had an obstruction, we check against the
+     new text base.
+   */
+  if (fb->adding_file && !fb->add_existed)
+    {
+      is_locally_modified = FALSE; /* There is no file: Don't check */
+    }
+  else
+    {
+      /* The working file is not an obstruction.
+         So: is the file modified, relative to its ORIGINAL pristine?
+
+         This function sets is_locally_modified to FALSE for
+         files that do not exist and for directories. */
+
+      SVN_ERR(svn_wc__internal_file_modified_p(&is_locally_modified,
+                                               eb->db, fb->local_abspath,
+                                               FALSE /* exact_comparison */,
+                                               scratch_pool));
+    }
+
+  /* For 'textual' merging, we use the following system:
+
+     When a file is modified and we have a new BASE:
+      - For text files
+          * svn_wc_merge uses diff3
+          * possibly makes backups and marks files as conflicted.
+
+      - For binary files
+          * svn_wc_merge makes backups and marks files as conflicted.
+
+     If a file is not modified and we have a new BASE:
+       * Install from pristine.
+
+     If we have property changes related to magic properties or if the
+     svn:keywords property is set:
+       * Retranslate from the working file.
+   */
+  if (! is_locally_modified
+      && fb->new_text_base_sha1_checksum)
+    {
+          /* If there are no local mods, who cares whether it's a text
+             or binary file!  Just write a log command to overwrite
+             any working file with the new text-base.  If newline
+             conversion or keyword substitution is activated, this
+             will happen as well during the copy.
+             For replaced files, though, we want to merge in the changes
+             even if the file is not modified compared to the (non-revert)
+             text-base. */
+
+      *install_pristine = TRUE;
+    }
+  else if (fb->new_text_base_sha1_checksum)
+    {
+      /* Actual file exists and has local mods:
+         Now we need to let loose svn_wc__merge_internal() to merge
+         the textual changes into the working file. */
+      SVN_ERR(svn_wc__perform_file_merge(work_items,
+                                         conflict_skel,
+                                         &found_text_conflict,
+                                         eb->db,
+                                         fb->local_abspath,
+                                         pb->local_abspath,
+                                         fb->new_text_base_sha1_checksum,
+                                         fb->add_existed
+                                                  ? NULL
+                                                  : fb->original_checksum,
+                                         actual_props,
+                                         eb->ext_patterns,
+                                         fb->old_revision,
+                                         *eb->target_revision,
+                                         fb->propchanges,
+                                         eb->diff3_cmd,
+                                         eb->cancel_func, eb->cancel_baton,
+                                         result_pool, scratch_pool));
+    } /* end: working file exists and has mods */
+  else
+    {
+      /* There is no new text base, but let's see if the working file needs
+         to be updated for any other reason. */
+
+      apr_hash_t *keywords;
+
+      /* Determine if any of the propchanges are the "magic" ones that
+         might require changing the working file. */
+      svn_boolean_t magic_props_changed;
+
+      magic_props_changed = svn_wc__has_magic_property(fb->propchanges);
+
+      SVN_ERR(svn_wc__get_translate_info(NULL, NULL,
+                                         &keywords,
+                                         NULL,
+                                         eb->db, fb->local_abspath,
+                                         actual_props, TRUE,
+                                         scratch_pool, scratch_pool));
+      if (magic_props_changed || keywords)
+        {
+          /* Special edge-case: it's possible that this file installation
+             only involves propchanges, but that some of those props still
+             require a retranslation of the working file.
+
+             OR that the file doesn't involve propchanges which by themselves
+             require retranslation, but receiving a change bumps the revision
+             number which requires re-expansion of keywords... */
+
+          if (is_locally_modified)
+            {
+              const char *tmptext;
+
+              /* Copy and DEtranslate the working file to a temp text-base.
+                 Note that detranslation is done according to the old props. */
+              SVN_ERR(svn_wc__internal_translated_file(
+                        &tmptext, fb->local_abspath, eb->db, fb->local_abspath,
+                        SVN_WC_TRANSLATE_TO_NF
+                          | SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP,
+                        eb->cancel_func, eb->cancel_baton,
+                        result_pool, scratch_pool));
+
+              /* We always want to reinstall the working file if the magic
+                 properties have changed, or there are any keywords present.
+                 Note that TMPTEXT might actually refer to the working file
+                 itself (the above function skips a detranslate when not
+                 required). This is acceptable, as we will (re)translate
+                 according to the new properties into a temporary file (from
+                 the working file), and then rename the temp into place. Magic!
+               */
+              *install_pristine = TRUE;
+              *install_from = tmptext;
+            }
+          else
+            {
+              /* Use our existing 'copy' from the pristine store instead
+                 of making a new copy. This way we can use the standard code
+                 to update the recorded size and modification time.
+                 (Issue #3842) */
+              *install_pristine = TRUE;
+            }
+        }
+    }
+
+  /* Set the returned content state. */
+
+  if (found_text_conflict)
+    *content_state = svn_wc_notify_state_conflicted;
+  else if (fb->new_text_base_sha1_checksum)
+    {
+      if (is_locally_modified)
+        *content_state = svn_wc_notify_state_merged;
+      else
+        *content_state = svn_wc_notify_state_changed;
+    }
+  else
+    *content_state = svn_wc_notify_state_unchanged;
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+/* Mostly a wrapper around merge_file. */
+static svn_error_t *
+close_file(void *file_baton,
+           const char *expected_md5_digest,
+           apr_pool_t *pool)
+{
+  struct file_baton *fb = file_baton;
+  struct dir_baton *pdb = fb->dir_baton;
+  struct edit_baton *eb = fb->edit_baton;
+  svn_wc_notify_state_t content_state, prop_state;
+  svn_wc_notify_lock_state_t lock_state;
+  svn_checksum_t *expected_md5_checksum = NULL;
+  apr_hash_t *new_base_props = NULL;
+  apr_hash_t *new_actual_props = NULL;
+  apr_array_header_t *entry_prop_changes;
+  apr_array_header_t *dav_prop_changes;
+  apr_array_header_t *regular_prop_changes;
+  apr_hash_t *current_base_props = NULL;
+  apr_hash_t *current_actual_props = NULL;
+  apr_hash_t *local_actual_props = NULL;
+  svn_skel_t *all_work_items = NULL;
+  svn_skel_t *conflict_skel = NULL;
+  svn_skel_t *work_item;
+  apr_pool_t *scratch_pool = fb->pool; /* Destroyed at function exit */
+  svn_boolean_t keep_recorded_info = FALSE;
+  const svn_checksum_t *new_checksum;
+  apr_array_header_t *iprops = NULL;
+
+  if (fb->skip_this)
+    {
+      svn_pool_destroy(fb->pool);
+      SVN_ERR(maybe_release_dir_info(pdb));
+      return SVN_NO_ERROR;
+    }
+
+  if (fb->edited)
+    conflict_skel = fb->edit_conflict;
+
+  if (expected_md5_digest)
+    SVN_ERR(svn_checksum_parse_hex(&expected_md5_checksum, svn_checksum_md5,
+                                   expected_md5_digest, scratch_pool));
+
+  if (fb->new_text_base_md5_checksum && expected_md5_checksum
+      && !svn_checksum_match(expected_md5_checksum,
+                             fb->new_text_base_md5_checksum))
+    return svn_error_trace(
+                svn_checksum_mismatch_err(expected_md5_checksum,
+                                          fb->new_text_base_md5_checksum,
+                                          scratch_pool,
+                                          _("Checksum mismatch for '%s'"),
+                                          svn_dirent_local_style(
+                                                fb->local_abspath, pool)));
+
+  /* Gather the changes for each kind of property.  */
+  SVN_ERR(svn_categorize_props(fb->propchanges, &entry_prop_changes,
+                               &dav_prop_changes, &regular_prop_changes,
+                               scratch_pool));
+
+  /* Extract the changed_* and lock state information.  */
+  {
+    svn_revnum_t new_changed_rev;
+    apr_time_t new_changed_date;
+    const char *new_changed_author;
+
+    SVN_ERR(accumulate_last_change(&new_changed_rev,
+                                   &new_changed_date,
+                                   &new_changed_author,
+                                   entry_prop_changes,
+                                   scratch_pool, scratch_pool));
+
+    if (SVN_IS_VALID_REVNUM(new_changed_rev))
+      fb->changed_rev = new_changed_rev;
+    if (new_changed_date != 0)
+      fb->changed_date = new_changed_date;
+    if (new_changed_author != NULL)
+      fb->changed_author = new_changed_author;
+  }
+
+  /* Determine whether the file has become unlocked.  */
+  {
+    int i;
+
+    lock_state = svn_wc_notify_lock_state_unchanged;
+
+    for (i = 0; i < entry_prop_changes->nelts; ++i)
+      {
+        const svn_prop_t *prop
+          = &APR_ARRAY_IDX(entry_prop_changes, i, svn_prop_t);
+
+        /* If we see a change to the LOCK_TOKEN entry prop, then the only
+           possible change is its REMOVAL. Thus, the lock has been removed,
+           and we should likewise remove our cached copy of it.  */
+        if (! strcmp(prop->name, SVN_PROP_ENTRY_LOCK_TOKEN))
+          {
+            /* If we lose the lock, but not because we are switching to
+               another url, remove the state lock from the wc */
+            if (! eb->switch_relpath
+                || strcmp(fb->new_relpath, fb->old_repos_relpath) == 0)
+              {
+                SVN_ERR_ASSERT(prop->value == NULL);
+                SVN_ERR(svn_wc__db_lock_remove(eb->db, fb->local_abspath,
+                                               scratch_pool));
+
+                lock_state = svn_wc_notify_lock_state_unlocked;
+              }
+            break;
+          }
+      }
+  }
+
+  /* Install all kinds of properties.  It is important to do this before
+     any file content merging, since that process might expand keywords, in
+     which case we want the new entryprops to be in place. */
+
+  /* Write log commands to merge REGULAR_PROPS into the existing
+     properties of FB->LOCAL_ABSPATH.  Update *PROP_STATE to reflect
+     the result of the regular prop merge.
+
+     BASE_PROPS and WORKING_PROPS are hashes of the base and
+     working props of the file; if NULL they are read from the wc.  */
+
+  /* ### some of this feels like voodoo... */
+
+  if ((!fb->adding_file || fb->add_existed)
+      && !fb->shadowed)
+    SVN_ERR(svn_wc__get_actual_props(&local_actual_props,
+                                     eb->db, fb->local_abspath,
+                                     scratch_pool, scratch_pool));
+  if (local_actual_props == NULL)
+    local_actual_props = apr_hash_make(scratch_pool);
+
+  if (fb->add_existed)
+    {
+      /* This node already exists. Grab the current pristine properties. */
+      SVN_ERR(svn_wc__db_read_pristine_props(&current_base_props,
+                                             eb->db, fb->local_abspath,
+                                             scratch_pool, scratch_pool));
+      current_actual_props = local_actual_props;
+    }
+  else if (!fb->adding_file)
+    {
+      /* Get the BASE properties for proper merging. */
+      SVN_ERR(svn_wc__db_base_get_props(&current_base_props,
+                                        eb->db, fb->local_abspath,
+                                        scratch_pool, scratch_pool));
+      current_actual_props = local_actual_props;
+    }
+
+  /* Note: even if the node existed before, it may not have
+     pristine props (e.g a local-add)  */
+  if (current_base_props == NULL)
+    current_base_props = apr_hash_make(scratch_pool);
+
+  /* And new nodes need an empty set of ACTUAL props.  */
+  if (current_actual_props == NULL)
+    current_actual_props = apr_hash_make(scratch_pool);
+
+  prop_state = svn_wc_notify_state_unknown;
+
+  if (! fb->shadowed)
+    {
+      svn_boolean_t install_pristine;
+      const char *install_from = NULL;
+
+      /* Merge the 'regular' props into the existing working proplist. */
+      /* This will merge the old and new props into a new prop db, and
+         write <cp> commands to the logfile to install the merged
+         props.  */
+      new_base_props = svn_prop__patch(current_base_props, regular_prop_changes,
+                                       scratch_pool);
+      SVN_ERR(svn_wc__merge_props(&conflict_skel,
+                                  &prop_state,
+                                  &new_actual_props,
+                                  eb->db,
+                                  fb->local_abspath,
+                                  NULL /* server_baseprops (update, not merge)  */,
+                                  current_base_props,
+                                  current_actual_props,
+                                  regular_prop_changes, /* propchanges */
+                                  scratch_pool,
+                                  scratch_pool));
+      /* We will ALWAYS have properties to save (after a not-dry-run merge). */
+      SVN_ERR_ASSERT(new_base_props != NULL && new_actual_props != NULL);
+
+      /* Merge the text. This will queue some additional work.  */
+      if (!fb->obstruction_found && !fb->edit_obstructed)
+        {
+          svn_error_t *err;
+          err = merge_file(&work_item, &conflict_skel,
+                           &install_pristine, &install_from,
+                           &content_state, fb, current_actual_props,
+                           fb->changed_date, scratch_pool, scratch_pool);
+
+          if (err && err->apr_err == SVN_ERR_WC_PATH_ACCESS_DENIED)
+            {
+              if (eb->notify_func)
+                {
+                  svn_wc_notify_t *notify =svn_wc_create_notify(
+                                fb->local_abspath,
+                                svn_wc_notify_update_skip_access_denied,
+                                scratch_pool);
+
+                  notify->kind = svn_node_file;
+                  notify->err = err;
+
+                  eb->notify_func(eb->notify_baton, notify, scratch_pool);
+                }
+              svn_error_clear(err);
+
+              SVN_ERR(remember_skipped_tree(eb, fb->local_abspath,
+                                            scratch_pool));
+              fb->skip_this = TRUE;
+
+              svn_pool_destroy(fb->pool);
+              SVN_ERR(maybe_release_dir_info(pdb));
+              return SVN_NO_ERROR;
+            }
+          else
+            SVN_ERR(err);
+
+          all_work_items = svn_wc__wq_merge(all_work_items, work_item,
+                                            scratch_pool);
+        }
+      else
+        {
+          install_pristine = FALSE;
+          if (fb->new_text_base_sha1_checksum)
+            content_state = svn_wc_notify_state_changed;
+          else
+            content_state = svn_wc_notify_state_unchanged;
+        }
+
+      if (install_pristine)
+        {
+          svn_boolean_t record_fileinfo;
+
+          /* If we are installing from the pristine contents, then go ahead and
+             record the fileinfo. That will be the "proper" values. Installing
+             from some random file means the fileinfo does NOT correspond to
+             the pristine (in which case, the fileinfo will be cleared for
+             safety's sake).  */
+          record_fileinfo = (install_from == NULL);
+
+          SVN_ERR(svn_wc__wq_build_file_install(&work_item,
+                                                eb->db,
+                                                fb->local_abspath,
+                                                install_from,
+                                                eb->use_commit_times,
+                                                record_fileinfo,
+                                                scratch_pool, scratch_pool));
+          all_work_items = svn_wc__wq_merge(all_work_items, work_item,
+                                            scratch_pool);
+        }
+      else if (lock_state == svn_wc_notify_lock_state_unlocked
+               && !fb->obstruction_found)
+        {
+          /* If a lock was removed and we didn't update the text contents, we
+             might need to set the file read-only.
+
+             Note: this will also update the executable flag, but ... meh.  */
+          SVN_ERR(svn_wc__wq_build_sync_file_flags(&work_item, eb->db,
+                                                   fb->local_abspath,
+                                                   scratch_pool, scratch_pool));
+          all_work_items = svn_wc__wq_merge(all_work_items, work_item,
+                                            scratch_pool);
+        }
+
+      if (! install_pristine
+          && (content_state == svn_wc_notify_state_unchanged))
+        {
+          /* It is safe to keep the current recorded timestamp and size */
+          keep_recorded_info = TRUE;
+        }
+
+      /* Clean up any temporary files.  */
+
+      /* Remove the INSTALL_FROM file, as long as it doesn't refer to the
+         working file.  */
+      if (install_from != NULL
+          && strcmp(install_from, fb->local_abspath) != 0)
+        {
+          SVN_ERR(svn_wc__wq_build_file_remove(&work_item, eb->db,
+                                               fb->local_abspath, install_from,
+                                               scratch_pool, scratch_pool));
+          all_work_items = svn_wc__wq_merge(all_work_items, work_item,
+                                            scratch_pool);
+        }
+    }
+  else
+    {
+      /* Adding or updating a BASE node under a locally added node. */
+      apr_hash_t *fake_actual_props;
+
+      if (fb->adding_file)
+        fake_actual_props = apr_hash_make(scratch_pool);
+      else
+        fake_actual_props = current_base_props;
+
+      /* Store the incoming props (sent as propchanges) in new_base_props
+         and create a set of new actual props to use for notifications */
+      new_base_props = svn_prop__patch(current_base_props, regular_prop_changes,
+                                       scratch_pool);
+      SVN_ERR(svn_wc__merge_props(&conflict_skel,
+                                  &prop_state,
+                                  &new_actual_props,
+                                  eb->db,
+                                  fb->local_abspath,
+                                  NULL /* server_baseprops (not merging) */,
+                                  current_base_props /* pristine_props */,
+                                  fake_actual_props /* actual_props */,
+                                  regular_prop_changes, /* propchanges */
+                                  scratch_pool,
+                                  scratch_pool));
+
+      if (fb->new_text_base_sha1_checksum)
+        content_state = svn_wc_notify_state_changed;
+      else
+        content_state = svn_wc_notify_state_unchanged;
+    }
+
+  /* Insert/replace the BASE node with all of the new metadata.  */
+
+  /* Set the 'checksum' column of the file's BASE_NODE row to
+   * NEW_TEXT_BASE_SHA1_CHECKSUM.  The pristine text identified by that
+   * checksum is already in the pristine store. */
+  new_checksum = fb->new_text_base_sha1_checksum;
+
+  /* If we don't have a NEW checksum, then the base must not have changed.
+     Just carry over the old checksum.  */
+  if (new_checksum == NULL)
+    new_checksum = fb->original_checksum;
+
+  if (conflict_skel)
+    {
+      SVN_ERR(complete_conflict(conflict_skel,
+                                fb->edit_baton,
+                                fb->local_abspath,
+                                fb->old_repos_relpath,
+                                fb->old_revision,
+                                fb->new_relpath,
+                                svn_node_file, svn_node_file,
+                                fb->pool, scratch_pool));
+
+      SVN_ERR(svn_wc__conflict_create_markers(&work_item,
+                                              eb->db, fb->local_abspath,
+                                              conflict_skel,
+                                              scratch_pool, scratch_pool));
+
+      all_work_items = svn_wc__wq_merge(all_work_items, work_item,
+                                        scratch_pool);
+    }
+
+  /* Any inherited props to be set set for this base node? */
+  if (eb->wcroot_iprops)
+    {
+      iprops = svn_hash_gets(eb->wcroot_iprops, fb->local_abspath);
+
+      /* close_edit may also update iprops for switched nodes, catching
+         those for which close_directory is never called (e.g. a switch
+         with no changes).  So as a minor optimization we remove any
+         iprops from the hash so as not to set them again in
+         close_edit. */
+      if (iprops)
+        svn_hash_sets(eb->wcroot_iprops, fb->local_abspath, NULL);
+    }
+
+  SVN_ERR(svn_wc__db_base_add_file(eb->db, fb->local_abspath,
+                                   eb->wcroot_abspath,
+                                   fb->new_relpath,
+                                   eb->repos_root, eb->repos_uuid,
+                                   *eb->target_revision,
+                                   new_base_props,
+                                   fb->changed_rev,
+                                   fb->changed_date,
+                                   fb->changed_author,
+                                   new_checksum,
+                                   (dav_prop_changes->nelts > 0)
+                                     ? svn_prop_array_to_hash(
+                                                      dav_prop_changes,
+                                                      scratch_pool)
+                                     : NULL,
+                                   (fb->add_existed && fb->adding_file),
+                                   (! fb->shadowed) && new_base_props,
+                                   new_actual_props,
+                                   iprops,
+                                   keep_recorded_info,
+                                   (fb->shadowed && fb->obstruction_found),
+                                   conflict_skel,
+                                   all_work_items,
+                                   scratch_pool));
+
+  if (conflict_skel && eb->conflict_func)
+    SVN_ERR(svn_wc__conflict_invoke_resolver(eb->db, fb->local_abspath,
+                                             conflict_skel,
+                                             NULL /* merge_options */,
+                                             eb->conflict_func,
+                                             eb->conflict_baton,
+                                             eb->cancel_func,
+                                             eb->cancel_baton,
+                                             scratch_pool));
+
+  /* Deal with the WORKING tree, based on updates to the BASE tree.  */
+
+  svn_hash_sets(fb->dir_baton->not_present_files, fb->name, NULL);
+
+  /* Send a notification to the callback function.  (Skip notifications
+     about files which were already notified for another reason.) */
+  if (eb->notify_func && !fb->already_notified
+      && (fb->edited || lock_state == svn_wc_notify_lock_state_unlocked))
+    {
+      svn_wc_notify_t *notify;
+      svn_wc_notify_action_t action = svn_wc_notify_update_update;
+
+      if (fb->edited)
+        {
+          if (fb->shadowed || fb->edit_obstructed)
+            action = fb->adding_file
+                            ? svn_wc_notify_update_shadowed_add
+                            : svn_wc_notify_update_shadowed_update;
+          else if (fb->obstruction_found || fb->add_existed)
+            {
+              if (content_state != svn_wc_notify_state_conflicted)
+                action = svn_wc_notify_exists;
+            }
+          else if (fb->adding_file)
+            {
+              action = svn_wc_notify_update_add;
+            }
+        }
+      else
+        {
+          SVN_ERR_ASSERT(lock_state == svn_wc_notify_lock_state_unlocked);
+          action = svn_wc_notify_update_broken_lock;
+        }
+
+      /* If the file was moved-away, notify for the moved-away node.
+       * The original location only had its BASE info changed and
+       * we don't usually notify about such changes. */
+      notify = svn_wc_create_notify(fb->local_abspath, action, scratch_pool);
+      notify->kind = svn_node_file;
+      notify->content_state = content_state;
+      notify->prop_state = prop_state;
+      notify->lock_state = lock_state;
+      notify->revision = *eb->target_revision;
+      notify->old_revision = fb->old_revision;
+
+      /* Fetch the mimetype from the actual properties */
+      notify->mime_type = svn_prop_get_value(new_actual_props,
+                                             SVN_PROP_MIME_TYPE);
+
+      eb->notify_func(eb->notify_baton, notify, scratch_pool);
+    }
+
+  svn_pool_destroy(fb->pool); /* Destroy scratch_pool */
+
+  /* We have one less referrer to the directory */
+  SVN_ERR(maybe_release_dir_info(pdb));
+
+  return SVN_NO_ERROR;
+}
+
+
+/* An svn_delta_editor_t function. */
+static svn_error_t *
+close_edit(void *edit_baton,
+           apr_pool_t *pool)
+{
+  struct edit_baton *eb = edit_baton;
+  apr_pool_t *scratch_pool = eb->pool;
+
+  /* The editor didn't even open the root; we have to take care of
+     some cleanup stuffs. */
+  if (! eb->root_opened
+      && *eb->target_basename == '\0')
+    {
+      /* We need to "un-incomplete" the root directory. */
+      SVN_ERR(svn_wc__db_temp_op_end_directory_update(eb->db,
+                                                      eb->anchor_abspath,
+                                                      scratch_pool));
+    }
+
+  /* By definition, anybody "driving" this editor for update or switch
+     purposes at a *minimum* must have called set_target_revision() at
+     the outset, and close_edit() at the end -- even if it turned out
+     that no changes ever had to be made, and open_root() was never
+     called.  That's fine.  But regardless, when the edit is over,
+     this editor needs to make sure that *all* paths have had their
+     revisions bumped to the new target revision. */
+
+  /* Make sure our update target now has the new working revision.
+     Also, if this was an 'svn switch', then rewrite the target's
+     url.  All of this tweaking might happen recursively!  Note
+     that if eb->target is NULL, that's okay (albeit "sneaky",
+     some might say).  */
+
+  /* Extra check: if the update did nothing but make its target
+     'deleted', then do *not* run cleanup on the target, as it
+     will only remove the deleted entry!  */
+  if (! eb->target_deleted)
+    {
+      SVN_ERR(svn_wc__db_op_bump_revisions_post_update(eb->db,
+                                                       eb->target_abspath,
+                                                       eb->requested_depth,
+                                                       eb->switch_relpath,
+                                                       eb->repos_root,
+                                                       eb->repos_uuid,
+                                                       *(eb->target_revision),
+                                                       eb->skipped_trees,
+                                                       eb->wcroot_iprops,
+                                                       eb->notify_func,
+                                                       eb->notify_baton,
+                                                       eb->pool));
+
+      if (*eb->target_basename != '\0')
+        {
+          svn_wc__db_status_t status;
+          svn_error_t *err;
+
+          /* Note: we are fetching information about the *target*, not anchor.
+             There is no guarantee that the target has a BASE node.
+             For example:
+
+               The node was not present in BASE, but locally-added, and the
+               update did not create a new BASE node "under" the local-add.
+
+             If there is no BASE node for the target, then we certainly don't
+             have to worry about removing it. */
+          err = svn_wc__db_base_get_info(&status, NULL, NULL, NULL, NULL, NULL,
+                                         NULL, NULL, NULL, NULL, NULL, NULL,
+                                         NULL, NULL, NULL, NULL,
+                                         eb->db, eb->target_abspath,
+                                         scratch_pool, scratch_pool);
+          if (err)
+            {
+              if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+                return svn_error_trace(err);
+
+              svn_error_clear(err);
+            }
+          else if (status == svn_wc__db_status_excluded)
+            {
+              /* There is a small chance that the explicit target of an update/
+                 switch is gone in the repository, in that specific case the
+                 node hasn't been re-added to the BASE tree by this update.
+
+                 If so, we should get rid of this excluded node now. */
+
+              SVN_ERR(svn_wc__db_base_remove(eb->db, eb->target_abspath,
+                                             FALSE /* keep_as_working */,
+                                             FALSE /* queue_deletes */,
+                                             SVN_INVALID_REVNUM,
+                                             NULL, NULL, scratch_pool));
+            }
+        }
+    }
+
+  /* The edit is over: run the wq with proper cancel support,
+     but first kill the handler that would run it on the pool
+     cleanup at the end of this function. */
+  apr_pool_cleanup_kill(eb->pool, eb, cleanup_edit_baton);
+
+  SVN_ERR(svn_wc__wq_run(eb->db, eb->wcroot_abspath,
+                         eb->cancel_func, eb->cancel_baton,
+                         eb->pool));
+
+  /* The edit is over, free its pool.
+     ### No, this is wrong.  Who says this editor/baton won't be used
+     again?  But the change is not merely to remove this call.  We
+     should also make eb->pool not be a subpool (see make_editor),
+     and change callers of svn_client_{checkout,update,switch} to do
+     better pool management. ### */
+
+  svn_pool_destroy(eb->pool);
+
+  return SVN_NO_ERROR;
+}
+
+
+/*** Returning editors. ***/
+
+/* Helper for the three public editor-supplying functions. */
+static svn_error_t *
+make_editor(svn_revnum_t *target_revision,
+            svn_wc__db_t *db,
+            const char *anchor_abspath,
+            const char *target_basename,
+            apr_hash_t *wcroot_iprops,
+            svn_boolean_t use_commit_times,
+            const char *switch_url,
+            svn_depth_t depth,
+            svn_boolean_t depth_is_sticky,
+            svn_boolean_t allow_unver_obstructions,
+            svn_boolean_t adds_as_modification,
+            svn_boolean_t server_performs_filtering,
+            svn_boolean_t clean_checkout,
+            svn_wc_notify_func2_t notify_func,
+            void *notify_baton,
+            svn_cancel_func_t cancel_func,
+            void *cancel_baton,
+            svn_wc_dirents_func_t fetch_dirents_func,
+            void *fetch_dirents_baton,
+            svn_wc_conflict_resolver_func2_t conflict_func,
+            void *conflict_baton,
+            svn_wc_external_update_t external_func,
+            void *external_baton,
+            const char *diff3_cmd,
+            const apr_array_header_t *preserved_exts,
+            const svn_delta_editor_t **editor,
+            void **edit_baton,
+            apr_pool_t *result_pool,
+            apr_pool_t *scratch_pool)
+{
+  struct edit_baton *eb;
+  void *inner_baton;
+  apr_pool_t *edit_pool = svn_pool_create(result_pool);
+  svn_delta_editor_t *tree_editor = svn_delta_default_editor(edit_pool);
+  const svn_delta_editor_t *inner_editor;
+  const char *repos_root, *repos_uuid;
+  struct svn_wc__shim_fetch_baton_t *sfb;
+  svn_delta_shim_callbacks_t *shim_callbacks =
+                                svn_delta_shim_callbacks_default(edit_pool);
+
+  /* An unknown depth can't be sticky. */
+  if (depth == svn_depth_unknown)
+    depth_is_sticky = FALSE;
+
+  /* Get the anchor's repository root and uuid. The anchor must already exist
+     in BASE. */
+  SVN_ERR(svn_wc__db_scan_base_repos(NULL, &repos_root, &repos_uuid,
+                                     db, anchor_abspath,
+                                     result_pool, scratch_pool));
+
+  /* With WC-NG we need a valid repository root */
+  SVN_ERR_ASSERT(repos_root != NULL && repos_uuid != NULL);
+
+  /* Disallow a switch operation to change the repository root of the target,
+     if that is known. */
+  if (switch_url && !svn_uri__is_ancestor(repos_root, switch_url))
+    return svn_error_createf(SVN_ERR_WC_INVALID_SWITCH, NULL,
+                             _("'%s'\nis not the same repository as\n'%s'"),
+                             switch_url, repos_root);
+
+  /* Construct an edit baton. */
+  eb = apr_pcalloc(edit_pool, sizeof(*eb));
+  eb->pool                     = edit_pool;
+  eb->use_commit_times         = use_commit_times;
+  eb->target_revision          = target_revision;
+  eb->repos_root               = repos_root;
+  eb->repos_uuid               = repos_uuid;
+  eb->db                       = db;
+  eb->target_basename          = target_basename;
+  eb->anchor_abspath           = anchor_abspath;
+  eb->wcroot_iprops            = wcroot_iprops;
+
+  SVN_ERR(svn_wc__db_get_wcroot(&eb->wcroot_abspath, db, anchor_abspath,
+                                edit_pool, scratch_pool));
+
+  if (switch_url)
+    eb->switch_relpath =
+      svn_uri_skip_ancestor(repos_root, switch_url, scratch_pool);
+  else
+    eb->switch_relpath = NULL;
+
+  if (svn_path_is_empty(target_basename))
+    eb->target_abspath = eb->anchor_abspath;
+  else
+    eb->target_abspath = svn_dirent_join(eb->anchor_abspath, target_basename,
+                                         edit_pool);
+
+  eb->requested_depth          = depth;
+  eb->depth_is_sticky          = depth_is_sticky;
+  eb->notify_func              = notify_func;
+  eb->notify_baton             = notify_baton;
+  eb->external_func            = external_func;
+  eb->external_baton           = external_baton;
+  eb->diff3_cmd                = diff3_cmd;
+  eb->cancel_func              = cancel_func;
+  eb->cancel_baton             = cancel_baton;
+  eb->conflict_func            = conflict_func;
+  eb->conflict_baton           = conflict_baton;
+  eb->allow_unver_obstructions = allow_unver_obstructions;
+  eb->adds_as_modification     = adds_as_modification;
+  eb->clean_checkout           = clean_checkout;
+  eb->skipped_trees            = apr_hash_make(edit_pool);
+  eb->dir_dirents              = apr_hash_make(edit_pool);
+  eb->ext_patterns             = preserved_exts;
+
+  apr_pool_cleanup_register(edit_pool, eb, cleanup_edit_baton,
+                            apr_pool_cleanup_null);
+
+  /* Construct an editor. */
+  tree_editor->set_target_revision = set_target_revision;
+  tree_editor->open_root = open_root;
+  tree_editor->delete_entry = delete_entry;
+  tree_editor->add_directory = add_directory;
+  tree_editor->open_directory = open_directory;
+  tree_editor->change_dir_prop = change_dir_prop;
+  tree_editor->close_directory = close_directory;
+  tree_editor->absent_directory = absent_directory;
+  tree_editor->add_file = add_file;
+  tree_editor->open_file = open_file;
+  tree_editor->apply_textdelta = apply_textdelta;
+  tree_editor->change_file_prop = change_file_prop;
+  tree_editor->close_file = close_file;
+  tree_editor->absent_file = absent_file;
+  tree_editor->close_edit = close_edit;
+
+  /* Fiddle with the type system. */
+  inner_editor = tree_editor;
+  inner_baton = eb;
+
+  if (!depth_is_sticky
+      && depth != svn_depth_unknown
+      && svn_depth_empty <= depth && depth < svn_depth_infinity
+      && fetch_dirents_func)
+    {
+      /* We are asked to perform an update at a depth less than the ambient
+         depth. In this case the update won't describe additions that would
+         have been reported if we updated at the ambient depth. */
+      svn_error_t *err;
+      svn_node_kind_t dir_kind;
+      svn_wc__db_status_t dir_status;
+      const char *dir_repos_relpath;
+      svn_depth_t dir_depth;
+
+      /* we have to do this on the target of the update, not the anchor */
+      err = svn_wc__db_base_get_info(&dir_status, &dir_kind, NULL,
+                                     &dir_repos_relpath, NULL, NULL, NULL,
+                                     NULL, NULL, &dir_depth, NULL, NULL, NULL,
+                                     NULL, NULL, NULL,
+                                     db, eb->target_abspath,
+                                     scratch_pool, scratch_pool);
+
+      if (!err
+          && dir_kind == svn_node_dir
+          && dir_status == svn_wc__db_status_normal)
+        {
+          if (dir_depth > depth)
+            {
+              apr_hash_t *dirents;
+
+              /* If we switch, we should look at the new relpath */
+              if (eb->switch_relpath)
+                dir_repos_relpath = eb->switch_relpath;
+
+              SVN_ERR(fetch_dirents_func(fetch_dirents_baton, &dirents,
+                                         repos_root, dir_repos_relpath,
+                                         edit_pool, scratch_pool));
+
+              if (dirents != NULL && apr_hash_count(dirents))
+                svn_hash_sets(eb->dir_dirents,
+                              apr_pstrdup(edit_pool, dir_repos_relpath),
+                              dirents);
+            }
+
+          if (depth == svn_depth_immediates)
+            {
+              /* Worst case scenario of issue #3569 fix: We have to do the
+                 same for all existing subdirs, but then we check for
+                 svn_depth_empty. */
+              const apr_array_header_t *children;
+              apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+              int i;
+              SVN_ERR(svn_wc__db_base_get_children(&children, db,
+                                                   eb->target_abspath,
+                                                   scratch_pool,
+                                                   iterpool));
+
+              for (i = 0; i < children->nelts; i++)
+                {
+                  const char *child_abspath;
+                  const char *child_name;
+
+                  svn_pool_clear(iterpool);
+
+                  child_name = APR_ARRAY_IDX(children, i, const char *);
+
+                  child_abspath = svn_dirent_join(eb->target_abspath,
+                                                  child_name, iterpool);
+
+                  SVN_ERR(svn_wc__db_base_get_info(&dir_status, &dir_kind,
+                                                   NULL, &dir_repos_relpath,
+                                                   NULL, NULL, NULL, NULL,
+                                                   NULL, &dir_depth, NULL,
+                                                   NULL, NULL, NULL, NULL,
+                                                   NULL,
+                                                   db, child_abspath,
+                                                   iterpool, iterpool));
+
+                  if (dir_kind == svn_node_dir
+                      && dir_status == svn_wc__db_status_normal
+                      && dir_depth > svn_depth_empty)
+                    {
+                      apr_hash_t *dirents;
+
+                      /* If we switch, we should look at the new relpath */
+                      if (eb->switch_relpath)
+                        dir_repos_relpath = svn_relpath_join(
+                                                eb->switch_relpath,
+                                                child_name, iterpool);
+
+                      SVN_ERR(fetch_dirents_func(fetch_dirents_baton, &dirents,
+                                                 repos_root, dir_repos_relpath,
+                                                 edit_pool, iterpool));
+
+                      if (dirents != NULL && apr_hash_count(dirents))
+                        svn_hash_sets(eb->dir_dirents,
+                                      apr_pstrdup(edit_pool,
+                                                  dir_repos_relpath),
+                                      dirents);
+                    }
+                }
+            }
+        }
+      else if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
+        svn_error_clear(err);
+      else
+        SVN_ERR(err);
+    }
+
+  /* We need to limit the scope of our operation to the ambient depths
+     present in the working copy already, but only if the requested
+     depth is not sticky. If a depth was explicitly requested,
+     libsvn_delta/depth_filter_editor.c will ensure that we never see
+     editor calls that extend beyond the scope of the requested depth.
+     But even what we do so might extend beyond the scope of our
+     ambient depth.  So we use another filtering editor to avoid
+     modifying the ambient working copy depth when not asked to do so.
+     (This can also be skipped if the server understands depth.) */
+  if (!server_performs_filtering
+      && !depth_is_sticky)
+    SVN_ERR(svn_wc__ambient_depth_filter_editor(&inner_editor,
+                                                &inner_baton,
+                                                db,
+                                                anchor_abspath,
+                                                target_basename,
+                                                inner_editor,
+                                                inner_baton,
+                                                result_pool));
+
+  SVN_ERR(svn_delta_get_cancellation_editor(cancel_func,
+                                            cancel_baton,
+                                            inner_editor,
+                                            inner_baton,
+                                            editor,
+                                            edit_baton,
+                                            result_pool));
+
+  sfb = apr_palloc(result_pool, sizeof(*sfb));
+  sfb->db = db;
+  sfb->base_abspath = eb->anchor_abspath;
+  sfb->fetch_base = TRUE;
+
+  shim_callbacks->fetch_kind_func = svn_wc__fetch_kind_func;
+  shim_callbacks->fetch_props_func = svn_wc__fetch_props_func;
+  shim_callbacks->fetch_base_func = svn_wc__fetch_base_func;
+  shim_callbacks->fetch_baton = sfb;
+
+  SVN_ERR(svn_editor__insert_shims(editor, edit_baton, *editor, *edit_baton,
+                                   NULL, NULL, shim_callbacks,
+                                   result_pool, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_wc__get_update_editor(const svn_delta_editor_t **editor,
+                          void **edit_baton,
+                          svn_revnum_t *target_revision,
+                          svn_wc_context_t *wc_ctx,
+                          const char *anchor_abspath,
+                          const char *target_basename,
+                          apr_hash_t *wcroot_iprops,
+                          svn_boolean_t use_commit_times,
+                          svn_depth_t depth,
+                          svn_boolean_t depth_is_sticky,
+                          svn_boolean_t allow_unver_obstructions,
+                          svn_boolean_t adds_as_modification,
+                          svn_boolean_t server_performs_filtering,
+                          svn_boolean_t clean_checkout,
+                          const char *diff3_cmd,
+                          const apr_array_header_t *preserved_exts,
+                          svn_wc_dirents_func_t fetch_dirents_func,
+                          void *fetch_dirents_baton,
+                          svn_wc_conflict_resolver_func2_t conflict_func,
+                          void *conflict_baton,
+                          svn_wc_external_update_t external_func,
+                          void *external_baton,
+                          svn_cancel_func_t cancel_func,
+                          void *cancel_baton,
+                          svn_wc_notify_func2_t notify_func,
+                          void *notify_baton,
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool)
+{
+  return make_editor(target_revision, wc_ctx->db, anchor_abspath,
+                     target_basename, wcroot_iprops, use_commit_times,
+                     NULL, depth, depth_is_sticky, allow_unver_obstructions,
+                     adds_as_modification, server_performs_filtering,
+                     clean_checkout,
+                     notify_func, notify_baton,
+                     cancel_func, cancel_baton,
+                     fetch_dirents_func, fetch_dirents_baton,
+                     conflict_func, conflict_baton,
+                     external_func, external_baton,
+                     diff3_cmd, preserved_exts, editor, edit_baton,
+                     result_pool, scratch_pool);
+}
+
+svn_error_t *
+svn_wc__get_switch_editor(const svn_delta_editor_t **editor,
+                          void **edit_baton,
+                          svn_revnum_t *target_revision,
+                          svn_wc_context_t *wc_ctx,
+                          const char *anchor_abspath,
+                          const char *target_basename,
+                          const char *switch_url,
+                          apr_hash_t *wcroot_iprops,
+                          svn_boolean_t use_commit_times,
+                          svn_depth_t depth,
+                          svn_boolean_t depth_is_sticky,
+                          svn_boolean_t allow_unver_obstructions,
+                          svn_boolean_t server_performs_filtering,
+                          const char *diff3_cmd,
+                          const apr_array_header_t *preserved_exts,
+                          svn_wc_dirents_func_t fetch_dirents_func,
+                          void *fetch_dirents_baton,
+                          svn_wc_conflict_resolver_func2_t conflict_func,
+                          void *conflict_baton,
+                          svn_wc_external_update_t external_func,
+                          void *external_baton,
+                          svn_cancel_func_t cancel_func,
+                          void *cancel_baton,
+                          svn_wc_notify_func2_t notify_func,
+                          void *notify_baton,
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool)
+{
+  SVN_ERR_ASSERT(switch_url && svn_uri_is_canonical(switch_url, scratch_pool));
+
+  return make_editor(target_revision, wc_ctx->db, anchor_abspath,
+                     target_basename, wcroot_iprops, use_commit_times,
+                     switch_url,
+                     depth, depth_is_sticky, allow_unver_obstructions,
+                     FALSE /* adds_as_modification */,
+                     server_performs_filtering,
+                     FALSE /* clean_checkout */,
+                     notify_func, notify_baton,
+                     cancel_func, cancel_baton,
+                     fetch_dirents_func, fetch_dirents_baton,
+                     conflict_func, conflict_baton,
+                     external_func, external_baton,
+                     diff3_cmd, preserved_exts,
+                     editor, edit_baton,
+                     result_pool, scratch_pool);
+}
+
+
+
+/* ### Note that this function is completely different from the rest of the
+       update editor in what it updates. The update editor changes only BASE
+       and ACTUAL and this function just changes WORKING and ACTUAL.
+
+       In the entries world this function shared a lot of code with the
+       update editor but in the wonderful new WC-NG world it will probably
+       do more and more by itself and would be more logically grouped with
+       the add/copy functionality in adm_ops.c and copy.c. */
+svn_error_t *
+svn_wc_add_repos_file4(svn_wc_context_t *wc_ctx,
+                       const char *local_abspath,
+                       svn_stream_t *new_base_contents,
+                       svn_stream_t *new_contents,
+                       apr_hash_t *new_base_props,
+                       apr_hash_t *new_props,
+                       const char *copyfrom_url,
+                       svn_revnum_t copyfrom_rev,
+                       svn_cancel_func_t cancel_func,
+                       void *cancel_baton,
+                       apr_pool_t *scratch_pool)
+{
+  svn_wc__db_t *db = wc_ctx->db;
+  const char *dir_abspath = svn_dirent_dirname(local_abspath, scratch_pool);
+  svn_wc__db_status_t status;
+  svn_node_kind_t kind;
+  const char *tmp_text_base_abspath;
+  svn_checksum_t *new_text_base_md5_checksum;
+  svn_checksum_t *new_text_base_sha1_checksum;
+  const char *source_abspath = NULL;
+  svn_skel_t *all_work_items = NULL;
+  svn_skel_t *work_item;
+  const char *repos_root_url;
+  const char *repos_uuid;
+  const char *original_repos_relpath;
+  svn_revnum_t changed_rev;
+  apr_time_t changed_date;
+  const char *changed_author;
+  svn_error_t *err;
+  apr_pool_t *pool = scratch_pool;
+
+  SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
+  SVN_ERR_ASSERT(new_base_contents != NULL);
+  SVN_ERR_ASSERT(new_base_props != NULL);
+
+  /* We should have a write lock on this file's parent directory.  */
+  SVN_ERR(svn_wc__write_check(db, dir_abspath, pool));
+
+  err = svn_wc__db_read_info(&status, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                             NULL, NULL, NULL,
+                             db, local_abspath, scratch_pool, scratch_pool);
+
+  if (err && err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+    return svn_error_trace(err);
+  else if(err)
+    svn_error_clear(err);
+  else
+    switch (status)
+      {
+        case svn_wc__db_status_not_present:
+        case svn_wc__db_status_deleted:
+          break;
+        default:
+          return svn_error_createf(SVN_ERR_ENTRY_EXISTS, NULL,
+                                   _("Node '%s' exists."),
+                                   svn_dirent_local_style(local_abspath,
+                                                          scratch_pool));
+      }
+
+  SVN_ERR(svn_wc__db_read_info(&status, &kind, NULL, NULL, &repos_root_url,
+                               &repos_uuid, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                               db, dir_abspath, scratch_pool, scratch_pool));
+
+  switch (status)
+    {
+      case svn_wc__db_status_normal:
+      case svn_wc__db_status_added:
+        break;
+      case svn_wc__db_status_deleted:
+        return
+          svn_error_createf(SVN_ERR_WC_SCHEDULE_CONFLICT, NULL,
+                            _("Can't add '%s' to a parent directory"
+                              " scheduled for deletion"),
+                            svn_dirent_local_style(local_abspath,
+                                                   scratch_pool));
+      default:
+        return svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, err,
+                                 _("Can't find parent directory's node while"
+                                   " trying to add '%s'"),
+                                 svn_dirent_local_style(local_abspath,
+                                                        scratch_pool));
+    }
+  if (kind != svn_node_dir)
+    return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
+                             _("Can't schedule an addition of '%s'"
+                               " below a not-directory node"),
+                             svn_dirent_local_style(local_abspath,
+                                                    scratch_pool));
+
+  /* Fabricate the anticipated new URL of the target and check the
+     copyfrom URL to be in the same repository. */
+  if (copyfrom_url != NULL)
+    {
+      /* Find the repository_root via the parent directory, which
+         is always versioned before this function is called */
+
+      if (!repos_root_url)
+        {
+          /* The parent is an addition, scan upwards to find the right info */
+          SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, NULL,
+                                           &repos_root_url, &repos_uuid,
+                                           NULL, NULL, NULL, NULL,
+                                           wc_ctx->db, dir_abspath,
+                                           scratch_pool, scratch_pool));
+        }
+      SVN_ERR_ASSERT(repos_root_url);
+
+      original_repos_relpath =
+          svn_uri_skip_ancestor(repos_root_url, copyfrom_url, scratch_pool);
+
+      if (!original_repos_relpath)
+        return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
+                                 _("Copyfrom-url '%s' has different repository"
+                                   " root than '%s'"),
+                                 copyfrom_url, repos_root_url);
+    }
+  else
+    {
+      original_repos_relpath = NULL;
+      copyfrom_rev = SVN_INVALID_REVNUM;  /* Just to be sure.  */
+    }
+
+  /* Set CHANGED_* to reflect the entry props in NEW_BASE_PROPS, and
+     filter NEW_BASE_PROPS so it contains only regular props. */
+  {
+    apr_array_header_t *regular_props;
+    apr_array_header_t *entry_props;
+
+    SVN_ERR(svn_categorize_props(svn_prop_hash_to_array(new_base_props, pool),
+                                 &entry_props, NULL, &regular_props,
+                                 pool));
+
+    /* Put regular props back into a hash table. */
+    new_base_props = svn_prop_array_to_hash(regular_props, pool);
+
+    /* Get the change_* info from the entry props.  */
+    SVN_ERR(accumulate_last_change(&changed_rev,
+                                   &changed_date,
+                                   &changed_author,
+                                   entry_props, pool, pool));
+  }
+
+  /* Copy NEW_BASE_CONTENTS into a temporary file so our log can refer to
+     it, and set TMP_TEXT_BASE_ABSPATH to its path.  Compute its
+     NEW_TEXT_BASE_MD5_CHECKSUM and NEW_TEXT_BASE_SHA1_CHECKSUM as we copy. */
+  {
+    svn_stream_t *tmp_base_contents;
+
+    SVN_ERR(svn_wc__open_writable_base(&tmp_base_contents,
+                                       &tmp_text_base_abspath,
+                                       &new_text_base_md5_checksum,
+                                       &new_text_base_sha1_checksum,
+                                       wc_ctx->db, local_abspath,
+                                       pool, pool));
+    SVN_ERR(svn_stream_copy3(new_base_contents, tmp_base_contents,
+                             cancel_func, cancel_baton, pool));
+  }
+
+  /* If the caller gave us a new working file, copy it to a safe (temporary)
+     location and set SOURCE_ABSPATH to that path. We'll then translate/copy
+     that into place after the node's state has been created.  */
+  if (new_contents)
+    {
+      const char *temp_dir_abspath;
+      svn_stream_t *tmp_contents;
+
+      SVN_ERR(svn_wc__db_temp_wcroot_tempdir(&temp_dir_abspath, db,
+                                             local_abspath, pool, pool));
+      SVN_ERR(svn_stream_open_unique(&tmp_contents, &source_abspath,
+                                     temp_dir_abspath, svn_io_file_del_none,
+                                     pool, pool));
+      SVN_ERR(svn_stream_copy3(new_contents, tmp_contents,
+                               cancel_func, cancel_baton, pool));
+    }
+
+  /* Install new text base for copied files. Added files do NOT have a
+     text base.  */
+  if (copyfrom_url != NULL)
+    {
+      SVN_ERR(svn_wc__db_pristine_install(db, tmp_text_base_abspath,
+                                          new_text_base_sha1_checksum,
+                                          new_text_base_md5_checksum, pool));
+    }
+  else
+    {
+      /* ### There's something wrong around here.  Sometimes (merge from a
+         foreign repository, at least) we are called with copyfrom_url =
+         NULL and an empty new_base_contents (and an empty set of
+         new_base_props).  Why an empty "new base"?
+
+         That happens in merge_tests.py 54,87,88,89,143.
+
+         In that case, having been given this supposed "new base" file, we
+         copy it and calculate its checksum but do not install it.  Why?
+         That must be wrong.
+
+         To crudely work around one issue with this, that we shouldn't
+         record a checksum in the database if we haven't installed the
+         corresponding pristine text, for now we'll just set the checksum
+         to NULL.
+
+         The proper solution is probably more like: the caller should pass
+         NULL for the missing information, and this function should learn to
+         handle that. */
+
+      new_text_base_sha1_checksum = NULL;
+      new_text_base_md5_checksum = NULL;
+    }
+
+  /* For added files without NEW_CONTENTS, then generate the working file
+     from the provided "pristine" contents.  */
+  if (new_contents == NULL && copyfrom_url == NULL)
+    source_abspath = tmp_text_base_abspath;
+
+  {
+    svn_boolean_t record_fileinfo;
+
+    /* If new contents were provided, then we do NOT want to record the
+       file information. We assume the new contents do not match the
+       "proper" values for RECORDED_SIZE and RECORDED_TIME.  */
+    record_fileinfo = (new_contents == NULL);
+
+    /* Install the working copy file (with appropriate translation) from
+       the appropriate source. SOURCE_ABSPATH will be NULL, indicating an
+       installation from the pristine (available for copied/moved files),
+       or it will specify a temporary file where we placed a "pristine"
+       (for an added file) or a detranslated local-mods file.  */
+    SVN_ERR(svn_wc__wq_build_file_install(&work_item,
+                                          db, local_abspath,
+                                          source_abspath,
+                                          FALSE /* use_commit_times */,
+                                          record_fileinfo,
+                                          pool, pool));
+    all_work_items = svn_wc__wq_merge(all_work_items, work_item, pool);
+
+    /* If we installed from somewhere besides the official pristine, then
+       it is a temporary file, which needs to be removed.  */
+    if (source_abspath != NULL)
+      {
+        SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db, local_abspath,
+                                             source_abspath,
+                                             pool, pool));
+        all_work_items = svn_wc__wq_merge(all_work_items, work_item, pool);
+      }
+  }
+
+  /* ### ideally, we would have a single DB operation, and queue the work
+     ### items on that. for now, we'll queue them with the second call.  */
+
+  SVN_ERR(svn_wc__db_op_copy_file(db, local_abspath,
+                                  new_base_props,
+                                  changed_rev,
+                                  changed_date,
+                                  changed_author,
+                                  original_repos_relpath,
+                                  original_repos_relpath ? repos_root_url
+                                                         : NULL,
+                                  original_repos_relpath ? repos_uuid : NULL,
+                                  copyfrom_rev,
+                                  new_text_base_sha1_checksum,
+                                  TRUE,
+                                  new_props,
+                                  FALSE /* is_move */,
+                                  NULL /* conflict */,
+                                  all_work_items,
+                                  pool));
+
+  return svn_error_trace(svn_wc__wq_run(db, dir_abspath,
+                                        cancel_func, cancel_baton,
+                                        pool));
+}
+
+svn_error_t *
+svn_wc__complete_directory_add(svn_wc_context_t *wc_ctx,
+                               const char *local_abspath,
+                               apr_hash_t *new_original_props,
+                               const char *copyfrom_url,
+                               svn_revnum_t copyfrom_rev,
+                               apr_pool_t *scratch_pool)
+{
+  svn_wc__db_status_t status;
+  svn_node_kind_t kind;
+  const char *original_repos_relpath;
+  const char *original_root_url;
+  const char *original_uuid;
+  svn_boolean_t had_props;
+  svn_boolean_t props_mod;
+
+  svn_revnum_t original_revision;
+  svn_revnum_t changed_rev;
+  apr_time_t changed_date;
+  const char *changed_author;
+
+  SVN_ERR(svn_wc__db_read_info(&status, &kind, NULL, NULL, NULL, NULL, NULL,
+                               NULL, NULL, NULL, NULL, NULL,
+                               &original_repos_relpath, &original_root_url,
+                               &original_uuid, &original_revision, NULL, NULL,
+                               NULL, NULL, NULL, NULL, &had_props, &props_mod,
+                               NULL, NULL, NULL,
+                               wc_ctx->db, local_abspath,
+                               scratch_pool, scratch_pool));
+
+  if (status != svn_wc__db_status_added
+      || kind != svn_node_dir
+      || had_props
+      || props_mod
+      || !original_repos_relpath)
+    {
+      return svn_error_createf(
+                    SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
+                    _("'%s' is not an unmodified copied directory"),
+                    svn_dirent_local_style(local_abspath, scratch_pool));
+    }
+  if (original_revision != copyfrom_rev
+      || strcmp(copyfrom_url,
+                 svn_path_url_add_component2(original_root_url,
+                                             original_repos_relpath,
+                                             scratch_pool)))
+    {
+      return svn_error_createf(
+                    SVN_ERR_WC_COPYFROM_PATH_NOT_FOUND, NULL,
+                    _("Copyfrom '%s' doesn't match original location of '%s'"),
+                    copyfrom_url,
+                    svn_dirent_local_style(local_abspath, scratch_pool));
+    }
+
+  {
+    apr_array_header_t *regular_props;
+    apr_array_header_t *entry_props;
+
+    SVN_ERR(svn_categorize_props(svn_prop_hash_to_array(new_original_props,
+                                                        scratch_pool),
+                                 &entry_props, NULL, &regular_props,
+                                 scratch_pool));
+
+    /* Put regular props back into a hash table. */
+    new_original_props = svn_prop_array_to_hash(regular_props, scratch_pool);
+
+    /* Get the change_* info from the entry props.  */
+    SVN_ERR(accumulate_last_change(&changed_rev,
+                                   &changed_date,
+                                   &changed_author,
+                                   entry_props, scratch_pool, scratch_pool));
+  }
+
+  return svn_error_trace(
+            svn_wc__db_op_copy_dir(wc_ctx->db, local_abspath,
+                                   new_original_props,
+                                   changed_rev, changed_date, changed_author,
+                                   original_repos_relpath, original_root_url,
+                                   original_uuid, original_revision,
+                                   NULL /* children */,
+                                   FALSE /* is_move */,
+                                   svn_depth_infinity,
+                                   NULL /* conflict */,
+                                   NULL /* work_items */,
+                                   scratch_pool));
+}