subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From i...@apache.org
Subject svn commit: r1658954 [5/22] - in /subversion/branches/reuse-ra-session: ./ build/generator/ build/generator/templates/ subversion/bindings/javahl/native/ subversion/bindings/javahl/native/jniwrapper/ subversion/bindings/swig/ subversion/include/ subver...
Date Wed, 11 Feb 2015 13:29:28 GMT
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_wc/wc_db_update_move.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_wc/wc_db_update_move.c?rev=1658954&r1=1658953&r2=1658954&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_wc/wc_db_update_move.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_wc/wc_db_update_move.c Wed Feb 11 13:29:26 2015
@@ -135,6 +135,44 @@ verify_write_lock(svn_wc__db_wcroot_t *w
   return SVN_NO_ERROR;
 }
 
+/* In our merge conflicts we record the move_op_src path, which is essentially
+   the depth at which what was moved is marked deleted. The problem is that
+   this depth is not guaranteed to be stable, because somebody might just
+   remove another ancestor, or revert one.
+
+   To work around this problem we locate the layer below this path, and use
+   that to pinpoint whatever is moved.
+
+   For a path SRC_RELPATH that was deleted by an operation rooted at
+   DELETE_OP_DEPTH find the op-depth at which the node was originally added.
+   */
+static svn_error_t *
+find_src_op_depth(int *src_op_depth,
+                  svn_wc__db_wcroot_t *wcroot,
+                  const char *src_relpath,
+                  int delete_op_depth,
+                  apr_pool_t *scratch_pool)
+{
+  svn_sqlite__stmt_t *stmt;
+  svn_boolean_t have_row;
+
+  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+                                    STMT_SELECT_HIGHEST_WORKING_NODE));
+  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
+                            src_relpath, delete_op_depth));
+
+  SVN_ERR(svn_sqlite__step(&have_row, stmt));
+  if (have_row)
+    *src_op_depth = svn_sqlite__column_int(stmt, 0);
+  SVN_ERR(svn_sqlite__reset(stmt));
+  if (!have_row)
+    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
+                              _("'%s' is not deleted"),
+                              path_for_error_message(wcroot, src_relpath,
+                                                    scratch_pool));
+
+  return SVN_NO_ERROR;
+}
 
 /*
  * Receiver code.
@@ -159,6 +197,9 @@ typedef struct update_move_baton_t {
   svn_wc_operation_t operation;
   svn_wc_conflict_version_t *old_version;
   svn_wc_conflict_version_t *new_version;
+
+  svn_cancel_func_t cancel_func;
+  void *cancel_baton;
 } update_move_baton_t;
 
 /* Per node flags for tree conflict collection */
@@ -206,8 +247,9 @@ update_move_list_add(svn_wc__db_wcroot_t
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
                                     STMT_INSERT_UPDATE_MOVE_LIST));
-  SVN_ERR(svn_sqlite__bindf(stmt, "sdddd", local_relpath,
-                            action, kind, content_state, prop_state));
+  SVN_ERR(svn_sqlite__bindf(stmt, "sdtdd", local_relpath,
+                            action, kind_map_none, kind,
+                            content_state, prop_state));
   SVN_ERR(svn_sqlite__step_done(stmt));
 
   if (conflict)
@@ -256,7 +298,7 @@ svn_wc__db_update_move_list_notify(svn_w
                                                         local_relpath,
                                                         iterpool),
                                         action, iterpool);
-          notify->kind = svn_sqlite__column_int(stmt, 2);
+          notify->kind = svn_sqlite__column_token(stmt, 2, kind_map_none);
           notify->content_state = svn_sqlite__column_int(stmt, 3);
           notify->prop_state = svn_sqlite__column_int(stmt, 4);
           notify->old_revision = old_revision;
@@ -488,9 +530,9 @@ check_node_shadowed(svn_boolean_t *shado
   return SVN_NO_ERROR;
 }
 
-/* Set a tree conflict for the shadowed node LOCAL_RELPATH, on the
-   ROOT OF THE OBSTRUCTION if such a tree-conflict does not already
-   exist.  KIND is the kind of the incoming LOCAL_RELPATH. */
+/* Set a tree conflict for the shadowed node LOCAL_RELPATH, which is
+   the ROOT OF THE OBSTRUCTION if such a tree-conflict does not
+   already exist.  KIND is the kind of the incoming LOCAL_RELPATH. */
 static svn_error_t *
 mark_tc_on_op_root(node_move_baton_t *nmb,
                    svn_node_kind_t old_kind,
@@ -500,48 +542,33 @@ mark_tc_on_op_root(node_move_baton_t *nm
                    apr_pool_t *scratch_pool)
 {
   update_move_baton_t *b = nmb->umb;
-  const char *conflict_root_relpath = nmb->dst_relpath;
-  const char *move_dst_relpath, *dummy1;
-  const char *dummy2, *move_src_op_root_relpath;
+  const char *move_dst_relpath;
   svn_skel_t *conflict;
 
-  SVN_ERR_ASSERT(nmb->shadowed);
+  SVN_ERR_ASSERT(nmb->shadowed && !nmb->pb->shadowed);
 
   nmb->skip = TRUE;
 
-  while (nmb->pb && nmb->pb->shadowed)
-    {
-      nmb = nmb->pb;
-
-      conflict_root_relpath = nmb->dst_relpath;
-
-      old_kind = new_kind = svn_node_dir;
-      if (old_repos_relpath)
-        old_repos_relpath = svn_relpath_dirname(old_repos_relpath,
-                                                scratch_pool);
-      action = svn_wc_conflict_action_edit;
-
-      nmb->skip = TRUE;
-    }
-
-  SVN_ERR(svn_wc__db_op_depth_moved_to(&move_dst_relpath,
-                                       &dummy1,
-                                       &dummy2,
-                                       &move_src_op_root_relpath,
-                                       b->dst_op_depth,
-                                       b->wcroot, conflict_root_relpath,
-                                       scratch_pool, scratch_pool));
+  if (old_kind == svn_node_none)
+    move_dst_relpath = NULL;
+  else
+    SVN_ERR(svn_wc__db_scan_moved_to_internal(NULL, &move_dst_relpath, NULL,
+                                              b->wcroot, nmb->dst_relpath,
+                                              b->dst_op_depth,
+                                              scratch_pool, scratch_pool));
 
-  SVN_ERR(create_node_tree_conflict(&conflict, nmb, conflict_root_relpath,
+  SVN_ERR(create_node_tree_conflict(&conflict, nmb, nmb->dst_relpath,
                                     old_kind, new_kind,
                                     old_repos_relpath,
                                     (move_dst_relpath
                                      ? svn_wc_conflict_reason_moved_away
                                      : svn_wc_conflict_reason_deleted),
-                                    action, move_src_op_root_relpath,
+                                    action, move_dst_relpath
+                                              ? nmb->dst_relpath
+                                              : NULL,
                                     scratch_pool, scratch_pool));
 
-  SVN_ERR(update_move_list_add(b->wcroot, conflict_root_relpath,
+  SVN_ERR(update_move_list_add(b->wcroot, nmb->dst_relpath,
                                svn_wc_notify_tree_conflict,
                                new_kind,
                                svn_wc_notify_state_inapplicable,
@@ -617,46 +644,46 @@ mark_parent_edited(node_move_baton_t *nm
 static svn_error_t *
 tc_editor_add_directory(node_move_baton_t *nmb,
                         const char *relpath,
+                        svn_node_kind_t old_kind,
                         apr_hash_t *props,
                         apr_pool_t *scratch_pool)
 {
   update_move_baton_t *b = nmb->umb;
   const char *move_dst_repos_relpath;
-  svn_node_kind_t move_dst_kind;
   const char *local_abspath;
-  svn_node_kind_t old_kind;
+  svn_node_kind_t wc_kind;
   svn_skel_t *work_item = NULL;
-  svn_wc_notify_action_t action = svn_wc_notify_update_add;
-  svn_error_t *err;
   svn_skel_t *conflict = NULL;
 
   SVN_ERR(mark_parent_edited(nmb, scratch_pool));
   if (nmb->skip)
     return SVN_NO_ERROR;
 
-  /* Update NODES, only the bits not covered by the later call to
-     replace_moved_layer. */
-  err = svn_wc__db_depth_get_info(NULL, &move_dst_kind, NULL,
-                                  &move_dst_repos_relpath, NULL, NULL, NULL,
-                                  NULL, NULL, NULL, NULL, NULL, NULL,
-                                  b->wcroot, relpath, b->dst_op_depth,
-                                  scratch_pool, scratch_pool);
-  if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
-    {
-      svn_error_clear(err);
-      old_kind = svn_node_none;
-      move_dst_repos_relpath = NULL;
-    }
-  else
-    {
-      SVN_ERR(err);
-      old_kind = move_dst_kind;
-    }
+  /* We can't read the information from the pre-add node to obtain the
+     relpath, but in WORKING we can just calculate it from the op-root */
+  {
+    const char *dst_op_root_relpath = svn_relpath_limit(nmb->pb->dst_relpath,
+                                                        b->dst_op_depth,
+                                                        scratch_pool);
+    SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
+                                      &move_dst_repos_relpath, NULL, NULL,
+                                      NULL, NULL, NULL, NULL, NULL, NULL,
+                                      NULL,
+                                      b->wcroot, dst_op_root_relpath,
+                                      b->dst_op_depth,
+                                      scratch_pool, scratch_pool));
+
+    move_dst_repos_relpath =
+            svn_relpath_join(move_dst_repos_relpath,
+                             svn_relpath_skip_ancestor(dst_op_root_relpath,
+                                                       relpath),
+                             scratch_pool);
+  }
 
   if (nmb->shadowed)
     {
       SVN_ERR(mark_tc_on_op_root(nmb,
-                                 old_kind, svn_node_dir,
+                                 svn_node_none, svn_node_dir,
                                  move_dst_repos_relpath,
                                  svn_wc_conflict_action_add,
                                  scratch_pool));
@@ -665,32 +692,31 @@ tc_editor_add_directory(node_move_baton_
 
   /* Check for unversioned tree-conflict */
   local_abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
-  SVN_ERR(svn_io_check_path(local_abspath, &old_kind, scratch_pool));
 
-  switch (old_kind)
+  SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
+  if (wc_kind == old_kind)
+    wc_kind = svn_node_none; /* Node will be gone once we install */
+
+  if (wc_kind != svn_node_none)
     {
-    case svn_node_file:
-    default:
       SVN_ERR(create_node_tree_conflict(&conflict, nmb, relpath,
-                                        old_kind, svn_node_dir,
+                                        wc_kind, svn_node_dir,
                                         move_dst_repos_relpath,
                                         svn_wc_conflict_reason_unversioned,
                                         svn_wc_conflict_action_add, NULL,
                                         scratch_pool, scratch_pool));
       nmb->skip = TRUE;
-      action = svn_wc_notify_tree_conflict;
-      break;
-
-    case svn_node_none:
+    }
+  else
+    {
       SVN_ERR(svn_wc__wq_build_dir_install(&work_item, b->db, local_abspath,
                                            scratch_pool, scratch_pool));
-      /* Fall through */
-    case svn_node_dir:
-      break;
     }
 
   SVN_ERR(update_move_list_add(b->wcroot, relpath,
-                               action,
+                               (old_kind == svn_node_none)
+                                  ? svn_wc_notify_update_add
+                                  : svn_wc_notify_update_replace,
                                svn_node_dir,
                                svn_wc_notify_state_inapplicable,
                                svn_wc_notify_state_inapplicable,
@@ -701,47 +727,48 @@ tc_editor_add_directory(node_move_baton_
 static svn_error_t *
 tc_editor_add_file(node_move_baton_t *nmb,
                    const char *relpath,
+                   svn_node_kind_t old_kind,
                    const svn_checksum_t *checksum,
                    apr_hash_t *props,
                    apr_pool_t *scratch_pool)
 {
   update_move_baton_t *b = nmb->umb;
   const char *move_dst_repos_relpath;
-  svn_node_kind_t move_dst_kind;
-  svn_node_kind_t old_kind;
+  svn_node_kind_t wc_kind;
   const char *local_abspath;
   svn_skel_t *work_item = NULL;
   svn_skel_t *conflict = NULL;
-  svn_error_t *err;
 
   SVN_ERR(mark_parent_edited(nmb, scratch_pool));
   if (nmb->skip)
     return SVN_NO_ERROR;
 
-  /* Update NODES, only the bits not covered by the later call to
-     replace_moved_layer. */
-  err = svn_wc__db_depth_get_info(NULL, &move_dst_kind, NULL,
-                                  &move_dst_repos_relpath, NULL, NULL, NULL,
-                                  NULL, NULL, NULL, NULL, NULL, NULL,
-                                  b->wcroot, relpath, b->dst_op_depth,
-                                  scratch_pool, scratch_pool);
-  if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
-    {
-      svn_error_clear(err);
-      old_kind = svn_node_none;
-      move_dst_repos_relpath = NULL;
-    }
-  else
-    {
-      SVN_ERR(err);
-      old_kind = move_dst_kind;
-    }
+  /* We can't read the information from the pre-add node to obtain the
+     relpath, but in WORKING we can just calculate it from the op-root */
+  {
+    const char *dst_op_root_relpath = svn_relpath_limit(nmb->pb->dst_relpath,
+                                                        b->dst_op_depth,
+                                                        scratch_pool);
+    SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
+                                      &move_dst_repos_relpath, NULL, NULL,
+                                      NULL, NULL, NULL, NULL, NULL, NULL,
+                                      NULL,
+                                      b->wcroot, dst_op_root_relpath,
+                                      b->dst_op_depth,
+                                      scratch_pool, scratch_pool));
+
+    move_dst_repos_relpath =
+            svn_relpath_join(move_dst_repos_relpath,
+                             svn_relpath_skip_ancestor(dst_op_root_relpath,
+                                                       relpath),
+                             scratch_pool);
+  }
 
   /* Check for NODES tree-conflict. */
   if (nmb->shadowed)
     {
       SVN_ERR(mark_tc_on_op_root(nmb,
-                                 old_kind, svn_node_file,
+                                 svn_node_none, svn_node_file,
                                  move_dst_repos_relpath,
                                  svn_wc_conflict_action_add,
                                  scratch_pool));
@@ -750,12 +777,15 @@ tc_editor_add_file(node_move_baton_t *nm
 
   /* Check for unversioned tree-conflict */
   local_abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
-  SVN_ERR(svn_io_check_path(local_abspath, &old_kind, scratch_pool));
+  SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
+
+  if (wc_kind == old_kind)
+    wc_kind = svn_node_none; /* Node will be gone once we install */
 
-  if (old_kind != svn_node_none)
+  if (wc_kind != svn_node_none)
     {
       SVN_ERR(create_node_tree_conflict(&conflict, nmb, relpath,
-                                        old_kind, svn_node_file,
+                                        wc_kind, svn_node_file,
                                         move_dst_repos_relpath,
                                         svn_wc_conflict_reason_unversioned,
                                         svn_wc_conflict_action_add, NULL,
@@ -776,7 +806,9 @@ tc_editor_add_file(node_move_baton_t *nm
     }
 
   SVN_ERR(update_move_list_add(b->wcroot, relpath,
-                               svn_wc_notify_update_add,
+                               (old_kind == svn_node_none)
+                                  ? svn_wc_notify_update_add
+                                  : svn_wc_notify_update_replace,
                                svn_node_file,
                                svn_wc_notify_state_inapplicable,
                                svn_wc_notify_state_inapplicable,
@@ -803,6 +835,7 @@ create_conflict_markers(svn_skel_t **wor
                         const working_node_version_t *old_version,
                         const working_node_version_t *new_version,
                         svn_node_kind_t kind,
+                        svn_boolean_t set_operation,
                         apr_pool_t *result_pool,
                         apr_pool_t *scratch_pool)
 {
@@ -823,19 +856,22 @@ create_conflict_markers(svn_skel_t **wor
     = svn_relpath_join(conflicted_version->path_in_repos, part, scratch_pool);
   original_version->path_in_repos = repos_relpath;
 
-  if (operation == svn_wc_operation_update)
+  if (set_operation)
     {
-      SVN_ERR(svn_wc__conflict_skel_set_op_update(
-                conflict_skel, original_version,
-                conflicted_version,
-                scratch_pool, scratch_pool));
-    }
-  else
-    {
-      SVN_ERR(svn_wc__conflict_skel_set_op_switch(
-                conflict_skel, original_version,
-                conflicted_version,
-                scratch_pool, scratch_pool));
+      if (operation == svn_wc_operation_update)
+        {
+          SVN_ERR(svn_wc__conflict_skel_set_op_update(
+                    conflict_skel, original_version,
+                    conflicted_version,
+                    scratch_pool, scratch_pool));
+        }
+      else
+        {
+          SVN_ERR(svn_wc__conflict_skel_set_op_switch(
+                    conflict_skel, original_version,
+                    conflicted_version,
+                    scratch_pool, scratch_pool));
+        }
     }
 
   /* According to this func's doc string, it is "Currently only used for
@@ -907,72 +943,80 @@ update_working_props(svn_wc_notify_state
 static svn_error_t *
 tc_editor_alter_directory(node_move_baton_t *nmb,
                           const char *dst_relpath,
+                          apr_hash_t *old_props,
                           apr_hash_t *new_props,
                           apr_pool_t *scratch_pool)
 {
   update_move_baton_t *b = nmb->umb;
-  const char *move_dst_repos_relpath;
-  svn_revnum_t move_dst_revision;
-  svn_node_kind_t move_dst_kind;
   working_node_version_t old_version, new_version;
-  svn_wc__db_status_t status;
   svn_skel_t *work_items = NULL;
   svn_skel_t *conflict_skel = NULL;
+  const char *local_abspath = svn_dirent_join(b->wcroot->abspath, dst_relpath,
+                                              scratch_pool);
+  svn_wc_notify_state_t prop_state;
+  apr_hash_t *actual_props;
+  apr_array_header_t *propchanges;
+  svn_node_kind_t wc_kind;
+  svn_boolean_t obstructed = FALSE;
 
-  if (new_props)
-    SVN_ERR(mark_node_edited(nmb, scratch_pool));
+  SVN_ERR(mark_node_edited(nmb, scratch_pool));
   if (nmb->skip)
     return SVN_NO_ERROR;
 
-  SVN_ERR(svn_wc__db_depth_get_info(&status, &move_dst_kind, &move_dst_revision,
-                                    &move_dst_repos_relpath, NULL, NULL, NULL,
-                                    NULL, NULL, &old_version.checksum, NULL,
-                                    NULL, &old_version.props,
-                                    b->wcroot, dst_relpath, b->dst_op_depth,
-                                    scratch_pool, scratch_pool));
-
-
+  SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
+  if (wc_kind != svn_node_none && wc_kind != svn_node_dir)
+    {
+      SVN_ERR(create_node_tree_conflict(&conflict_skel, nmb, dst_relpath,
+                                        wc_kind, svn_node_dir,
+                                        NULL /* local obstruction relpath */,
+                                        svn_wc_conflict_reason_obstructed,
+                                        svn_wc_conflict_action_edit,
+                                        NULL,
+                                        scratch_pool, scratch_pool));
+      obstructed = TRUE;
+    }
 
   old_version.location_and_kind = b->old_version;
   new_version.location_and_kind = b->new_version;
 
+  old_version.checksum = NULL; /* not a file */
+  old_version.props = old_props;
   new_version.checksum = NULL; /* not a file */
-  new_version.props = new_props ? new_props : old_version.props;
+  new_version.props = new_props;
 
-  if (new_props)
+  SVN_ERR(update_working_props(&prop_state, &conflict_skel,
+                                &propchanges, &actual_props,
+                                b, dst_relpath,
+                                &old_version, &new_version,
+                                scratch_pool, scratch_pool));
+
+  if (prop_state == svn_wc_notify_state_conflicted)
     {
-      const char *dst_abspath = svn_dirent_join(b->wcroot->abspath,
-                                                dst_relpath,
-                                                scratch_pool);
-      svn_wc_notify_state_t prop_state;
-      apr_hash_t *actual_props;
-      apr_array_header_t *propchanges;
-
-      /* ### TODO: Only do this when there is no higher WORKING layer */
-      SVN_ERR(update_working_props(&prop_state, &conflict_skel,
-                                   &propchanges, &actual_props,
-                                   b, dst_relpath,
-                                   &old_version, &new_version,
-                                   scratch_pool, scratch_pool));
+      const char *move_dst_repos_relpath;
 
-      if (conflict_skel)
-        {
-          SVN_ERR(create_conflict_markers(&work_items, dst_abspath,
-                                          b->db, move_dst_repos_relpath,
-                                          conflict_skel, b->operation,
-                                          &old_version, &new_version,
-                                          svn_node_dir,
-                                          scratch_pool, scratch_pool));
-        }
+      SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
+                                        &move_dst_repos_relpath, NULL, NULL,
+                                        NULL, NULL, NULL, NULL, NULL, NULL,
+                                        NULL,
+                                        b->wcroot, dst_relpath,
+                                        b->dst_op_depth,
+                                        scratch_pool, scratch_pool));
 
-    SVN_ERR(update_move_list_add(b->wcroot, dst_relpath,
-                                 svn_wc_notify_update_update,
-                                 svn_node_dir,
-                                 svn_wc_notify_state_inapplicable,
-                                 prop_state,
-                                 conflict_skel, work_items, scratch_pool));
+      SVN_ERR(create_conflict_markers(&work_items, local_abspath,
+                                      b->db, move_dst_repos_relpath,
+                                      conflict_skel, b->operation,
+                                      &old_version, &new_version,
+                                      svn_node_dir, !obstructed,
+                                      scratch_pool, scratch_pool));
     }
 
+  SVN_ERR(update_move_list_add(b->wcroot, dst_relpath,
+                               svn_wc_notify_update_update,
+                               svn_node_dir,
+                               svn_wc_notify_state_inapplicable,
+                               prop_state,
+                               conflict_skel, work_items, scratch_pool));
+
   return SVN_NO_ERROR;
 }
 
@@ -996,12 +1040,13 @@ tc_editor_alter_directory(node_move_bato
 static svn_error_t *
 tc_editor_alter_file(node_move_baton_t *nmb,
                      const char *dst_relpath,
+                     const svn_checksum_t *old_checksum,
                      const svn_checksum_t *new_checksum,
+                     apr_hash_t *old_props,
                      apr_hash_t *new_props,
                      apr_pool_t *scratch_pool)
 {
   update_move_baton_t *b = nmb->umb;
-  const char *move_dst_repos_relpath;
   working_node_version_t old_version, new_version;
   const char *local_abspath = svn_dirent_join(b->wcroot->abspath,
                                               dst_relpath,
@@ -1014,24 +1059,33 @@ tc_editor_alter_file(node_move_baton_t *
   enum svn_wc_merge_outcome_t merge_outcome;
   svn_wc_notify_state_t prop_state, content_state;
   svn_skel_t *work_item, *work_items = NULL;
+  svn_node_kind_t wc_kind;
+  svn_boolean_t obstructed = FALSE;
 
   SVN_ERR(mark_node_edited(nmb, scratch_pool));
   if (nmb->skip)
     return SVN_NO_ERROR;
 
-  SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
-                                    &move_dst_repos_relpath, NULL, NULL, NULL,
-                                    NULL, NULL, &old_version.checksum, NULL,
-                                    NULL, &old_version.props,
-                                    b->wcroot, dst_relpath, b->dst_op_depth,
-                                    scratch_pool, scratch_pool));
+  SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
+  if (wc_kind != svn_node_none && wc_kind != svn_node_file)
+    {
+      SVN_ERR(create_node_tree_conflict(&conflict_skel, nmb, dst_relpath,
+                                        wc_kind, svn_node_file,
+                                        NULL /* local obstruction relpath */,
+                                        svn_wc_conflict_reason_obstructed,
+                                        svn_wc_conflict_action_edit,
+                                        NULL,
+                                        scratch_pool, scratch_pool));
+      obstructed = TRUE;
+    }
 
   old_version.location_and_kind = b->old_version;
   new_version.location_and_kind = b->new_version;
 
-  /* If new checksum is null that means no change; similarly props. */
-  new_version.checksum = new_checksum ? new_checksum : old_version.checksum;
-  new_version.props = new_props ? new_props : old_version.props;
+  old_version.checksum = old_checksum;
+  old_version.props = old_props;
+  new_version.checksum = new_checksum;
+  new_version.props = new_props;
 
   /* ### TODO: Only do this when there is no higher WORKING layer */
   SVN_ERR(update_working_props(&prop_state, &conflict_skel, &propchanges,
@@ -1039,7 +1093,8 @@ tc_editor_alter_file(node_move_baton_t *
                                &old_version, &new_version,
                                scratch_pool, scratch_pool));
 
-  if (!svn_checksum_match(new_version.checksum, old_version.checksum))
+  if (!obstructed
+      && !svn_checksum_match(new_version.checksum, old_version.checksum))
     {
       svn_boolean_t is_locally_modified;
 
@@ -1088,7 +1143,7 @@ tc_editor_alter_file(node_move_baton_t *
                                          NULL, /* diff3-cmd */
                                          NULL, /* merge options */
                                          propchanges,
-                                         NULL, NULL, /* cancel_func + baton */
+                                         b->cancel_func, b->cancel_baton,
                                          scratch_pool, scratch_pool));
 
           work_items = svn_wc__wq_merge(work_items, work_item, scratch_pool);
@@ -1106,10 +1161,20 @@ tc_editor_alter_file(node_move_baton_t *
    * too. */
   if (conflict_skel)
     {
+      const char *move_dst_repos_relpath;
+
+      SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
+                                        &move_dst_repos_relpath, NULL, NULL,
+                                        NULL, NULL, NULL, NULL, NULL, NULL,
+                                        NULL,
+                                        b->wcroot, dst_relpath,
+                                        b->dst_op_depth,
+                                        scratch_pool, scratch_pool));
+
       SVN_ERR(create_conflict_markers(&work_item, local_abspath, b->db,
                                       move_dst_repos_relpath, conflict_skel,
                                       b->operation, &old_version, &new_version,
-                                      svn_node_file,
+                                      svn_node_file, !obstructed,
                                       scratch_pool, scratch_pool));
 
       work_items = svn_wc__wq_merge(work_items, work_item, scratch_pool);
@@ -1128,15 +1193,15 @@ tc_editor_alter_file(node_move_baton_t *
 static svn_error_t *
 tc_editor_delete(node_move_baton_t *nmb,
                  const char *relpath,
+                 svn_node_kind_t old_kind,
+                 svn_node_kind_t new_kind,
                  apr_pool_t *scratch_pool)
 {
   update_move_baton_t *b = nmb->umb;
   svn_sqlite__stmt_t *stmt;
   const char *move_dst_repos_relpath;
   svn_node_kind_t move_dst_kind;
-  svn_boolean_t must_delete_wc_nodes = FALSE;
   const char *local_abspath;
-  svn_boolean_t have_row;
   svn_boolean_t is_modified, is_all_deletes;
   svn_skel_t *work_items = NULL;
   svn_skel_t *conflict = NULL;
@@ -1158,7 +1223,7 @@ tc_editor_delete(node_move_baton_t *nmb,
     {
       SVN_ERR(mark_tc_on_op_root(nmb,
                                  move_dst_kind,
-                                 svn_node_unknown,
+                                 new_kind,
                                  move_dst_repos_relpath,
                                  svn_wc_conflict_action_delete,
                                  scratch_pool));
@@ -1173,41 +1238,34 @@ tc_editor_delete(node_move_baton_t *nmb,
     {
       svn_wc_conflict_reason_t reason;
 
-      if (!is_all_deletes)
-        {
-          /* No conflict means no NODES rows at the relpath op-depth
-             so it's easy to convert the modified tree into a copy.
+      /* No conflict means no NODES rows at the relpath op-depth
+         so it's easy to convert the modified tree into a copy.
 
-             Note the following assumptions for relpath:
-               * it is not shadowed
-               * it is not the/an op-root. (or we can't make us a copy)
-          */
+         Note the following assumptions for relpath:
+            * it is not shadowed
+            * it is not the/an op-root. (or we can't make us a copy)
+       */
 
-          SVN_ERR(svn_wc__db_op_make_copy_internal(b->wcroot, relpath,
-                                                   NULL, NULL, scratch_pool));
+      SVN_ERR(svn_wc__db_op_make_copy_internal(b->wcroot, relpath,
+                                               NULL, NULL, scratch_pool));
+
+      reason = svn_wc_conflict_reason_edited;
 
-          reason = svn_wc_conflict_reason_edited;
-        }
-      else
-        {
-          reason = svn_wc_conflict_reason_deleted;
-          must_delete_wc_nodes = TRUE;
-        }
       SVN_ERR(create_node_tree_conflict(&conflict, nmb, relpath,
-                                        move_dst_kind, svn_node_none,
+                                        move_dst_kind, new_kind,
                                         move_dst_repos_relpath, reason,
-                                        svn_wc_conflict_action_delete, NULL,
+                                        (new_kind == svn_node_none)
+                                          ? svn_wc_conflict_action_delete
+                                          : svn_wc_conflict_action_replace,
+                                        NULL,
                                         scratch_pool, scratch_pool));
       nmb->skip = TRUE;
     }
   else
-    must_delete_wc_nodes = TRUE;
-
-  if (must_delete_wc_nodes)
     {
       apr_pool_t *iterpool = svn_pool_create(scratch_pool);
-      svn_node_kind_t del_kind;
       const char *del_abspath;
+      svn_boolean_t have_row;
 
       /* Get all descendants of the node in reverse order (so children are
          handled before their parents, but not strictly depth first) */
@@ -1220,6 +1278,7 @@ tc_editor_delete(node_move_baton_t *nmb,
         {
           svn_error_t *err;
           svn_skel_t *work_item;
+          svn_node_kind_t del_kind;
 
           svn_pool_clear(iterpool);
 
@@ -1245,12 +1304,7 @@ tc_editor_delete(node_move_baton_t *nmb,
         }
       SVN_ERR(svn_sqlite__reset(stmt));
 
-      SVN_ERR(svn_wc__db_depth_get_info(NULL, &del_kind, NULL, NULL, NULL,
-                                        NULL, NULL, NULL, NULL, NULL, NULL,
-                                        NULL, NULL,
-                                        b->wcroot, relpath, b->dst_op_depth,
-                                        iterpool, iterpool));
-      if (del_kind == svn_node_dir)
+      if (old_kind == svn_node_dir)
         SVN_ERR(svn_wc__wq_build_dir_remove(&work_items, b->db,
                                             b->wcroot->abspath, local_abspath,
                                             FALSE /* recursive */,
@@ -1258,17 +1312,22 @@ tc_editor_delete(node_move_baton_t *nmb,
       else
         SVN_ERR(svn_wc__wq_build_file_remove(&work_items, b->db,
                                              b->wcroot->abspath, local_abspath,
-                                             iterpool, iterpool));
+                                             scratch_pool, iterpool));
 
-        svn_pool_destroy(iterpool);
+      svn_pool_destroy(iterpool);
     }
 
-  SVN_ERR(update_move_list_add(b->wcroot, relpath,
-                               svn_wc_notify_update_delete,
-                               move_dst_kind,
-                               svn_wc_notify_state_inapplicable,
-                               svn_wc_notify_state_inapplicable,
-                               conflict, work_items, scratch_pool));
+  /* Only notify if add_file/add_dir is not going to notify */
+  if (conflict || (new_kind == svn_node_none))
+    SVN_ERR(update_move_list_add(b->wcroot, relpath,
+                                 svn_wc_notify_update_delete,
+                                 move_dst_kind,
+                                 svn_wc_notify_state_inapplicable,
+                                 svn_wc_notify_state_inapplicable,
+                                 conflict, work_items, scratch_pool));
+  else if (work_items)
+    SVN_ERR(svn_wc__db_wq_add_internal(b->wcroot, work_items,
+                                       scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -1367,30 +1426,26 @@ get_info(apr_hash_t **props,
          apr_pool_t *result_pool,
          apr_pool_t *scratch_pool)
 {
-  apr_hash_t *hash_children;
-  apr_array_header_t *sorted_children;
-  svn_error_t *err;
   svn_wc__db_status_t status;
   const char *repos_relpath;
-  int i;
+  svn_node_kind_t db_kind;
+  svn_error_t *err;
 
-  err = svn_wc__db_depth_get_info(&status, kind, NULL, &repos_relpath, NULL,
+  err = svn_wc__db_depth_get_info(&status, &db_kind, NULL, &repos_relpath, NULL,
                                   NULL, NULL, NULL, NULL, checksum, NULL,
                                   NULL, props,
                                   wcroot, local_relpath, op_depth,
                                   result_pool, scratch_pool);
 
   /* If there is no node at this depth, or only a node that describes a delete
-     of a lower layer we report this node as not existing.
-
-     But when a node is reported as DELETED, but has a repository location it
-     is really a not-present node that must be reported as being there */
+     of a lower layer we report this node as not existing. */
   if ((err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
-      || (!err && status == svn_wc__db_status_deleted))
+      || (!err && status != svn_wc__db_status_added
+               && status != svn_wc__db_status_normal))
     {
       svn_error_clear(err);
 
-      if (kind && (err || !repos_relpath))
+      if (kind)
         *kind = svn_node_none;
       if (checksum)
         *checksum = NULL;
@@ -1404,47 +1459,35 @@ get_info(apr_hash_t **props,
   else
     SVN_ERR(err);
 
+  if (kind)
+    *kind = db_kind;
 
-  SVN_ERR(svn_wc__db_get_children_op_depth(&hash_children, wcroot,
-                                           local_relpath, op_depth,
-                                           scratch_pool, scratch_pool));
-
-  sorted_children = svn_sort__hash(hash_children,
-                                   svn_sort_compare_items_lexically,
-                                   scratch_pool);
-
-  *children = apr_array_make(result_pool, sorted_children->nelts,
-                             sizeof(const char *));
-  for (i = 0; i < sorted_children->nelts; ++i)
-    APR_ARRAY_PUSH(*children, const char *)
-      = apr_pstrdup(result_pool, APR_ARRAY_IDX(sorted_children, i,
-                                               svn_sort__item_t).key);
-
-  return SVN_NO_ERROR;
-}
-
-/* Return TRUE if SRC_CHILDREN and DST_CHILDREN represent the same
-   children, FALSE otherwise.  SRC_CHILDREN and DST_CHILDREN are
-   sorted arrays of basenames of type 'const char *'. */
-static svn_boolean_t
-children_match(apr_array_header_t *src_children,
-               apr_array_header_t *dst_children) { int i;
+  if (children && db_kind == svn_node_dir)
+    {
+      svn_sqlite__stmt_t *stmt;
+      svn_boolean_t have_row;
 
-  if (src_children->nelts != dst_children->nelts)
-    return FALSE;
+      *children = apr_array_make(result_pool, 16, sizeof(const char *));
+      SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+                                        STMT_SELECT_OP_DEPTH_CHILDREN_EXISTS));
+      SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, local_relpath,
+                                op_depth));
+      SVN_ERR(svn_sqlite__step(&have_row, stmt));
+      while (have_row)
+        {
+          const char *child_relpath = svn_sqlite__column_text(stmt, 0, NULL);
 
-  for(i = 0; i < src_children->nelts; ++i)
-    {
-      const char *src_child =
-        APR_ARRAY_IDX(src_children, i, const char *);
-      const char *dst_child =
-        APR_ARRAY_IDX(dst_children, i, const char *);
+          APR_ARRAY_PUSH(*children, const char *)
+              = svn_relpath_basename(child_relpath, result_pool);
 
-      if (strcmp(src_child, dst_child))
-        return FALSE;
+          SVN_ERR(svn_sqlite__step(&have_row, stmt));
+        }
+      SVN_ERR(svn_sqlite__reset(stmt));
     }
+  else if (children)
+    *children = apr_array_make(result_pool, 0, sizeof(const char *));
 
-  return TRUE;
+  return SVN_NO_ERROR;
 }
 
 /* Return TRUE if SRC_PROPS and DST_PROPS contain the same properties,
@@ -1485,8 +1528,8 @@ update_moved_away_node(node_move_baton_t
   apr_hash_t *src_props, *dst_props;
   apr_array_header_t *src_children, *dst_children;
 
-  SVN_ERR(verify_write_lock(wcroot, src_relpath, scratch_pool));
-  SVN_ERR(verify_write_lock(wcroot, dst_relpath, scratch_pool));
+  if (b->cancel_func)
+    SVN_ERR(b->cancel_func(b->cancel_baton));
 
   SVN_ERR(get_info(&src_props, &src_checksum, &src_children, &src_kind,
                    src_relpath, b->src_op_depth,
@@ -1499,7 +1542,8 @@ update_moved_away_node(node_move_baton_t
   if (src_kind == svn_node_none
       || (dst_kind != svn_node_none && src_kind != dst_kind))
     {
-      SVN_ERR(tc_editor_delete(nmb, dst_relpath, scratch_pool));
+      SVN_ERR(tc_editor_delete(nmb, dst_relpath, dst_kind, src_kind,
+                               scratch_pool));
     }
 
   if (nmb->skip)
@@ -1509,39 +1553,33 @@ update_moved_away_node(node_move_baton_t
     {
       if (src_kind == svn_node_file || src_kind == svn_node_symlink)
         {
-          SVN_ERR(tc_editor_add_file(nmb, dst_relpath,
+          SVN_ERR(tc_editor_add_file(nmb, dst_relpath, dst_kind,
                                      src_checksum, src_props, scratch_pool));
         }
       else if (src_kind == svn_node_dir)
         {
-          SVN_ERR(tc_editor_add_directory(nmb, dst_relpath,
+          SVN_ERR(tc_editor_add_directory(nmb, dst_relpath, dst_kind,
                                           src_props, scratch_pool));
         }
     }
   else if (src_kind != svn_node_none)
     {
-      svn_boolean_t match;
-      apr_hash_t *props;
+      svn_boolean_t props_equal;
 
-      SVN_ERR(props_match(&match, src_props, dst_props, scratch_pool));
-      props = match ? NULL: src_props;
+      SVN_ERR(props_match(&props_equal, src_props, dst_props, scratch_pool));
 
       if (src_kind == svn_node_file || src_kind == svn_node_symlink)
         {
-          if (svn_checksum_match(src_checksum, dst_checksum))
-            src_checksum = NULL;
-
-          if (props || src_checksum)
-            SVN_ERR(tc_editor_alter_file(nmb, dst_relpath, src_checksum,
-                                         props, scratch_pool));
+          if (!props_equal || !svn_checksum_match(src_checksum, dst_checksum))
+            SVN_ERR(tc_editor_alter_file(nmb, dst_relpath,
+                                         dst_checksum, src_checksum,
+                                         dst_props, src_props, scratch_pool));
         }
       else if (src_kind == svn_node_dir)
         {
-          apr_array_header_t *children
-            = children_match(src_children, dst_children) ? NULL : src_children;
-
-          if (props || children)
-            SVN_ERR(tc_editor_alter_directory(nmb, dst_relpath, props,
+          if (!props_equal)
+            SVN_ERR(tc_editor_alter_directory(nmb, dst_relpath,
+                                              dst_props, src_props,
                                               scratch_pool));
         }
     }
@@ -1617,66 +1655,6 @@ update_moved_away_node(node_move_baton_t
   return SVN_NO_ERROR;
 }
 
-/* Transfer changes from the move source to the move destination.
- *
- * Drive the editor with the difference between DST_RELPATH
- * (at its own op-depth) and SRC_RELPATH (at op-depth zero).
- *
- * Then update the single op-depth layer in the move destination subtree
- * rooted at DST_RELPATH to make it match the move source subtree
- * rooted at SRC_RELPATH.
- *
- * ### And the other params?
- */
-static svn_error_t *
-drive_tree_conflict_editor(update_move_baton_t *b,
-                           const char *src_relpath,
-                           const char *dst_relpath,
-                           svn_wc_operation_t operation,
-                           svn_wc_conflict_reason_t local_change,
-                           svn_wc_conflict_action_t incoming_change,
-                           svn_wc_conflict_version_t *old_version,
-                           svn_wc_conflict_version_t *new_version,
-                           svn_wc__db_wcroot_t *wcroot,
-                           svn_cancel_func_t cancel_func,
-                           void *cancel_baton,
-                           apr_pool_t *scratch_pool)
-{
-  node_move_baton_t nmb = { 0 };
-  SVN_ERR(verify_write_lock(wcroot, src_relpath, scratch_pool));
-  SVN_ERR(verify_write_lock(wcroot, dst_relpath, scratch_pool));
-  /*
-   * Refuse to auto-resolve unsupported tree conflicts.
-   */
-  /* ### Only handle conflicts created by update/switch operations for now. */
-  if (operation != svn_wc_operation_update &&
-      operation != svn_wc_operation_switch)
-    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
-                            _("Cannot auto-resolve tree-conflict on '%s'"),
-                            path_for_error_message(wcroot, src_relpath,
-                                                   scratch_pool));
-
-  nmb.umb = b;
-  nmb.src_relpath = src_relpath;
-  nmb.dst_relpath = dst_relpath;
-  /* nmb.shadowed = FALSE; */
-  /* nmb.edited = FALSE; */
-  /* nmb.skip_children = FALSE; */
-
-  /* We walk the move source (i.e. the post-update tree), comparing each node
-   * with the equivalent node at the move destination and applying the update
-   * to nodes at the move destination. */
-  SVN_ERR(update_moved_away_node(&nmb, wcroot, src_relpath, dst_relpath,
-                                 scratch_pool));
-
-  SVN_ERR(svn_wc__db_op_copy_layer_internal(wcroot, src_relpath,
-                                            b->src_op_depth,
-                                            dst_relpath, NULL, NULL,
-                                            scratch_pool));
-
-  return SVN_NO_ERROR;
-}
-
 static svn_error_t *
 suitable_for_move(svn_wc__db_wcroot_t *wcroot,
                   const char *local_relpath,
@@ -1743,85 +1721,113 @@ suitable_for_move(svn_wc__db_wcroot_t *w
 /* The body of svn_wc__db_update_moved_away_conflict_victim(), which see.
  */
 static svn_error_t *
-update_moved_away_conflict_victim(svn_wc__db_t *db,
+update_moved_away_conflict_victim(svn_revnum_t *old_rev,
+                                  svn_revnum_t *new_rev,
+                                  svn_wc__db_t *db,
                                   svn_wc__db_wcroot_t *wcroot,
-                                  const char *victim_relpath,
+                                  const char *local_relpath,
+                                  const char *delete_relpath,
                                   svn_wc_operation_t operation,
-                                  svn_wc_conflict_reason_t local_change,
-                                  svn_wc_conflict_action_t incoming_change,
-                                  const char *move_src_op_root_relpath,
-                                  svn_wc_conflict_version_t *old_version,
-                                  svn_wc_conflict_version_t *new_version,
+                                  svn_wc_conflict_action_t action,
+                                  svn_wc_conflict_reason_t reason,
                                   svn_cancel_func_t cancel_func,
                                   void *cancel_baton,
                                   apr_pool_t *scratch_pool)
 {
   update_move_baton_t umb = { NULL };
-  svn_sqlite__stmt_t *stmt;
-  svn_boolean_t have_row;
-  const char *dummy1, *dummy2, *dummy3;
-  const char *move_root_dst_abspath;
-  const char *move_root_dst_relpath;
+  const char *src_relpath, *dst_relpath;
+  svn_wc_conflict_version_t old_version;
+  svn_wc_conflict_version_t new_version;
+  apr_int64_t repos_id;
+  node_move_baton_t nmb = { 0 };
 
-  /* ### assumes wc write lock already held */
+  SVN_ERR_ASSERT(svn_relpath_skip_ancestor(delete_relpath, local_relpath));
 
   /* Construct editor baton. */
-  SVN_ERR(svn_wc__db_op_depth_moved_to(
-            &dummy1, &move_root_dst_relpath, &dummy2, &dummy3,
-            relpath_depth(move_src_op_root_relpath) - 1,
-            wcroot, victim_relpath, scratch_pool, scratch_pool));
-  if (move_root_dst_relpath == NULL)
+
+  SVN_ERR(find_src_op_depth(&umb.src_op_depth, wcroot,
+                            local_relpath, relpath_depth(delete_relpath),
+                            scratch_pool));
+
+  SVN_ERR(svn_wc__db_scan_moved_to_internal(&src_relpath, &dst_relpath, NULL,
+                                            wcroot, local_relpath,
+                                            umb.src_op_depth,
+                                            scratch_pool, scratch_pool));
+
+  if (dst_relpath == NULL)
     return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
                              _("The node '%s' has not been moved away"),
-                             path_for_error_message(wcroot, victim_relpath,
+                             path_for_error_message(wcroot, local_relpath,
                                                     scratch_pool));
 
-  move_root_dst_abspath
-    = svn_dirent_join(wcroot->abspath, move_root_dst_relpath, scratch_pool);
-  SVN_ERR(svn_wc__write_check(db, move_root_dst_abspath, scratch_pool));
+  umb.dst_op_depth = relpath_depth(dst_relpath);
+
+  SVN_ERR(verify_write_lock(wcroot, src_relpath, scratch_pool));
+  SVN_ERR(verify_write_lock(wcroot, dst_relpath, scratch_pool));
+
+
+  SVN_ERR(svn_wc__db_depth_get_info(NULL, &new_version.node_kind,
+                                    &new_version.peg_rev,
+                                    &new_version.path_in_repos, &repos_id,
+                                    NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                    NULL,
+                                    wcroot, src_relpath, umb.src_op_depth,
+                                    scratch_pool, scratch_pool));
+
+  SVN_ERR(svn_wc__db_fetch_repos_info(&new_version.repos_url,
+                                      &new_version.repos_uuid,
+                                      wcroot, repos_id,
+                                      scratch_pool));
+
+  SVN_ERR(svn_wc__db_depth_get_info(NULL, &old_version.node_kind,
+                                    &old_version.peg_rev,
+                                    &old_version.path_in_repos, &repos_id,
+                                    NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                    NULL,
+                                    wcroot, dst_relpath, umb.dst_op_depth,
+                                    scratch_pool, scratch_pool));
+
+  SVN_ERR(svn_wc__db_fetch_repos_info(&old_version.repos_url,
+                                      &old_version.repos_uuid,
+                                      wcroot, repos_id,
+                                      scratch_pool));
+  *old_rev = old_version.peg_rev;
+  *new_rev = new_version.peg_rev;
 
   umb.operation = operation;
-  umb.old_version= old_version;
-  umb.new_version= new_version;
+  umb.old_version= &old_version;
+  umb.new_version= &new_version;
   umb.db = db;
   umb.wcroot = wcroot;
-
-  umb.dst_op_depth = relpath_depth(move_root_dst_relpath);
-
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_HIGHEST_WORKING_NODE));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
-                            move_src_op_root_relpath,
-                            relpath_depth(move_src_op_root_relpath)));
-  SVN_ERR(svn_sqlite__step(&have_row, stmt));
-  if (have_row)
-    umb.src_op_depth = svn_sqlite__column_int(stmt, 0);
-  SVN_ERR(svn_sqlite__reset(stmt));
-  if (!have_row)
-    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
-                             _("'%s' is not deleted"),
-                             path_for_error_message(wcroot, victim_relpath,
-                                                    scratch_pool));
+  umb.cancel_func = cancel_func;
+  umb.cancel_baton = cancel_baton;
 
   if (umb.src_op_depth == 0)
-    SVN_ERR(suitable_for_move(wcroot, victim_relpath, scratch_pool));
+    SVN_ERR(suitable_for_move(wcroot, src_relpath, scratch_pool));
 
   /* Create a new, and empty, list for notification information. */
   SVN_ERR(svn_sqlite__exec_statements(wcroot->sdb,
                                       STMT_CREATE_UPDATE_MOVE_LIST));
-  /* Create the editor... */
 
-  /* ... and drive it. */
-  SVN_ERR(drive_tree_conflict_editor(&umb,
-                                     victim_relpath,
-                                     move_root_dst_relpath,
-                                     operation,
-                                     local_change, incoming_change,
-                                     umb.old_version,
-                                     umb.new_version,
-                                     wcroot,
-                                     cancel_func, cancel_baton,
-                                     scratch_pool));
+  /* Drive the editor... */
+
+  nmb.umb = &umb;
+  nmb.src_relpath = src_relpath;
+  nmb.dst_relpath = dst_relpath;
+  /* nmb.shadowed = FALSE; */
+  /* nmb.edited = FALSE; */
+  /* nmb.skip_children = FALSE; */
+
+  /* We walk the move source (i.e. the post-update tree), comparing each node
+    * with the equivalent node at the move destination and applying the update
+    * to nodes at the move destination. */
+  SVN_ERR(update_moved_away_node(&nmb, wcroot, src_relpath, dst_relpath,
+                                 scratch_pool));
+
+  SVN_ERR(svn_wc__db_op_copy_layer_internal(wcroot, src_relpath,
+                                            umb.src_op_depth,
+                                            dst_relpath, NULL, NULL,
+                                            scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -1829,58 +1835,43 @@ update_moved_away_conflict_victim(svn_wc
 
 svn_error_t *
 svn_wc__db_update_moved_away_conflict_victim(svn_wc__db_t *db,
-                                             const char *victim_abspath,
-                                             svn_wc_notify_func2_t notify_func,
-                                             void *notify_baton,
+                                             const char *local_abspath,
+                                             const char *delete_op_abspath,
+                                             svn_wc_operation_t operation,
+                                             svn_wc_conflict_action_t action,
+                                             svn_wc_conflict_reason_t reason,
                                              svn_cancel_func_t cancel_func,
                                              void *cancel_baton,
+                                             svn_wc_notify_func2_t notify_func,
+                                             void *notify_baton,
                                              apr_pool_t *scratch_pool)
 {
   svn_wc__db_wcroot_t *wcroot;
+  svn_revnum_t old_rev, new_rev;
   const char *local_relpath;
-  svn_wc_operation_t operation;
-  svn_wc_conflict_reason_t local_change;
-  svn_wc_conflict_action_t incoming_change;
-  svn_wc_conflict_version_t *old_version;
-  svn_wc_conflict_version_t *new_version;
-  const char *move_src_op_root_abspath, *move_src_op_root_relpath;
+  const char *delete_relpath;
 
   /* ### Check for mixed-rev src or dst? */
 
-  SVN_ERR(get_tc_info(&operation, &local_change, &incoming_change,
-                      &move_src_op_root_abspath,
-                      &old_version, &new_version,
-                      db, victim_abspath,
-                      scratch_pool, scratch_pool));
-
-  SVN_ERR(svn_wc__write_check(db, move_src_op_root_abspath, scratch_pool));
-
   SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath,
-                                                db, victim_abspath,
+                                                db, local_abspath,
                                                 scratch_pool, scratch_pool));
   VERIFY_USABLE_WCROOT(wcroot);
 
-  move_src_op_root_relpath
-    = svn_dirent_skip_ancestor(wcroot->abspath, move_src_op_root_abspath);
+  delete_relpath
+    = svn_dirent_skip_ancestor(wcroot->abspath, delete_op_abspath);
 
   SVN_WC__DB_WITH_TXN(
     update_moved_away_conflict_victim(
-      db, wcroot, local_relpath,
-      operation, local_change, incoming_change,
-      move_src_op_root_relpath,
-      old_version, new_version,
+      &old_rev, &new_rev,
+      db, wcroot, local_relpath, delete_relpath,
+      operation, action, reason,
       cancel_func, cancel_baton,
       scratch_pool),
     wcroot);
 
   /* Send all queued up notifications. */
-  SVN_ERR(svn_wc__db_update_move_list_notify(wcroot,
-                                             (old_version
-                                              ? old_version->peg_rev
-                                              : SVN_INVALID_REVNUM),
-                                             (new_version
-                                              ? new_version->peg_rev
-                                              : SVN_INVALID_REVNUM),
+  SVN_ERR(svn_wc__db_update_move_list_notify(wcroot, old_rev, new_rev,
                                              notify_func, notify_baton,
                                              scratch_pool));
   if (notify_func)
@@ -1895,7 +1886,7 @@ svn_wc__db_update_moved_away_conflict_vi
       notify->kind = svn_node_none;
       notify->content_state = svn_wc_notify_state_inapplicable;
       notify->prop_state = svn_wc_notify_state_inapplicable;
-      notify->revision = new_version->peg_rev;
+      notify->revision = new_rev;
       notify_func(notify_baton, notify, scratch_pool);
     }
 
@@ -1985,7 +1976,7 @@ bump_mark_tree_conflict(svn_wc__db_wcroo
                                             wcroot, move_src_op_root_relpath,
                                             scratch_pool, scratch_pool));
   SVN_ERR(svn_wc__db_fetch_repos_info(&repos_root_url, &repos_uuid,
-                                      wcroot->sdb, repos_id, scratch_pool));
+                                      wcroot, repos_id, scratch_pool));
 
   /* Read old (pre-update) information from the move destination node.
 
@@ -2291,17 +2282,27 @@ svn_wc__db_bump_moved_away(svn_wc__db_wc
 
   if (local_relpath[0] != '\0')
     {
-      const char *dummy1, *move_dst_op_root_relpath;
-      const char *move_src_root_relpath, *move_src_op_root_relpath;
+      const char *move_dst_op_root_relpath;
+      const char *move_src_root_relpath, *delete_relpath;
+      svn_error_t *err;
 
       /* Is the root of the update moved away? (Impossible for the wcroot) */
-      SVN_ERR(svn_wc__db_op_depth_moved_to(&dummy1, &move_dst_op_root_relpath,
-                                           &move_src_root_relpath,
-                                           &move_src_op_root_relpath, 0,
-                                           wcroot, local_relpath,
-                                           scratch_pool, scratch_pool));
 
-      if (move_src_root_relpath)
+      err = svn_wc__db_scan_moved_to_internal(&move_src_root_relpath,
+                                              &move_dst_op_root_relpath,
+                                              &delete_relpath,
+                                              wcroot, local_relpath,
+                                              0 /* BASE */,
+                                              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 (move_src_root_relpath)
         {
           if (strcmp(move_src_root_relpath, local_relpath))
             {
@@ -2321,7 +2322,7 @@ svn_wc__db_bump_moved_away(svn_wc__db_wc
                 {
                   SVN_ERR(bump_mark_tree_conflict(wcroot,
                                                   move_src_root_relpath,
-                                                  move_src_op_root_relpath,
+                                                  delete_relpath,
                                                   move_dst_op_root_relpath,
                                                   db, scratch_pool));
                 }
@@ -2335,15 +2336,17 @@ svn_wc__db_bump_moved_away(svn_wc__db_wc
   return SVN_NO_ERROR;
 }
 
-static svn_error_t *
-resolve_delete_raise_moved_away(svn_wc__db_wcroot_t *wcroot,
-                                const char *local_relpath,
-                                svn_wc__db_t *db,
-                                svn_wc_operation_t operation,
-                                svn_wc_conflict_action_t action,
-                                svn_wc_conflict_version_t *old_version,
-                                svn_wc_conflict_version_t *new_version,
-                                apr_pool_t *scratch_pool)
+svn_error_t *
+svn_wc__db_op_raise_moved_away_internal(
+                        svn_wc__db_wcroot_t *wcroot,
+                        const char *local_relpath,
+                        int delete_op_depth,
+                        svn_wc__db_t *db,
+                        svn_wc_operation_t operation,
+                        svn_wc_conflict_action_t action,
+                        const svn_wc_conflict_version_t *old_version,
+                        const svn_wc_conflict_version_t *new_version,
+                        apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
   svn_boolean_t have_row;
@@ -2353,17 +2356,17 @@ resolve_delete_raise_moved_away(svn_wc__
                                       STMT_CREATE_UPDATE_MOVE_LIST));
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_OP_DEPTH_MOVED_PAIR));
+                                    STMT_SELECT_MOVED_DESCENDANTS_SHD));
   SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, local_relpath,
-                            relpath_depth(local_relpath)));
+                            delete_op_depth));
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
   while(have_row)
     {
       svn_error_t *err;
-      const char *src_relpath = svn_sqlite__column_text(stmt, 0, NULL);
-      svn_node_kind_t src_kind = svn_sqlite__column_token(stmt, 1, kind_map);
-      const char *dst_relpath = svn_sqlite__column_text(stmt, 2, NULL);
+      const char *src_relpath = svn_sqlite__column_text(stmt, 1, NULL);
+      svn_node_kind_t src_kind = svn_sqlite__column_token(stmt, 2, kind_map);
       const char *src_repos_relpath = svn_sqlite__column_text(stmt, 3, NULL);
+      const char *dst_relpath = svn_sqlite__column_text(stmt, 4, NULL);
       svn_skel_t *conflict;
       svn_pool_clear(iterpool);
 
@@ -2375,7 +2378,10 @@ resolve_delete_raise_moved_away(svn_wc__
                                  src_kind /* ### new kind */,
                                  src_repos_relpath,
                                  svn_wc_conflict_reason_moved_away,
-                                 action, local_relpath,
+                                 action,
+                                 svn_relpath_limit(src_relpath,
+                                                   delete_op_depth,
+                                                   iterpool),
                                  iterpool, iterpool);
 
       if (!err)
@@ -2422,10 +2428,11 @@ svn_wc__db_resolve_delete_raise_moved_aw
                       db, local_abspath, scratch_pool, scratch_pool));
 
   SVN_WC__DB_WITH_TXN(
-    resolve_delete_raise_moved_away(wcroot, local_relpath,
-                                    db, operation, action,
-                                    old_version, new_version,
-                                    scratch_pool),
+    svn_wc__db_op_raise_moved_away_internal(wcroot, local_relpath,
+                                            relpath_depth(local_relpath),
+                                            db, operation, action,
+                                            old_version, new_version,
+                                            scratch_pool),
     wcroot);
 
   SVN_ERR(svn_wc__db_update_move_list_notify(wcroot,
@@ -2442,63 +2449,40 @@ svn_wc__db_resolve_delete_raise_moved_aw
 }
 
 static svn_error_t *
-break_move(svn_wc__db_wcroot_t *wcroot,
-           const char *src_relpath,
-           int src_op_depth,
-           const char *dst_relpath,
-           apr_pool_t *scratch_pool)
+break_moved_away(svn_wc__db_wcroot_t *wcroot,
+                 const char *local_relpath,
+                 int op_depth,
+                 apr_pool_t *scratch_pool)
 {
-  svn_sqlite__stmt_t *stmt;
+  const char *dst_relpath;
+  int src_op_depth;
+  const char *delete_relpath;
 
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_CLEAR_MOVED_TO_RELPATH));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, src_relpath,
-                            src_op_depth));
-  SVN_ERR(svn_sqlite__step_done(stmt));
+  SVN_ERR(find_src_op_depth(&src_op_depth, wcroot,
+                            local_relpath, op_depth,
+                            scratch_pool));
 
-  /* The destination is always an op-root, so we can calculate the depth
-     from there. */
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_CLEAR_MOVED_HERE_RECURSIVE));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
-                            dst_relpath, relpath_depth(dst_relpath)));
-  SVN_ERR(svn_sqlite__step_done(stmt));
 
-  return SVN_NO_ERROR;
-}
+  SVN_ERR(svn_wc__db_scan_moved_to_internal(NULL, &dst_relpath,
+                                            &delete_relpath,
+                                            wcroot, local_relpath,
+                                            src_op_depth,
+                                            scratch_pool, scratch_pool));
 
-svn_error_t *
-svn_wc__db_resolve_break_moved_away_internal(svn_wc__db_wcroot_t *wcroot,
-                                             const char *local_relpath,
-                                             int op_depth,
-                                             apr_pool_t *scratch_pool)
-{
-  const char *dummy1, *move_dst_op_root_relpath;
-  const char *dummy2, *move_src_op_root_relpath;
+  SVN_ERR_ASSERT(dst_relpath != NULL && delete_relpath != NULL);
 
-  /* We want to include the passed op-depth, but the function does a > check */
-  SVN_ERR(svn_wc__db_op_depth_moved_to(&dummy1, &move_dst_op_root_relpath,
-                                       &dummy2,
-                                       &move_src_op_root_relpath,
-                                       op_depth - 1,
-                                       wcroot, local_relpath,
-                                       scratch_pool, scratch_pool));
-
-  SVN_ERR_ASSERT(move_src_op_root_relpath != NULL
-                 && move_dst_op_root_relpath != NULL);
-
-  SVN_ERR(break_move(wcroot, local_relpath,
-                     relpath_depth(move_src_op_root_relpath),
-                     move_dst_op_root_relpath,
-                     scratch_pool));
+  SVN_ERR(svn_wc__db_op_break_move_internal(wcroot, local_relpath,
+                                            relpath_depth(delete_relpath),
+                                            dst_relpath, NULL,
+                                            scratch_pool));
 
   return SVN_NO_ERROR;
 }
 
 static svn_error_t *
-break_moved_away_children_internal(svn_wc__db_wcroot_t *wcroot,
-                                   const char *local_relpath,
-                                   apr_pool_t *scratch_pool)
+break_moved_away_children(svn_wc__db_wcroot_t *wcroot,
+                          const char *local_relpath,
+                          apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
   svn_boolean_t have_row;
@@ -2508,7 +2492,7 @@ break_moved_away_children_internal(svn_w
                                       STMT_CREATE_UPDATE_MOVE_LIST));
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_MOVED_DESCENDANTS));
+                                    STMT_SELECT_MOVED_DESCENDANTS_SRC));
   SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, local_relpath,
                             relpath_depth(local_relpath)));
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
@@ -2516,21 +2500,23 @@ break_moved_away_children_internal(svn_w
   iterpool = svn_pool_create(scratch_pool);
   while (have_row)
     {
-      const char *src_relpath = svn_sqlite__column_text(stmt, 0, NULL);
-      const char *dst_relpath = svn_sqlite__column_text(stmt, 1, NULL);
-      int src_op_depth = svn_sqlite__column_int(stmt, 2);
+      int src_op_depth = svn_sqlite__column_int(stmt, 0) ;
+      const char *src_relpath = svn_sqlite__column_text(stmt, 1, NULL);
+      svn_node_kind_t src_kind = svn_sqlite__column_token(stmt, 2, kind_map);
+      const char *dst_relpath = svn_sqlite__column_text(stmt, 4, NULL);
       svn_error_t *err;
 
       svn_pool_clear(iterpool);
 
-      err = break_move(wcroot, src_relpath, src_op_depth, dst_relpath,
-                       iterpool);
+      err = svn_wc__db_op_break_move_internal(wcroot,
+                                              src_relpath, src_op_depth,
+                                              dst_relpath, NULL, iterpool);
 
       if (! err)
         {
           err = update_move_list_add(wcroot, src_relpath,
                                      svn_wc_notify_move_broken,
-                                     svn_node_unknown,
+                                     src_kind,
                                      svn_wc_notify_state_inapplicable,
                                      svn_wc_notify_state_inapplicable,
                                      NULL, NULL, scratch_pool);
@@ -2572,11 +2558,10 @@ svn_wc__db_resolve_break_moved_away(svn_
   src_relpath = svn_dirent_skip_ancestor(wcroot->abspath, src_op_root_abspath);
   SVN_ERR_ASSERT(src_relpath != NULL);
 
-  SVN_WC__DB_WITH_TXN(
-    svn_wc__db_resolve_break_moved_away_internal(wcroot, local_relpath,
-                                                 relpath_depth(src_relpath),
-                                                 scratch_pool),
-    wcroot);
+  SVN_WC__DB_WITH_TXN(break_moved_away(wcroot, local_relpath,
+                                       relpath_depth(src_relpath),
+                                       scratch_pool),
+                      wcroot);
 
   if (notify_func)
     {
@@ -2614,7 +2599,7 @@ svn_wc__db_resolve_break_moved_away_chil
   VERIFY_USABLE_WCROOT(wcroot);
 
   SVN_WC__DB_WITH_TXN(
-    break_moved_away_children_internal(wcroot, local_relpath, scratch_pool),
+    break_moved_away_children(wcroot, local_relpath, scratch_pool),
     wcroot);
 
   SVN_ERR(svn_wc__db_update_move_list_notify(wcroot,

Modified: subversion/branches/reuse-ra-session/subversion/mod_dav_svn/deadprops.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/mod_dav_svn/deadprops.c?rev=1658954&r1=1658953&r2=1658954&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/mod_dav_svn/deadprops.c (original)
+++ subversion/branches/reuse-ra-session/subversion/mod_dav_svn/deadprops.c Wed Feb 11 13:29:26 2015
@@ -638,16 +638,14 @@ static void get_name(dav_db *db, dav_pro
     }
   else
     {
-      const void *name;
-
-      apr_hash_this(db->hi, &name, NULL, NULL);
+      const char *name = apr_hash_this_key(db->hi);
 
 #define PREFIX_LEN (sizeof(SVN_PROP_PREFIX) - 1)
       if (strncmp(name, SVN_PROP_PREFIX, PREFIX_LEN) == 0)
 #undef PREFIX_LEN
         {
           pname->ns = SVN_DAV_PROP_NS_SVN;
-          pname->name = (const char *)name + 4;
+          pname->name = name + 4;
         }
       else
         {

Modified: subversion/branches/reuse-ra-session/subversion/mod_dav_svn/util.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/mod_dav_svn/util.c?rev=1658954&r1=1658953&r2=1658954&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/mod_dav_svn/util.c (original)
+++ subversion/branches/reuse-ra-session/subversion/mod_dav_svn/util.c Wed Feb 11 13:29:26 2015
@@ -116,51 +116,51 @@ dav_svn__convert_err(svn_error_t *serr,
                      const char *message,
                      apr_pool_t *pool)
 {
-    dav_error *derr;
+  dav_error *derr;
 
-    /* Remove the trace-only error chain links.  We need predictable
-       protocol behavior regardless of whether or not we're in a
-       debugging build. */
-    svn_error_t *purged_serr = svn_error_purge_tracing(serr);
-
-    /* ### someday mod_dav_svn will send back 'rich' error tags, much
-       finer grained than plain old svn_error_t's.  But for now, all
-       svn_error_t's are marshalled to the client via the single
-       generic <svn:error/> tag nestled within a <D:error> block. */
-
-    /* Examine the Subverion error code, and select the most
-       appropriate HTTP status code.  If no more appropriate HTTP
-       status code maps to the Subversion error code, use the one
-       suggested status provided by the caller. */
-    switch (purged_serr->apr_err)
-      {
-      case SVN_ERR_FS_NOT_FOUND:
-        status = HTTP_NOT_FOUND;
-        break;
-      case SVN_ERR_UNSUPPORTED_FEATURE:
-        status = HTTP_NOT_IMPLEMENTED;
-        break;
-      case SVN_ERR_FS_LOCK_OWNER_MISMATCH:
-      case SVN_ERR_FS_PATH_ALREADY_LOCKED:
-        status = HTTP_LOCKED;
-        break;
-      case SVN_ERR_FS_PROP_BASEVALUE_MISMATCH:
-        status = HTTP_PRECONDITION_FAILED;
-        break;
-        /* add other mappings here */
-      }
-
-    derr = build_error_chain(pool, purged_serr, status);
-    if (message != NULL
-        && !svn_error_find_cause(purged_serr, SVN_ERR_REPOS_HOOK_FAILURE))
-      /* Don't hide hook failures; we might hide the error text */
-      derr = dav_push_error(pool, status, purged_serr->apr_err,
-                            message, derr);
+  /* Remove the trace-only error chain links.  We need predictable
+     protocol behavior regardless of whether or not we're in a
+     debugging build. */
+  svn_error_t *purged_serr = svn_error_purge_tracing(serr);
+
+  /* ### someday mod_dav_svn will send back 'rich' error tags, much
+     finer grained than plain old svn_error_t's.  But for now, all
+     svn_error_t's are marshalled to the client via the single
+     generic <svn:error/> tag nestled within a <D:error> block. */
+
+  /* Examine the Subverion error code, and select the most
+     appropriate HTTP status code.  If no more appropriate HTTP
+     status code maps to the Subversion error code, use the one
+     suggested status provided by the caller. */
+  switch (purged_serr->apr_err)
+    {
+    case SVN_ERR_FS_NOT_FOUND:
+      status = HTTP_NOT_FOUND;
+      break;
+    case SVN_ERR_UNSUPPORTED_FEATURE:
+      status = HTTP_NOT_IMPLEMENTED;
+      break;
+    case SVN_ERR_FS_LOCK_OWNER_MISMATCH:
+    case SVN_ERR_FS_PATH_ALREADY_LOCKED:
+      status = HTTP_LOCKED;
+      break;
+    case SVN_ERR_FS_PROP_BASEVALUE_MISMATCH:
+      status = HTTP_PRECONDITION_FAILED;
+      break;
+      /* add other mappings here */
+    }
+
+  derr = build_error_chain(pool, purged_serr, status);
+  if (message != NULL
+      && !svn_error_find_cause(purged_serr, SVN_ERR_REPOS_HOOK_FAILURE))
+    /* Don't hide hook failures; we might hide the error text */
+    derr = dav_push_error(pool, status, purged_serr->apr_err,
+                          message, derr);
 
-    /* Now, destroy the Subversion error. */
-    svn_error_clear(serr);
+  /* Now, destroy the Subversion error. */
+  svn_error_clear(serr);
 
-    return derr;
+  return derr;
 }
 
 
@@ -571,11 +571,12 @@ dav_svn__sanitize_error(svn_error_t *ser
                         "%s", purged_serr->message);
         }
 
-        svn_error_clear(serr);
-      }
-    return dav_svn__convert_err(safe_err, http_status,
-                                apr_psprintf(r->pool, "%s", safe_err->message),
-                                r->pool);
+      svn_error_clear(serr);
+    }
+
+  return dav_svn__convert_err(safe_err, http_status,
+                              apr_psprintf(r->pool, "%s", safe_err->message),
+                              r->pool);
 }
 
 
@@ -856,7 +857,7 @@ dav_svn__parse_request_skel(svn_skel_t *
   *skel = NULL;
   status = request_body_to_string(&skel_str, r, pool);
   if (status != OK)
-    return OK;
+    return status;
 
   *skel = svn_skel__parse(skel_str->data, skel_str->len, pool);
   return OK;

Modified: subversion/branches/reuse-ra-session/subversion/svn/resolve-cmd.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/svn/resolve-cmd.c?rev=1658954&r1=1658953&r2=1658954&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/svn/resolve-cmd.c (original)
+++ subversion/branches/reuse-ra-session/subversion/svn/resolve-cmd.c Wed Feb 11 13:29:26 2015
@@ -123,7 +123,7 @@ svn_cl__resolve(apr_getopt_t *os,
   svn_pool_destroy(iterpool);
 
   if (had_error)
-    return svn_error_create(SVN_ERR_CL_ERROR_PROCESSING_EXTERNALS, NULL,
+    return svn_error_create(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
                             _("Failure occurred resolving one or more "
                               "conflicts"));
 



Mime
View raw message