anchor.diff:      maybe_handoff(State);
   active(?COVERAGE_REQ{keyspaces=KeySpaces, 
                        request=Request,
  -                     sender=Sender},
  -       State=#state{handoff_node=HN}) when HN =:= none ->
  +                     sender=Sender}, State) ->
  +    %% Coverage request handled in handoff and non-handoff.  Will be forwarded if set.
       vnode_coverage(Sender, Request, KeySpaces, State);
   active(?VNODE_REQ{sender=Sender, request=Request},
          State=#state{handoff_node=HN}) when HN =:= none ->
  
positive.code:     continue(NewState);
  active(trigger_handoff, State) ->
       maybe_handoff(State);
  active(unregistered, State=#state{mod=Mod, modstate=ModState, index=Index}) ->
      lager:debug("~p ~p vnode completed handoff and unregistered.  Cleaning up.",
                  [Index, Mod]),
      {ok, NewModState} = Mod:delete(ModState),
      {stop, normal, State#state{modstate=NewModState,
                                 handoff_node=none,
                                 pool_pid=undefined,
                                 handoff_pid=undefined}}.
  
  
negative.code:     {reply, Reply, active, State, State#state.inactivity_timeout}.
  
  finish_handoff(State=#state{mod=Mod, 
                              modstate=ModState,
                              index=Idx,
                              handoff_node=HN}) ->
      case riak_core_gossip:finish_handoff(Idx, node(), HN, Mod) of
          continue ->
              continue(State#state{handoff_node=none});
          Res when Res == forward; Res == shutdown ->
              %% Have to issue the delete now.  Once unregistered the
              %% vnode master will spin up a new vnode on demand.  
              {ok, NewModState} = Mod:delete(ModState),
              lager:debug("~p ~p vnode finished handoff and deleted.",
                          [Idx, Mod]),
              riak_core_vnode_master:unregister_vnode(Idx, Mod),
              riak_core_vnode_manager:set_not_forwarding(self(), false),
              continue(State#state{modstate=NewModState,
                                   handoff_node=none,
                                   forward=HN})
      end.
  
  handle_event(R={update_forwarding, _Ring}, _StateName, State) ->
  