Attempt 2 at: Makes Window not change focus and send out

ui/aura/window.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 331 matching lines @@
 
 void Window::StackChildAbove(Window* child, Window* target) {
   StackChildRelativeTo(child, target, STACK_ABOVE);
 }
 
 void Window::StackChildBelow(Window* child, Window* target) {
   StackChildRelativeTo(child, target, STACK_BELOW);
 }
 
 void Window::AddChild(Window* child) {
+  RootWindow* old_root = child->GetRootWindow();
+
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
-    child->parent()->RemoveChild(child);
+    child->parent()->RemoveChildImpl(child, this);
   child->parent_ = this;
 
   layer_->Add(child->layer_);
 
   children_.push_back(child);
   if (layout_manager_.get())
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
   child->OnParentChanged();
 
-  RootWindow* root_window = child->GetRootWindow();
-  if (root_window) {
+  RootWindow* root_window = GetRootWindow();
+  if (root_window && old_root != root_window) {
     root_window->OnWindowAddedToRootWindow(child);
     child->NotifyAddedToRootWindow();
   }
 }
 
 void Window::AddTransientChild(Window* child) {
   if (child->transient_parent_)
     child->transient_parent_->RemoveTransientChild(child);
   DCHECK(std::find(transient_children_.begin(), transient_children_.end(),
                    child) == transient_children_.end());
   transient_children_.push_back(child);
   child->transient_parent_ = this;
 }
 
 void Window::RemoveTransientChild(Window* child) {
   Windows::iterator i =
       std::find(transient_children_.begin(), transient_children_.end(), child);
   DCHECK(i != transient_children_.end());
   transient_children_.erase(i);
   if (child->transient_parent_ == this)
     child->transient_parent_ = NULL;
 }
 
 void Window::RemoveChild(Window* child) {
-  Windows::iterator i = std::find(children_.begin(), children_.end(), child);
-  DCHECK(i != children_.end());
-  if (layout_manager_.get())
-    layout_manager_->OnWillRemoveWindowFromLayout(child);
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
-  RootWindow* root_window = child->GetRootWindow();
-  if (root_window) {
-    root_window->OnWindowRemovedFromRootWindow(child);
-    child->NotifyRemovingFromRootWindow();
-  }
-  child->parent_ = NULL;
-  // We should only remove the child's layer if the child still owns that layer.
-  // Someone else may have acquired ownership of it via AcquireLayer() and may
-  // expect the hierarchy to go unchanged as the Window is destroyed.
-  if (child->layer_owner_.get())
-    layer_->Remove(child->layer_);
-  children_.erase(i);
-  child->OnParentChanged();
-  if (layout_manager_.get())
-    layout_manager_->OnWindowRemovedFromLayout(child);
+  RemoveChildImpl(child, NULL);
 }
 
 bool Window::Contains(const Window* other) const {
   for (const Window* parent = other; parent; parent = parent->parent_) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
@@ skipping 347 matching lines @@
     Window* match = child->GetWindowForPoint(point_in_child_coords,
                                              return_tightest,
                                              for_event_handling);
     if (match)
       return match;
   }
 
   return delegate_ ? this : NULL;
 }
 
+void Window::RemoveChildImpl(Window* child, Window* new_parent) {
+  Windows::iterator i = std::find(children_.begin(), children_.end(), child);
+  DCHECK(i != children_.end());
+  if (layout_manager_.get())
+    layout_manager_->OnWillRemoveWindowFromLayout(child);
+  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
+  RootWindow* root_window = child->GetRootWindow();
+  if (root_window &&
+      (!new_parent || new_parent->GetRootWindow() != root_window)) {
+    root_window->OnWindowRemovedFromRootWindow(child);
+    child->NotifyRemovingFromRootWindow();
+  }
+  child->parent_ = NULL;
+  // We should only remove the child's layer if the child still owns that layer.
+  // Someone else may have acquired ownership of it via AcquireLayer() and may
+  // expect the hierarchy to go unchanged as the Window is destroyed.
+  if (child->layer_owner_.get())
+    layer_->Remove(child->layer_);
+  children_.erase(i);
+  child->OnParentChanged();
+  if (layout_manager_.get())
+    layout_manager_->OnWindowRemovedFromLayout(child);
+}
+
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
 void Window::StackChildRelativeTo(Window* child,
                                   Window* target,
                                   StackDirection direction) {
   DCHECK_NE(child, target);
   DCHECK(child);
@@ skipping 159 matching lines @@
   for (Windows::const_reverse_iterator it = children_.rbegin(),
            rend = children_.rend();
        it != rend; ++it) {
     Window* child = *it;
     child->PrintWindowHierarchy(depth + 1);
   }
 }
 #endif
 
 }  // namespace aura