Improve w32notify notifications

* src/w32notify.c (DIRWATCH_BUFFER_SIZE): New macro.
(struct notification): 'terminate' is now a HANDLE.
(send_notifications): Argument is now a pointer to a
notification.  Don't loop waiting for the notification to be
acknowledged by the main thread; instead, just add the
notification to the linked list of notifications waiting to be
acknowledged.
(watch_end): Don't close the directory handle.
(watch_completion): Allocate a new notification structure to be
added to the notifications set.  Call ReadDirectoryChangesW
immediately after adding the new notification, and before sending
a message to the main thread about them.
(watch_worker): Don't loop calling ReadDirectoryChangesW; instead,
call it just once -- it will be called again in watch_completion.
Loop waiting for the main thread's indication to terminate.
(start_watching): Create the event to be used to indicate to the
worker thread that its should terminate.
(remove_watch): Indicate to the worker thread that it should
terminate.
* src/w32term.c (queue_notifications): Loop over all the
notifications in the linked list, processing all of them in one
go.
* src/w32inevt.c (handle_file_notifications): Loop over all the
notifications in the linked list.
* src/w32xfns.c (init_crit): Initialize the linked list of file
notifications.
(delete_crit): Free the linked list of file notifications,
including any unprocessed notifications left in it.
* src/w32term.h (struct notifications_se): New struct.

* test/lisp/filenotify-tests.el (file-notify-test02-events)
(file-notify-test05-dir-validity): Add read-event calls to
facilitate event recognition by the main thread in batch mode.

1 files changed, 66 insertions, 50 deletions

diff --git a/src/w32term.c b/src/w32term.c
index 62ad4eb086b..8955ce26b4b 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -3211,71 +3211,85 @@ static void
 queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
                      int *evcount)
 {
-  BYTE *p = file_notifications;
-  FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
-  const DWORD min_size
-    = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
+  struct notifications_set *ns = NULL;
   Lisp_Object frame;
+  int done = 0;
 
   /* We cannot process notification before Emacs is fully initialized,
      since we need the UTF-16LE coding-system to be set up.  */
   if (!initialized)
-    {
-      notification_buffer_in_use = 0;
-      return;
-    }
+    return;
 
   XSETFRAME (frame, f);
 
-  enter_crit ();
-  if (notification_buffer_in_use)
+  while (!done)
     {
-      DWORD info_size = notifications_size;
-      Lisp_Object cs = Qutf_16le;
-      Lisp_Object obj = w32_get_watch_object (notifications_desc);
-
-      /* notifications_size could be zero when the buffer of
-         notifications overflowed on the OS level, or when the
-         directory being watched was itself deleted.  Do nothing in
-         that case.  */
-      if (info_size
-          && !NILP (obj) && CONSP (obj))
+      ns = NULL;
+
+      /* Find out if there is a record available in the linked list of
+         notifications sets.  If so, unlink the set from the linked
+         list.  Use critical section.  */
+      enter_crit ();
+      if (notifications_set_head->next != notifications_set_head)
         {
-          Lisp_Object callback = XCDR (obj);
+          ns = notifications_set_head->next;
+          ns->prev->next = ns->next;
+          ns->next->prev = ns->prev;
+        }
+      else
+        done = 1;
+      leave_crit();
 
-          while (info_size >= min_size)
+      if (ns)
+        {
+          BYTE *p = ns->notifications;
+          FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
+          const DWORD min_size
+            = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
+          DWORD info_size = ns->size;
+          Lisp_Object cs = Qutf_16le;
+          Lisp_Object obj = w32_get_watch_object (ns->desc);
+
+          /* notifications size could be zero when the buffer of
+             notifications overflowed on the OS level, or when the
+             directory being watched was itself deleted.  Do nothing in
+             that case.  */
+          if (info_size
+              && !NILP (obj) && CONSP (obj))
             {
-              Lisp_Object utf_16_fn
-                = make_unibyte_string ((char *)fni->FileName,
-                                       fni->FileNameLength);
-              /* Note: mule-conf is preloaded, so utf-16le must
-                 already be defined at this point.  */
-              Lisp_Object fname
-                = code_convert_string_norecord (utf_16_fn, cs, 0);
-              Lisp_Object action = lispy_file_action (fni->Action);
-
-              event->kind = FILE_NOTIFY_EVENT;
-              event->timestamp = msg->msg.time;
-              event->modifiers = 0;
-              event->frame_or_window = callback;
-              event->arg = list3 (make_pointer_integer (notifications_desc),
-                                  action, fname);
-              kbd_buffer_store_event (event);
-              (*evcount)++;
-
-              if (!fni->NextEntryOffset)
-                break;
-              p += fni->NextEntryOffset;
-              fni = (PFILE_NOTIFY_INFORMATION)p;
-              info_size -= fni->NextEntryOffset;
+              Lisp_Object callback = XCDR (obj);
+
+              while (info_size >= min_size)
+                {
+                  Lisp_Object utf_16_fn
+                    = make_unibyte_string ((char *)fni->FileName,
+                                           fni->FileNameLength);
+                  /* Note: mule-conf is preloaded, so utf-16le must
+                     already be defined at this point.  */
+                  Lisp_Object fname
+                    = code_convert_string_norecord (utf_16_fn, cs, 0);
+                  Lisp_Object action = lispy_file_action (fni->Action);
+
+                  event->kind = FILE_NOTIFY_EVENT;
+                  event->timestamp = msg->msg.time;
+                  event->modifiers = 0;
+                  event->frame_or_window = callback;
+                  event->arg = list3 (make_pointer_integer (ns->desc),
+                                      action, fname);
+                  kbd_buffer_store_event (event);
+                  (*evcount)++;
+                  if (!fni->NextEntryOffset)
+                    break;
+                  p += fni->NextEntryOffset;
+                  fni = (PFILE_NOTIFY_INFORMATION)p;
+                  info_size -= fni->NextEntryOffset;
+                }
             }
+          /* Free this notifications set. */
+          xfree (ns->notifications);
+          xfree (ns);
         }
-      notification_buffer_in_use = 0;
     }
-  else
-    DebPrint (("We were promised notifications, but in-use flag is zero!\n"));
-  leave_crit ();
-
   /* We've stuffed all the events ourselves, so w32_read_socket shouldn't.  */
   event->kind = NO_EVENT;
 }
@@ -6949,6 +6963,8 @@ w32_init_main_thread (void)
   DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
                    GetCurrentProcess (), &hMainThread, 0, TRUE,
                    DUPLICATE_SAME_ACCESS);
+
+
 }
 
 DWORD WINAPI w32_msg_worker (void * arg);