Make Page Visibility API work when the browser window is visible or not

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 934 matching lines @@
   else if (layer())
     layer()->SetVisible(visible);
   visible_ = visible;
   SchedulePaint();
   if (parent_ && parent_->layout_manager_)
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
 
   if (delegate_)
     delegate_->OnWindowTargetVisibilityChanged(visible);
 
-  NotifyWindowVisibilityChanged(this, visible);
+  NotifyWindowVisibilityChanged(this, visible, false);
 }
 
+#if defined(OS_LINUX)
+// Trigger the VisibilityChange event.
+void Window::SetPageVisibility(bool visible) {
+  // The third parameter is used to show content even if the visible parameter
+  // is false, which is needed for a workspace view like Mac Expose.
+  NotifyWindowVisibilityChanged(this, visible, true);
+}
+#endif
+
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 void Window::Paint(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
   PaintLayerlessChildren(canvas);
 }
 
@@ skipping 307 matching lines @@
     FOR_EACH_OBSERVER(WindowObserver, observers_,
                       OnWindowHierarchyChanged(local_params));
     break;
   default:
     NOTREACHED();
     break;
   }
 }
 
 void Window::NotifyWindowVisibilityChanged(aura::Window* target,
-                                           bool visible) {
-  if (!NotifyWindowVisibilityChangedDown(target, visible)) {
+                                           bool visible, bool content_visible) {
+  if (!NotifyWindowVisibilityChangedDown(target, visible, content_visible)) {
     return; // |this| has been deleted.
   }
   NotifyWindowVisibilityChangedUp(target, visible);
 }
 
 bool Window::NotifyWindowVisibilityChangedAtReceiver(aura::Window* target,
-                                                     bool visible) {
+                                                     bool visible,
+                                                     bool content_visible) {
   // |this| may be deleted during a call to OnWindowVisibilityChanged() on one
   // of the observers. We create an local observer for that. In that case we
   // exit without further access to any members.
   WindowTracker tracker;
   tracker.Add(this);
   FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowVisibilityChanged(target, visible));
+                  OnWindowVisibilityChanged(target, visible, content_visible));
   return tracker.Contains(this);
 }
 
 bool Window::NotifyWindowVisibilityChangedDown(aura::Window* target,
-                                               bool visible) {
-  if (!NotifyWindowVisibilityChangedAtReceiver(target, visible))
+                                               bool visible,
+                                               bool content_visible) {
+  if (!NotifyWindowVisibilityChangedAtReceiver(target, visible,
+      content_visible))
     return false; // |this| was deleted.
   std::set<const Window*> child_already_processed;
   bool child_destroyed = false;
   do {
     child_destroyed = false;
     for (Window::Windows::const_iterator it = children_.begin();
          it != children_.end(); ++it) {
       if (!child_already_processed.insert(*it).second)
         continue;
-      if (!(*it)->NotifyWindowVisibilityChangedDown(target, visible)) {
+      if (!(*it)->NotifyWindowVisibilityChangedDown(target, visible,
+          content_visible)) {
         // |*it| was deleted, |it| is invalid and |children_| has changed.
         // We exit the current for-loop and enter a new one.
         child_destroyed = true;
         break;
       }
     }
   } while (child_destroyed);
   return true;
 }
 
 void Window::NotifyWindowVisibilityChangedUp(aura::Window* target,
                                              bool visible) {
   // Start with the parent as we already notified |this|
   // in NotifyWindowVisibilityChangedDown.
   for (Window* window = parent(); window; window = window->parent()) {
-    bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
+    bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible,
+        false);
     DCHECK(ret);
   }
 }
 
 void Window::NotifyAncestorWindowTransformed(Window* source) {
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnAncestorWindowTransformed(source, this));
   for (Window::Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     (*it)->NotifyAncestorWindowTransformed(source);
@@ skipping 121 matching lines @@
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura