bug#32672: 27.0.50; image resize on window resizing

[martin rudalics <rudalics@gmx.at>]

[-- Attachment #1: Type: text/plain, Size: 3771 bytes --]

 > Please try with more buffers than initial 2 (*scratch* and *Messages*),
 > e.g. with *info* (just `C-h i'), I get
 >
 > 1 ... current: *scratch* ... window-buffer: *scratch*

... which is something you probably don't even want - it comes from
'get-buffer-create' when making the *info* buffer ...

 > 2 ... current: *scratch* ... window-buffer: *info*
 >
 > which is in an inconsistent state,

... not really - look at the backtrace:

   foo()
   run-hooks(buffer-list-update-hook)
   record-window-buffer(#<window 3 on *info*>)
   set-window-buffer(#<window 3 on *info*> #<buffer *info*>)
   window--display-buffer(#<buffer *info*> #<window 3 on *info*> reuse ((inhibit-same-window)))
   display-buffer-same-window(#<buffer *info*> ((inhibit-same-window)))
   display-buffer(#<buffer *info*> (display-buffer-same-window (inhibit-same-window)))
   pop-to-buffer("*info*" (display-buffer-same-window (inhibit-same-window)) nil)
   pop-to-buffer-same-window("*info*")
   info(nil nil)
   funcall-interactively(info nil nil)
   call-interactively(info nil nil)
   command-execute(info)

'pop-to-buffer' can "reasonably" select the window and thus implicitly
make its buffer current only _after_ the buffer has been displayed via
'display-buffer-same-window'.  I say reasonably because we could make
the buffer current earlier but this doesn't strike me as a very good
idea.  It would constitute an incompatible change in the internal
behavior of 'pop-to-buffer'.

 > and after typing `q' the hook is called 3 times
 >
 > 3 ... current: *scratch* ... window-buffer: *scratch*
 > 4 ... current: *scratch* ... window-buffer: *scratch*
 > 5 ... current: *scratch* ... window-buffer: *scratch*

Look at the backtraces:

3 ... current: *scratch* ... window-buffer: *scratch*
   run-hooks(buffer-list-update-hook)
   record-window-buffer(#<window 3 on *scratch*>)
   set-window-buffer(#<window 3 on *scratch*> #<buffer *scratch*>)
   set-window-buffer-start-and-point(#<window 3 on *scratch*> #<buffer *scratch*> 1 #<marker at 1598 in *scratch*>)
   quit-restore-window(nil bury)
   quit-window()
   Info-exit()
   funcall-interactively(Info-exit)
   call-interactively(Info-exit nil nil)
   command-execute(Info-exit)

This one comes from replacing the *info* buffer with *scratch* in the
window.

4 ... current: *scratch* ... window-buffer: *scratch*
   run-hooks(buffer-list-update-hook)
   select-window(#<window 3 on *scratch*>)
   quit-restore-window(nil bury)
   quit-window()
   Info-exit()
   funcall-interactively(Info-exit)
   call-interactively(Info-exit nil nil)
   command-execute(Info-exit)

This one comes from selecting that window.

5 ... current: *scratch* ... window-buffer: *scratch*
   run-hooks(buffer-list-update-hook)
   bury-buffer-internal(#<buffer *info*>)
   quit-restore-window(nil bury)
   quit-window()
   Info-exit()
   funcall-interactively(Info-exit)
   call-interactively(Info-exit nil nil)
   command-execute(Info-exit)

And this one comes from burying the *info* buffer.  What should we do
instead?

 > And there is the workflow how to break the correct order
 > of `C-x <right> C-x <left>':
 >
 > 1. Create *info* buffer: `C-h i' and quit `q'
 > 2. Split windows `C-x 2' or `C-x 3' (both windows display *scratch*)
 > 3. Check that `C-x <right> C-x <left>' correctly returns to the original
 >     buffer *scratch* in the first window.
 > 4. After `C-x o' in another window `C-x <right> C-x <left>'
 >     doesn't return to the original buffer *scratch*.
 >     It displays *info*.

Evidently, this comment for 'record-window-buffer'

;; The following function is called by `set-window-buffer' _before_ it
;; replaces the buffer of the argument window with the new buffer.

had its purpose.  Please try the attached patch.

Thanks, martin

[-- Attachment #2: buffer-list-update-hook.diff --]
[-- Type: text/plain, Size: 3585 bytes --]

--- a/lisp/window.el
+++ b/lisp/window.el
@@ -4274,9 +4274,7 @@ record-window-buffer
 			       ;; (Bug#12588).
 			       point window-point-insertion-type)))))
 	  (set-window-prev-buffers
-	   window (cons entry (window-prev-buffers window)))))
-
-      (run-hooks 'buffer-list-update-hook))))
+	   window (cons entry (window-prev-buffers window))))))))
 
 (defun unrecord-window-buffer (&optional window buffer)
   "Unrecord BUFFER in WINDOW.
@@ -4301,9 +4299,9 @@ set-window-buffer-start-and-point
   (setq window (window-normalize-window window t))
   (let ((selected (eq window (selected-window)))
 	(current (eq (window-buffer window) (current-buffer))))
-    (set-window-buffer window buffer)
     (when (and selected current)
       (set-buffer buffer))
+    (set-window-buffer window buffer)
     (when start
       ;; Don't force window-start here (even if POINT is nil).
       (set-window-start window start t))
diff --git a/src/window.c b/src/window.c
index 409b01f..d765564 100644
--- a/src/window.c
+++ b/src/window.c
@@ -3573,40 +3573,38 @@ depends on the value of (window-start WINDOW), so if calling this
 
 This function runs `window-scroll-functions' before running
 `window-configuration-change-hook'.  */)
-  (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
+     (Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
 {
-  register Lisp_Object tem, buffer;
-  register struct window *w = decode_live_window (window);
+  Lisp_Object old_buffer, new_buffer;
+  struct window *w = decode_live_window (window);
 
   XSETWINDOW (window, w);
-  buffer = Fget_buffer (buffer_or_name);
-  CHECK_BUFFER (buffer);
-  if (!BUFFER_LIVE_P (XBUFFER (buffer)))
+  old_buffer = w->contents;
+  new_buffer = Fget_buffer (buffer_or_name);
+  CHECK_BUFFER (new_buffer);
+  if (!BUFFER_LIVE_P (XBUFFER (new_buffer)))
     error ("Attempt to display deleted buffer");
 
-  tem = w->contents;
-  if (NILP (tem))
-    error ("Window is deleted");
-  else
+  if (!EQ (old_buffer, new_buffer))
     {
-      if (!EQ (tem, buffer))
-	{
-	  if (EQ (w->dedicated, Qt))
-	    /* WINDOW is strongly dedicated to its buffer, signal an
-	       error.  */
-	    error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
-	  else
-	    /* WINDOW is weakly dedicated to its buffer, reset
-	       dedication.  */
-	    wset_dedicated (w, Qnil);
-
-	  call1 (Qrecord_window_buffer, window);
-	}
+      if (EQ (w->dedicated, Qt))
+	/* WINDOW is strongly dedicated to its buffer, signal an
+	   error.  */
+	error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (old_buffer), name)));
+      else
+	/* WINDOW is weakly dedicated to its buffer, reset
+	   dedication.  */
+	wset_dedicated (w, Qnil);
 
-      unshow_buffer (w);
+      call1 (Qrecord_window_buffer, window);
     }
 
-  set_window_buffer (window, buffer, true, !NILP (keep_margins));
+  unshow_buffer (w);
+
+  set_window_buffer (window, new_buffer, true, !NILP (keep_margins));
+
+  if (!NILP (Vrun_hooks) && !EQ (old_buffer, new_buffer))
+    call1 (Vrun_hooks, Qbuffer_list_update_hook);
 
   return Qnil;
 }
@@ -6415,7 +6413,12 @@ struct saved_window
 	      && BUFFER_LIVE_P (XBUFFER (p->buffer)))
 	    /* If a window we restore gets another buffer, record the
 	       window's old buffer.  */
-	    call1 (Qrecord_window_buffer, window);
+	    {
+	      call1 (Qrecord_window_buffer, window);
+
+	      if (!NILP (Vrun_hooks))
+		call1 (Vrun_hooks, Qbuffer_list_update_hook);
+	    }
 	}
 
       /* Disallow x_set_window_size, temporarily.  */