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

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.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/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 1241 matching lines @@
   // minimized.
   bool is_minimized = IsMinimized();
   if (is_minimized != was_minimized) {
     if (is_minimized) {
       compositor()->SetVisible(false);
       content_window_->Hide();
     } else {
       content_window_->Show();
       compositor()->SetVisible(true);
     }
   }

[sadrul, 2015/03/03 00:41:46]

If this block of code does the right thing (i.e. content_window_->Hide() is
called), that should be sufficient to trigger the visibility events (that's how
it works when switching between tabs, right?). Can you explain why this alone
wouldn't be sufficient?

[joone, 2015/03/03 03:30:22]

Please see my previous comment.

 
   if (restored_bounds_in_pixels_.IsEmpty()) {
     DCHECK(!IsFullscreen());
     if (IsMaximized()) {
       // The request that we become maximized originated from a different
       // process. |bounds_in_pixels_| already contains our maximized bounds. Do
       // a best effort attempt to get restored bounds by setting it to our
       // previously set bounds (and if we get this wrong, we aren't any worse
       // off since we'd otherwise be returning our maximized bounds).
       restored_bounds_in_pixels_ = previous_bounds_in_pixels_;
@@ skipping 472 matching lines @@
                               &unused);
       }
       gfx::Rect bounds_in_pixels(translated_x_in_pixels, translated_y_in_pixels,
                                  xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_in_pixels_.size() != bounds_in_pixels.size();
       bool origin_changed =
           bounds_in_pixels_.origin() != bounds_in_pixels.origin();
       previous_bounds_in_pixels_ = bounds_in_pixels_;
       bounds_in_pixels_ = bounds_in_pixels;
 
-      if (origin_changed)
+      if (origin_changed) {
         OnHostMoved(bounds_in_pixels_.origin());
+        // Allows to trigger visibilityChange events while swithcing between
+        // workspaces.
+        ::Screen* screen = DefaultScreenOfDisplay(xdisplay_);
+        int screen_width = WidthOfScreen(screen);
+        int screen_height = HeightOfScreen(screen);
+
+        if (translated_x_in_pixels < 0 || translated_x_in_pixels > screen_width
+            || translated_y_in_pixels < 0 ||
+            translated_y_in_pixels > screen_height)
+          content_window_->SetPageVisibility(false);
+        else
+          content_window_->SetPageVisibility(true);
+      }
 
       if (size_changed) {
         delayed_resize_task_.Reset(base::Bind(
             &DesktopWindowTreeHostX11::DelayedResize,
             close_widget_factory_.GetWeakPtr(), bounds_in_pixels.size()));
         base::MessageLoop::current()->PostTask(
             FROM_HERE, delayed_resize_task_.callback());
       }
       break;
     }
@@ skipping 219 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views