When DWM compositing is disabled (i.e. XP, RDP) ensure that windowed NPAPI plugins don't cover UI d…

content/browser/web_contents/web_contents_view_aura.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 "content/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 637 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(OverscrollNavigationOverlay);
 };
 
 class WebContentsViewAura::WindowObserver
     : public aura::WindowObserver, public aura::RootWindowObserver {
  public:
   explicit WindowObserver(WebContentsViewAura* view)
       : view_(view),
         parent_(NULL) {
     view_->window_->AddObserver(this);
+
+#if defined(OS_WIN)
+    if (view_->window_->GetRootWindow())
+      view_->window_->GetRootWindow()->AddObserver(this);
+#endif
   }
 
   virtual ~WindowObserver() {
     view_->window_->RemoveObserver(this);
     if (view_->window_->GetDispatcher())
       view_->window_->GetDispatcher()->RemoveRootWindowObserver(this);
     if (parent_)
       parent_->RemoveObserver(this);
 
 #if defined(OS_WIN)
     if (parent_) {
       const aura::Window::Windows& children = parent_->children();
       for (size_t i = 0; i < children.size(); ++i)
         children[i]->RemoveObserver(this);
     }
+
+    aura::Window* root_window = view_->window_->GetRootWindow();
+    if (root_window) {
+      root_window->RemoveObserver(this);
+      const aura::Window::Windows& root_children = root_window->children();
+      for (size_t i = 0; i < root_children.size(); ++i)
+        root_children[i]->RemoveObserver(this);
+    }
 #endif
   }
 
   // Overridden from aura::WindowObserver:
 #if defined(OS_WIN)
   // Constrained windows are added as children of the parent's parent's view
   // which may overlap with windowed NPAPI plugins. In that case, tell the RWHV
   // so that it can update the plugins' cutout rects accordingly.
   // Note: this is hard coding how Chrome layer adds its dialogs. Since NPAPI is
   // going to be deprecated in a year, this is ok for now. The test for this is
   // PrintPreviewTest.WindowedNPAPIPluginHidden.
   virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE {
-    if (new_window->parent() != parent_)
+    if (new_window == view_->window_)
       return;
 
-    new_window->AddObserver(this);
-    UpdateConstrainedWindows(NULL);
+    if (new_window == parent_)
+      return;  // This happens if the parent moves to the root window.
+
+    // Observe sibling windows of the WebContents, or children of the root
+    // window.
+    if (new_window->parent() == parent_ ||
+        new_window->parent() == view_->window_->GetRootWindow()) {
+      new_window->AddObserver(this);
+      UpdateConstrainedWindows(NULL);
+    }
   }
 
   virtual void OnWillRemoveWindow(aura::Window* window) OVERRIDE {
-    if (window->parent() == parent_ && window != view_->window_) {
-      window->RemoveObserver(this);
-      UpdateConstrainedWindows(window);
-    }
+    if (window == view_->window_)
+      return;
+
+    window->RemoveObserver(this);
+    UpdateConstrainedWindows(window);
   }
 
   virtual void OnWindowVisibilityChanged(aura::Window* window,
                                          bool visible) OVERRIDE {
-    if (window->parent() == parent_ && window != view_->window_)
+    if (window == view_->window_)
+      return;
+
+    if (window->parent() == parent_ ||
+        window->parent() == view_->window_->GetRootWindow()) {
       UpdateConstrainedWindows(NULL);
+    }
   }
 #endif
 
   virtual void OnWindowParentChanged(aura::Window* window,
                                      aura::Window* parent) OVERRIDE {
     if (window != view_->window_)
       return;
     if (parent_)
       parent_->RemoveObserver(this);
 
 #if defined(OS_WIN)
     if (parent_) {
       const aura::Window::Windows& children = parent_->children();
       for (size_t i = 0; i < children.size(); ++i)
         children[i]->RemoveObserver(this);
 
       RenderWidgetHostViewAura* view = ToRenderWidgetHostViewAura(
           view_->web_contents_->GetRenderWidgetHostView());
       if (view)
         view->UpdateConstrainedWindowRects(std::vector<gfx::Rect>());
     }
+
+    // When we get parented to the root window, the code below will watch the
+    // parent, aka root window. Since we already watch the root window on
+    // Windows, unregister first so that the debug check doesn't fire.
+    if (parent && parent == window->GetRootWindow())
+      parent->RemoveObserver(this);
 #endif
 
     parent_ = parent;
     if (parent) {
       parent->AddObserver(this);
 #if defined(OS_WIN)
-      const aura::Window::Windows& children = parent_->children();
-      for (size_t i = 0; i < children.size(); ++i) {
-        if (children[i] != view_->window_)
-          children[i]->AddObserver(this);
+      if (parent != window->GetRootWindow()) {
+        const aura::Window::Windows& children = parent->children();
+        for (size_t i = 0; i < children.size(); ++i) {
+          if (children[i] != view_->window_)
+            children[i]->AddObserver(this);
+        }
       }
 #endif
     }
   }
 
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE {
     if (window == parent_ || window == view_->window_) {
       SendScreenRects();
       if (view_->touch_editable_)
         view_->touch_editable_->UpdateEditingController();
 #if defined(OS_WIN)
     } else {
       UpdateConstrainedWindows(NULL);
 #endif
     }
   }
 
   virtual void OnWindowAddedToRootWindow(aura::Window* window) OVERRIDE {
-    if (window == view_->window_)
+    if (window == view_->window_) {
       window->GetDispatcher()->AddRootWindowObserver(this);
+#if defined(OS_WIN)
+      window->GetRootWindow()->AddObserver(this);
+#endif
+    }
   }
 
   virtual void OnWindowRemovingFromRootWindow(aura::Window* window) OVERRIDE {
-    if (window == view_->window_)
+    if (window == view_->window_) {
       window->GetDispatcher()->RemoveRootWindowObserver(this);
+#if defined(OS_WIN)
+      window->GetRootWindow()->RemoveObserver(this);
+#endif
+    }
   }
 
   // Overridden RootWindowObserver:
   virtual void OnRootWindowHostMoved(const aura::RootWindow* root,
                                      const gfx::Point& new_origin) OVERRIDE {
     TRACE_EVENT1("ui",
                  "WebContentsViewAura::WindowObserver::OnRootWindowHostMoved",
                  "new_origin", new_origin.ToString());
 
     // This is for the desktop case (i.e. Aura desktop).
     SendScreenRects();
   }
 
  private:
   void SendScreenRects() {
     RenderWidgetHostImpl::From(view_->web_contents_->GetRenderViewHost())->
         SendScreenRects();
   }
 
 #if defined(OS_WIN)
   void UpdateConstrainedWindows(aura::Window* exclude) {
     RenderWidgetHostViewAura* view = ToRenderWidgetHostViewAura(
         view_->web_contents_->GetRenderWidgetHostView());
     if (!view)
       return;
 
     std::vector<gfx::Rect> constrained_windows;
-    const aura::Window::Windows& children = parent_->children();
-    for (size_t i = 0; i < children.size(); ++i) {
-      if (children[i] != view_->window_ &&
-          children[i] != exclude &&
-          children[i]->IsVisible()) {
-        constrained_windows.push_back(children[i]->GetBoundsInRootWindow());
+    if (parent_) {
+      const aura::Window::Windows& children = parent_->children();
+      for (size_t i = 0; i < children.size(); ++i) {
+        if (children[i] != view_->window_ &&
+            children[i] != exclude &&
+            children[i]->IsVisible()) {
+          constrained_windows.push_back(children[i]->GetBoundsInRootWindow());
+        }
+      }
+    }
+
+    aura::Window* root_window = view_->window_->GetRootWindow();
+    const aura::Window::Windows& root_children = root_window->children();
+    if (root_window) {
+      for (size_t i = 0; i < root_children.size(); ++i) {
+        if (root_children[i]->IsVisible() &&
+            !root_children[i]->Contains(view_->window_.get())) {
+          constrained_windows.push_back(
+              root_children[i]->GetBoundsInRootWindow());
+        }
       }
     }
 
     view->UpdateConstrainedWindowRects(constrained_windows);
   }
 #endif
 
   WebContentsViewAura* view_;
 
   // We cache the old parent so that we can unregister when it's not the parent
@@ skipping 837 matching lines @@
       event.location(),
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint(),
       ConvertAuraEventFlagsToWebInputEventModifiers(event.flags()));
   if (drag_dest_delegate_)
     drag_dest_delegate_->OnDrop();
   current_drop_data_.reset();
   return current_drag_op_;
 }
 
 }  // namespace content