1.
public int depth(){
	BinaryTree<E> temp = this;
	int count = 0;

	while( !temp.isRoot() ){
		count++;
		temp = temp.parent;
	}

	return count;
}

2.
Here is an approach that does a DFS (or BFS depending on the data structure) search for the item:

public boolean search(E item){
	Linear<BinaryTree<E>> pending = new LinkedStack<BinaryTree<E>>(); // or new LinkedQueue<BinaryTree<E>>();
	pending.add(this);

	boolean found = False;

	while( !pending.isEmpty() && !found ){
		BinaryTree<E> current = pending.remove();

		if( current.data.equals(item) ){
			found = True;
		}else{
			if( current.right != null ){
				pending.add(current.right);
			}

			if( current.left != null ){
				pending.add(current.left);
			}
		}
	}

	return found;
}

By some definition this is "straightforward" given that it's just an implementation of BFS (or DFS) and we can simplify it since we don't have to worry about checking for visited nodes.  However, I don't think it's hard to argue that the recursive version is MUCH more straightforward.  The key challenge with search (and many similar methods) is that we need to keep track of multiple paths in the tree.  For the depth() method, we just were traversing parent links so there was just one path.