[gnome-shell/wip/jstpierre/cursor-position-tracker] Replace cursor position monitoring with MetaCursorTracker

[Jasper St. Pierre <jstpierre src gnome org>]

commit 8c9aa2efd9fa3fbb87efa85d4b7cb5e93d77a105
Author: Jasper St. Pierre <jstpierre mecheye net>
Date:   Thu Feb 23 11:13:36 2017 -0800

    Replace cursor position monitoring with MetaCursorTracker
    
    I was tired of seeing 1s updates in shell recording videos when seeing
    them on Planet GNOME, so here you go.

 js/ui/pointerWatcher.js |   59 ++++++----------------------------------------
 src/shell-recorder.c    |   45 ++++-------------------------------
 2 files changed, 14 insertions(+), 90 deletions(-)
---
diff --git a/js/ui/pointerWatcher.js b/js/ui/pointerWatcher.js
index c59d741..d3fe8e3 100644
--- a/js/ui/pointerWatcher.js
+++ b/js/ui/pointerWatcher.js
@@ -7,13 +7,6 @@ const Meta = imports.gi.Meta;
 const GnomeDesktop = imports.gi.GnomeDesktop;
 const Shell = imports.gi.Shell;
 
-// We stop polling if the user is idle for more than this amount of time
-const IDLE_TIME = 1000;
-
-// This file implements a reasonably efficient system for tracking the position
-// of the mouse pointer. We simply query the pointer from the X server in a loop,
-// but we turn off the polling when the user is idle.
-
 let _pointerWatcher = null;
 function getPointerWatcher() {
     if (_pointerWatcher == null)
@@ -25,9 +18,8 @@ function getPointerWatcher() {
 const PointerWatch = new Lang.Class({
     Name: 'PointerWatch',
 
-    _init: function(watcher, interval, callback) {
+    _init: function(watcher, callback) {
         this.watcher = watcher;
-        this.interval = interval;
         this.callback = callback;
     },
 
@@ -43,9 +35,9 @@ const PointerWatcher = new Lang.Class({
     Name: 'PointerWatcher',
 
     _init: function() {
-        this._idleMonitor = Meta.IdleMonitor.get_core();
-        this._idleMonitor.add_idle_watch(IDLE_TIME, Lang.bind(this, this._onIdleMonitorBecameIdle));
-        this._idle = this._idleMonitor.get_idletime() > IDLE_TIME;
+        this._cursorTracker = Meta.CursorTracker.get_for_screen(global.screen);
+        this._cursorTracker.connect('position-changed', Lang.bind(this, this._updatePointer));
+
         this._watches = [];
         this.pointerX = null;
         this.pointerY = null;
@@ -61,60 +53,25 @@ const PointerWatcher = new Lang.Class({
     // Set up a watch on the position of the mouse pointer. Returns a
     // PointerWatch object which has a remove() method to remove the watch.
     addWatch: function(interval, callback) {
+        this._cursorTracker.enable_track_position();
+
         // Avoid unreliably calling the watch for the current position
         this._updatePointer();
 
-        let watch = new PointerWatch(this, interval, callback);
-        this._watches.push(watch);
-        this._updateTimeout();
+        this._watches.push(callback);
         return watch;
     },
 
     _removeWatch: function(watch) {
         for (let i = 0; i < this._watches.length; i++) {
             if (this._watches[i] == watch) {
+                this._cursorTracker.disable_track_position();
                 this._watches.splice(i, 1);
-                this._updateTimeout();
                 return;
             }
         }
     },
 
-    _onIdleMonitorBecameActive: function(monitor) {
-        this._idle = false;
-        this._updatePointer();
-        this._updateTimeout();
-    },
-
-    _onIdleMonitorBecameIdle: function(monitor) {
-        this._idle = true;
-        this._idleMonitor.add_user_active_watch(Lang.bind(this, this._onIdleMonitorBecameActive));
-        this._updateTimeout();
-    },
-
-    _updateTimeout: function() {
-        if (this._timeoutId) {
-            Mainloop.source_remove(this._timeoutId);
-            this._timeoutId = 0;
-        }
-
-        if (this._idle || this._watches.length == 0)
-            return;
-
-        let minInterval = this._watches[0].interval;
-        for (let i = 1; i < this._watches.length; i++)
-            minInterval = Math.min(this._watches[i].interval, minInterval);
-
-        this._timeoutId = Mainloop.timeout_add(minInterval,
-                                               Lang.bind(this, this._onTimeout));
-        GLib.Source.set_name_by_id(this._timeoutId, '[gnome-shell] this._onTimeout');
-    },
-
-    _onTimeout: function() {
-        this._updatePointer();
-        return GLib.SOURCE_CONTINUE;
-    },
-
     _updatePointer: function() {
         let [x, y, mods] = global.get_pointer();
         if (this.pointerX == x && this.pointerY == y)
diff --git a/src/shell-recorder.c b/src/shell-recorder.c
index 8a907a9..1ec585d 100644
--- a/src/shell-recorder.c
+++ b/src/shell-recorder.c
@@ -80,7 +80,6 @@ struct _ShellRecorder {
   guint redraw_timeout;
   guint redraw_idle;
   guint update_memory_used_timeout;
-  guint update_pointer_timeout;
   guint repaint_hook_id;
 };
 
@@ -126,11 +125,6 @@ G_DEFINE_TYPE(ShellRecorder, shell_recorder, G_TYPE_OBJECT);
  */
 #define DEFAULT_FRAMES_PER_SECOND 30
 
-/* The time (in milliseconds) between querying the server for the cursor
- * position.
- */
-#define UPDATE_POINTER_TIME 100
-
 /* The time we wait (in milliseconds) before redrawing when the memory used
  * changes.
  */
@@ -537,7 +531,8 @@ on_cursor_changed (MetaCursorTracker *tracker,
 }
 
 static void
-recorder_update_pointer (ShellRecorder *recorder)
+on_cursor_position_changed (MetaCursorTracker *tracker,
+                            ShellRecorder     *recorder)
 {
   int pointer_x, pointer_y;
 
@@ -551,36 +546,6 @@ recorder_update_pointer (ShellRecorder *recorder)
     }
 }
 
-static gboolean
-recorder_update_pointer_timeout (gpointer data)
-{
-  recorder_update_pointer (data);
-
-  return TRUE;
-}
-
-static void
-recorder_add_update_pointer_timeout (ShellRecorder *recorder)
-{
-  if (!recorder->update_pointer_timeout)
-    {
-      recorder->update_pointer_timeout = g_timeout_add (UPDATE_POINTER_TIME,
-                                                        recorder_update_pointer_timeout,
-                                                        recorder);
-      g_source_set_name_by_id (recorder->update_pointer_timeout, "[gnome-shell] 
recorder_update_pointer_timeout");
-    }
-}
-
-static void
-recorder_remove_update_pointer_timeout (ShellRecorder *recorder)
-{
-  if (recorder->update_pointer_timeout)
-    {
-      g_source_remove (recorder->update_pointer_timeout);
-      recorder->update_pointer_timeout = 0;
-    }
-}
-
 static void
 recorder_connect_stage_callbacks (ShellRecorder *recorder)
 {
@@ -652,6 +617,8 @@ recorder_set_screen (ShellRecorder *recorder,
   recorder->cursor_tracker = tracker;
   g_signal_connect_object (tracker, "cursor-changed",
                            G_CALLBACK (on_cursor_changed), recorder, 0);
+  g_signal_connect_object (tracker, "position-changed",
+                           G_CALLBACK (on_cursor_position_changed), recorder, 0);
 }
 
 static void
@@ -1514,7 +1481,7 @@ shell_recorder_record (ShellRecorder  *recorder,
 
   recorder->state = RECORDER_STATE_RECORDING;
   recorder_update_pointer (recorder);
-  recorder_add_update_pointer_timeout (recorder);
+  meta_cursor_tracker_enable_track_position (recorder->cursor_tracker);
 
   /* Disable unredirection while we are recoring */
   meta_disable_unredirect_for_screen (shell_global_get_screen (shell_global_get ()));
@@ -1553,7 +1520,7 @@ shell_recorder_close (ShellRecorder *recorder)
    */
   clutter_actor_paint (CLUTTER_ACTOR (recorder->stage));
 
-  recorder_remove_update_pointer_timeout (recorder);
+  meta_cursor_tracker_disable_track_position (recorder->cursor_tracker);
   recorder_close_pipeline (recorder);
 
   /* Queue a redraw to remove the recording indicator */