Do not show notifications when in fullscreen or screensaver mode....

chrome/browser/notifications/notification_ui_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/notifications/notification_ui_manager.h"
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/fullscreen.h"
+#include "chrome/browser/idle.h"
 #include "chrome/browser/notifications/balloon_collection.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/renderer_host/site_instance.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 
+namespace {
+const int kUserStatePollingIntervalSeconds = 1;
+}
+
 // A class which represents a notification waiting to be shown.
 class QueuedNotification {
  public:
   QueuedNotification(const Notification& notification, Profile* profile)
       : notification_(notification),
         profile_(profile) {
   }
 
   const Notification& notification() const { return notification_; }
   Profile* profile() const { return profile_; }
 
   void Replace(const Notification& new_notification) {
     notification_ = new_notification;
   }
 
  private:
   // The notification to be shown.
   Notification notification_;
 
   // Non owned pointer to the user's profile.
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(QueuedNotification);
 };
 
 NotificationUIManager::NotificationUIManager(PrefService* local_state)
-    : balloon_collection_(NULL) {
+    : balloon_collection_(NULL),
+      is_user_active_(true) {
   registrar_.Add(this, NotificationType::APP_TERMINATING,
                  NotificationService::AllSources());
   position_pref_.Init(prefs::kDesktopNotificationPosition, local_state, this);
+#if defined(OS_MACOSX)
+  InitMacFullScreenMonitor();
+#endif
 }
 
 NotificationUIManager::~NotificationUIManager() {
   STLDeleteElements(&show_queue_);
+#if defined(OS_MACOSX)
+  StopMacFullScreenMonitor();
+#endif
 }
 
 // static
 NotificationUIManager* NotificationUIManager::Create(PrefService* local_state) {
   BalloonCollection* balloons = BalloonCollection::Create();
   NotificationUIManager* instance = new NotificationUIManager(local_state);
   instance->Initialize(balloons);
   balloons->set_space_change_listener(instance);
   return instance;
 }
@@ skipping 56 matching lines @@
 
   return balloon_collection_->RemoveBySourceOrigin(source) || removed;
 }
 
 void NotificationUIManager::CancelAll() {
   STLDeleteElements(&show_queue_);
   balloon_collection_->RemoveAll();
 }
 
 void NotificationUIManager::CheckAndShowNotifications() {
-  // TODO(johnnyg): http://crbug.com/25061 - Check for user idle/presentation.
-  ShowNotifications();
+  CheckUserState();
+  if (is_user_active_)
+    ShowNotifications();
+}
+
+void NotificationUIManager::CheckUserState() {
+  bool is_user_active_previously = is_user_active_;
+  is_user_active_ = CalculateIdleState(0) != IDLE_STATE_LOCKED &&
+                    !IsFullScreenMode();

[evanm, 2011/01/21 00:42:05]

IsFullScreenMode, at least in the Linux implementation, will take a lot of time
to complete.

Is this on the UI thread?
If so, you're blocking the UI thread.
If not, you can't make UI calls from non-UI threads...

[jianli, 2011/01/21 01:15:50]

Yes, it is on UI thread. The Win32/MacOSX implementation should run quite fast.
For Linux, do you know any better way to do the detection? I can do a couple
following things to optimize the Linux experience:
1) Combine screensaver and fullscreen detection code so that we do not need to
call XQueryTree twice for each separate detection.
2) We can also cache the last user state from a very small period of time ago,
say 0.1s.

+  if (is_user_active_ == is_user_active_previously)
+    return;
+
+  if (is_user_active_) {
+    user_state_check_timer_.Stop();
+    ShowNotifications();

[John Gregg, 2011/01/21 07:14:51]

This doesn't look right at first glance because  CheckAndShowNotifications() is
already calling ShowNotifications().  Can you add a comment that this is
detecting (with the a timer) the first time that the user becomes active?  

[jianli, 2011/01/21 20:21:00]

Done.

+  } else if (!user_state_check_timer_.IsRunning()) {
+    user_state_check_timer_.Start(
+        base::TimeDelta::FromSeconds(kUserStatePollingIntervalSeconds), this,
+        &NotificationUIManager::CheckUserState);
+  }
 }
 
 void NotificationUIManager::ShowNotifications() {
   while (!show_queue_.empty() && balloon_collection_->HasSpace()) {
     scoped_ptr<QueuedNotification> queued_notification(show_queue_.front());
     show_queue_.pop_front();
     balloon_collection_->Add(queued_notification->notification(),
                              queued_notification->profile());
   }
 }
@@ skipping 59 matching lines @@
   } else if (type == NotificationType::PREF_CHANGED) {
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kDesktopNotificationPosition)
       balloon_collection_->SetPositionPreference(
           static_cast<BalloonCollection::PositionPreference>(
               position_pref_.GetValue()));
   } else {
     NOTREACHED();
   }
 }