Update calls to addEventToTimeline and addLiveEvents for new signature

Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>

src/components/structures/FilePanel.tsx

@@ -104,7 +104,11 @@ class FilePanel extends React.Component<IProps, IState> {
         }
 
         if (!this.state.timelineSet.eventIdToTimeline(ev.getId()!)) {
-            this.state.timelineSet.addEventToTimeline(ev, timeline, false);
+            this.state.timelineSet.addEventToTimeline(ev, timeline, {
+                fromCache: false,
+                addToState: false,
+                toStartOfTimeline: false,
+            });
         }
     }
 

src/indexing/EventIndex.ts

@@ -820,7 +820,11 @@ export default class EventIndex extends EventEmitter {
         // Add the events to the timeline of the file panel.
         matrixEvents.forEach((e) => {
             if (!timelineSet.eventIdToTimeline(e.getId()!)) {
-                timelineSet.addEventToTimeline(e, timeline, direction == EventTimeline.BACKWARDS);
+                timelineSet.addEventToTimeline(e, timeline, {
+                    toStartOfTimeline: direction == EventTimeline.BACKWARDS,
+                    fromCache: false,
+                    addToState: false,
+                });
             }
         });
 

src/utils/dm/createDmLocalRoom.ts

@@ -109,7 +109,7 @@ export async function createDmLocalRoom(client: MatrixClient, targets: Member[])
 
     localRoom.targets = targets;
     localRoom.updateMyMembership(KnownMembership.Join);
-    localRoom.addLiveEvents(events);
+    localRoom.addLiveEvents(events, { addToState: true });
     localRoom.currentState.setStateEvents(events);
     localRoom.name = localRoom.getDefaultRoomName(client.getUserId()!);
     client.store.storeRoom(localRoom);

test/test-utils/call.ts

@@ -44,17 +44,20 @@ export class MockedCall extends Call {
     }
 
     public static create(room: Room, id: string) {
-        room.addLiveEvents([
-            mkEvent({
-                event: true,
-                type: this.EVENT_TYPE,
-                room: room.roomId,
-                user: "@alice:example.org",
-                content: { "m.type": "m.video", "m.intent": "m.prompt" },
-                skey: id,
-                ts: Date.now(),
-            }),
-        ]);
+        room.addLiveEvents(
+            [
+                mkEvent({
+                    event: true,
+                    type: this.EVENT_TYPE,
+                    room: room.roomId,
+                    user: "@alice:example.org",
+                    content: { "m.type": "m.video", "m.intent": "m.prompt" },
+                    skey: id,
+                    ts: Date.now(),
+                }),
+            ],
+            { addToState: true },
+        );
         // @ts-ignore deliberately calling a private method
         // Let CallStore know that a call might now exist
         CallStore.instance.updateRoom(room);
@@ -81,17 +84,20 @@ export class MockedCall extends Call {
 
     public destroy() {
         // Terminate the call for good measure
-        this.room.addLiveEvents([
-            mkEvent({
-                event: true,
-                type: MockedCall.EVENT_TYPE,
-                room: this.room.roomId,
-                user: "@alice:example.org",
-                content: { ...this.event.getContent(), "m.terminated": "Call ended" },
-                skey: this.widget.id,
-                ts: Date.now(),
-            }),
-        ]);
+        this.room.addLiveEvents(
+            [
+                mkEvent({
+                    event: true,
+                    type: MockedCall.EVENT_TYPE,
+                    room: this.room.roomId,
+                    user: "@alice:example.org",
+                    content: { ...this.event.getContent(), "m.terminated": "Call ended" },
+                    skey: this.widget.id,
+                    ts: Date.now(),
+                }),
+            ],
+            { addToState: true },
+        );
 
         super.destroy();
     }

test/test-utils/threads.ts

@@ -157,6 +157,6 @@ export const populateThread = async ({
     // that it is already loaded, and send the events again to the room
     // so they are added to the thread timeline.
     ret.thread.initialEventsFetched = true;
-    await room.addLiveEvents(ret.events);
+    await room.addLiveEvents(ret.events, { addToState: false });
     return ret;
 };

test/unit-tests/Notifier-test.ts

@@ -624,8 +624,7 @@ describe("Notifier", () => {
                     content: { body: "this is a thread root" },
                 }),
                 testRoom.threadsTimelineSets[0]!.getLiveTimeline(),
-                false,
-                false,
+                { toStartOfTimeline: false, fromCache: false, addToState: true },
             );
 
             expect(fn).not.toHaveBeenCalled();

test/unit-tests/RoomNotifs-test.ts

@@ -147,7 +147,7 @@ describe("RoomNotifs test", () => {
 
             const itShouldCountPredecessorHighlightWhenThereIsAPredecessorInTheCreateEvent = (): void => {
                 it("and there is a predecessor in the create event, it should count predecessor highlight", () => {
-                    room.addLiveEvents([mkCreateEvent(OLD_ROOM_ID)]);
+                    room.addLiveEvents([mkCreateEvent(OLD_ROOM_ID)], { addToState: true });
 
                     expect(getUnreadNotificationCount(room, NotificationCountType.Total, false)).toBe(8);
                     expect(getUnreadNotificationCount(room, NotificationCountType.Highlight, false)).toBe(7);
@@ -157,7 +157,7 @@ describe("RoomNotifs test", () => {
             const itShouldCountPredecessorHighlightWhenThereIsAPredecessorEvent = (): void => {
                 it("and there is a predecessor event, it should count predecessor highlight", () => {
                     client.getVisibleRooms();
-                    room.addLiveEvents([mkCreateEvent(OLD_ROOM_ID)]);
+                    room.addLiveEvents([mkCreateEvent(OLD_ROOM_ID)], { addToState: true });
                     upsertRoomStateEvents(room, [mkPredecessorEvent(OLD_ROOM_ID)]);
 
                     expect(getUnreadNotificationCount(room, NotificationCountType.Total, false)).toBe(8);
@@ -185,7 +185,7 @@ describe("RoomNotifs test", () => {
                 itShouldCountPredecessorHighlightWhenThereIsAPredecessorEvent();
 
                 it("and there is only a predecessor event, it should not count predecessor highlight", () => {
-                    room.addLiveEvents([mkCreateEvent()]);
+                    room.addLiveEvents([mkCreateEvent()], { addToState: true });
                     upsertRoomStateEvents(room, [mkPredecessorEvent(OLD_ROOM_ID)]);
 
                     expect(getUnreadNotificationCount(room, NotificationCountType.Total, false)).toBe(2);
@@ -204,15 +204,15 @@ describe("RoomNotifs test", () => {
                 itShouldCountPredecessorHighlightWhenThereIsAPredecessorEvent();
 
                 it("and there is only a predecessor event, it should count predecessor highlight", () => {
-                    room.addLiveEvents([mkCreateEvent()]);
+                    room.addLiveEvents([mkCreateEvent()], { addToState: true });
                     upsertRoomStateEvents(room, [mkPredecessorEvent(OLD_ROOM_ID)]);
 
                     expect(getUnreadNotificationCount(room, NotificationCountType.Total, false)).toBe(8);
                     expect(getUnreadNotificationCount(room, NotificationCountType.Highlight, false)).toBe(7);
                 });
 
                 it("and there is an unknown room in the predecessor event, it should not count predecessor highlight", () => {
-                    room.addLiveEvents([mkCreateEvent()]);
+                    room.addLiveEvents([mkCreateEvent()], { addToState: true });
                     upsertRoomStateEvents(room, [mkPredecessorEvent("!unknon:example.com")]);
 
                     expect(getUnreadNotificationCount(room, NotificationCountType.Total, false)).toBe(2);

test/unit-tests/Unread-test.ts

@@ -138,7 +138,7 @@ describe("Unread", () => {
                     room: roomId,
                     content: {},
                 });
-                room.addLiveEvents([event]);
+                room.addLiveEvents([event], { addToState: true });
 
                 // Don't care about the code path of hidden events.
                 mocked(haveRendererForEvent).mockClear().mockReturnValue(true);
@@ -157,7 +157,7 @@ describe("Unread", () => {
                     content: {},
                 });
                 // Only for timeline events.
-                room.addLiveEvents([event]);
+                room.addLiveEvents([event], { addToState: true });
 
                 expect(doesRoomHaveUnreadMessages(room, false)).toBe(false);
             });
@@ -201,7 +201,7 @@ describe("Unread", () => {
                     content: {},
                 });
                 // Only for timeline events.
-                room.addLiveEvents([event2]);
+                room.addLiveEvents([event2], { addToState: true });
 
                 expect(doesRoomHaveUnreadMessages(room, false)).toBe(true);
             });
@@ -403,7 +403,7 @@ describe("Unread", () => {
             redactedEvent.makeRedacted(redactedEvent, room);
             console.log("Event Id", redactedEvent.getId());
             // Only for timeline events.
-            room.addLiveEvents([redactedEvent]);
+            room.addLiveEvents([redactedEvent], { addToState: true });
 
             expect(doesRoomHaveUnreadMessages(room, true)).toBe(true);
             expect(logger.warn).toHaveBeenCalledWith(
@@ -448,7 +448,7 @@ describe("Unread", () => {
                     room: roomId,
                     content: {},
                 });
-                room.addLiveEvents([event]);
+                room.addLiveEvents([event], { addToState: true });
             });
 
             it("an unthreaded receipt for the event makes the room read", () => {
@@ -502,7 +502,7 @@ describe("Unread", () => {
                     ts: 100,
                     currentUserId: myId,
                 });
-                room.addLiveEvents(events);
+                room.addLiveEvents(events, { addToState: true });
                 threadEvent = events[1];
             });
 
@@ -555,7 +555,7 @@ describe("Unread", () => {
                 room: roomId,
                 content: {},
             });
-            room.addLiveEvents([event]);
+            room.addLiveEvents([event], { addToState: true });
 
             // It still returns false
             expect(doesRoomHaveUnreadThreads(room)).toBe(false);

test/unit-tests/components/structures/RoomView-test.tsx

@@ -249,15 +249,19 @@ describe("RoomView", () => {
         cli.isRoomEncrypted.mockReturnValue(true);
 
         // and fake an encryption event into the room to prompt it to re-check
-        room.addLiveEvents([
-            new MatrixEvent({
-                type: "m.room.encryption",
-                sender: cli.getUserId()!,
-                content: {},
-                event_id: "someid",
-                room_id: room.roomId,
-            }),
-        ]);
+        room.addLiveEvents(
+            [
+                new MatrixEvent({
+                    type: "m.room.encryption",
+                    sender: cli.getUserId()!,
+                    content: {},
+                    event_id: "someid",
+                    room_id: room.roomId,
+                    state_key: "",
+                }),
+            ],
+            { addToState: true },
+        );
 
         // URL previews should now be disabled
         expect(roomViewInstance.state.showUrlPreview).toBe(false);
@@ -440,7 +444,7 @@ describe("RoomView", () => {
                 skey: id,
                 ts,
             });
-            room.addLiveEvents([widgetEvent]);
+            room.addLiveEvents([widgetEvent], { addToState: true });
             room.currentState.setStateEvents([widgetEvent]);
             cli.emit(RoomStateEvent.Events, widgetEvent, room.currentState, null);
             await flushPromises();

test/unit-tests/components/structures/ThreadPanel-test.tsx

@@ -209,11 +209,11 @@ describe("ThreadPanel", () => {
                 return event ? Promise.resolve(event) : Promise.reject();
             });
             const [allThreads, myThreads] = room.threadsTimelineSets;
-            allThreads!.addLiveEvent(otherThread.rootEvent);
-            allThreads!.addLiveEvent(mixedThread.rootEvent);
-            allThreads!.addLiveEvent(ownThread.rootEvent);
-            myThreads!.addLiveEvent(mixedThread.rootEvent);
-            myThreads!.addLiveEvent(ownThread.rootEvent);
+            allThreads!.addLiveEvent(otherThread.rootEvent, { addToState: true });
+            allThreads!.addLiveEvent(mixedThread.rootEvent, { addToState: true });
+            allThreads!.addLiveEvent(ownThread.rootEvent, { addToState: true });
+            myThreads!.addLiveEvent(mixedThread.rootEvent, { addToState: true });
+            myThreads!.addLiveEvent(ownThread.rootEvent, { addToState: true });
 
             let events: EventData[] = [];
             const renderResult = render(<TestThreadPanel />);
@@ -259,7 +259,7 @@ describe("ThreadPanel", () => {
                 return event ? Promise.resolve(event) : Promise.reject();
             });
             const [allThreads] = room.threadsTimelineSets;
-            allThreads!.addLiveEvent(otherThread.rootEvent);
+            allThreads!.addLiveEvent(otherThread.rootEvent, { addToState: true });
 
             let events: EventData[] = [];
             const renderResult = render(<TestThreadPanel />);

test/unit-tests/components/structures/TimelinePanel-test.tsx

@@ -66,7 +66,7 @@ const mkTimeline = (room: Room, events: MatrixEvent[]): [EventTimeline, EventTim
         getPendingEvents: () => [] as MatrixEvent[],
     } as unknown as EventTimelineSet;
     const timeline = new EventTimeline(timelineSet);
-    events.forEach((event) => timeline.addEvent(event, { toStartOfTimeline: false }));
+    events.forEach((event) => timeline.addEvent(event, { toStartOfTimeline: false, addToState: true }));
 
     return [timeline, timelineSet];
 };
@@ -150,9 +150,11 @@ const setupPagination = (
     mocked(client).paginateEventTimeline.mockImplementation(async (tl, { backwards }) => {
         if (tl === timeline) {
             if (backwards) {
-                forEachRight(previousPage ?? [], (event) => tl.addEvent(event, { toStartOfTimeline: true }));
+                forEachRight(previousPage ?? [], (event) =>
+                    tl.addEvent(event, { toStartOfTimeline: true, addToState: true }),
+                );
             } else {
-                (nextPage ?? []).forEach((event) => tl.addEvent(event, { toStartOfTimeline: false }));
+                (nextPage ?? []).forEach((event) => tl.addEvent(event, { toStartOfTimeline: false, addToState: true }));
             }
             // Prevent any further pagination attempts in this direction
             tl.setPaginationToken(null, backwards ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS);
@@ -256,7 +258,7 @@ describe("TimelinePanel", () => {
             describe("and reading the timeline", () => {
                 beforeEach(async () => {
                     await renderTimelinePanel();
-                    timelineSet.addLiveEvent(ev1, {});
+                    timelineSet.addLiveEvent(ev1, { addToState: true });
                     await flushPromises();
 
                     // @ts-ignore
@@ -285,11 +287,11 @@ describe("TimelinePanel", () => {
                     });
 
                     it("and forgetting the read markers, should send the stored marker again", async () => {
-                        timelineSet.addLiveEvent(ev2, {});
+                        timelineSet.addLiveEvent(ev2, { addToState: true });
                         // Add the event to the room as well as the timeline, so we can find it when we
                         // call findEventById in getEventReadUpTo. This is odd because in our test
                         // setup, timelineSet is not actually the timelineSet of the room.
-                        await room.addLiveEvents([ev2], {});
+                        await room.addLiveEvents([ev2], { addToState: true });
                         room.addEphemeralEvents([newReceipt(ev2.getId()!, userId, 222, 200)]);
                         await timelinePanel.forgetReadMarker();
                         expect(client.setRoomReadMarkers).toHaveBeenCalledWith(roomId, ev2.getId());
@@ -315,7 +317,7 @@ describe("TimelinePanel", () => {
 
                 it("should send a fully read marker and a private receipt", async () => {
                     await renderTimelinePanel();
-                    timelineSet.addLiveEvent(ev1, {});
+                    timelineSet.addLiveEvent(ev1, { addToState: true });
                     await flushPromises();
 
                     // @ts-ignore
@@ -361,7 +363,7 @@ describe("TimelinePanel", () => {
 
             it("should send receipts but no fully_read when reading the thread timeline", async () => {
                 await renderTimelinePanel();
-                timelineSet.addLiveEvent(threadEv1, {});
+                timelineSet.addLiveEvent(threadEv1, { addToState: true });
                 await flushPromises();
 
                 // @ts-ignore
@@ -871,7 +873,9 @@ describe("TimelinePanel", () => {
             // @ts-ignore
             thread.fetchEditsWhereNeeded = () => Promise.resolve();
             await thread.addEvent(reply1, false, true);
-            await allThreads.getLiveTimeline().addEvent(thread.rootEvent!, { toStartOfTimeline: true });
+            await allThreads
+                .getLiveTimeline()
+                .addEvent(thread.rootEvent!, { toStartOfTimeline: true, addToState: true });
             const replyToEvent = jest.spyOn(thread, "replyToEvent", "get");
 
             const dom = render(
@@ -907,7 +911,9 @@ describe("TimelinePanel", () => {
             // @ts-ignore
             realThread.fetchEditsWhereNeeded = () => Promise.resolve();
             await realThread.addEvent(reply1, true);
-            await allThreads.getLiveTimeline().addEvent(realThread.rootEvent!, { toStartOfTimeline: true });
+            await allThreads
+                .getLiveTimeline()
+                .addEvent(realThread.rootEvent!, { toStartOfTimeline: true, addToState: true });
             const replyToEvent = jest.spyOn(realThread, "replyToEvent", "get");
 
             // @ts-ignore
@@ -968,7 +974,9 @@ describe("TimelinePanel", () => {
 
         events.push(rootEvent);
 
-        events.forEach((event) => timelineSet.getLiveTimeline().addEvent(event, { toStartOfTimeline: true }));
+        events.forEach((event) =>
+            timelineSet.getLiveTimeline().addEvent(event, { toStartOfTimeline: true, addToState: true }),
+        );
 
         const roomMembership = mkMembership({
             mship: KnownMembership.Join,
@@ -988,7 +996,10 @@ describe("TimelinePanel", () => {
         jest.spyOn(roomState, "getMember").mockReturnValue(member);
 
         jest.spyOn(timelineSet.getLiveTimeline(), "getState").mockReturnValue(roomState);
-        timelineSet.addEventToTimeline(roomMembership, timelineSet.getLiveTimeline(), { toStartOfTimeline: false });
+        timelineSet.addEventToTimeline(roomMembership, timelineSet.getLiveTimeline(), {
+            toStartOfTimeline: false,
+            addToState: true,
+        });
 
         for (const event of events) {
             jest.spyOn(event, "isDecryptionFailure").mockReturnValue(true);