logiguard fork v3: full patch set on verified 8c74db0 tree

Includes prior-session patches (carry forward so the app compiles):
  - crates/gpui/build.rs: cross-compile manifest fix
  - crates/gpui/src/platform.rs: PlatformWindow::activate_with_token trait method
  - crates/gpui/src/window.rs: Window::activate_with_token public API
  - crates/gpui_linux/src/linux/wayland/window.rs: WaylandWindow::activate_with_token + activate() keyboard-serial fix

Plus the focus-serial fix:
  - serial.rs: SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; latest_serial_of()

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/channel/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "channel"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/channel.rs"
+doctest = false
+
+[features]
+test-support = ["collections/test-support", "gpui/test-support", "rpc/test-support"]
+
+[dependencies]
+anyhow.workspace = true
+client.workspace = true
+clock.workspace = true
+collections.workspace = true
+futures.workspace = true
+gpui.workspace = true
+language.workspace = true
+log.workspace = true
+postage.workspace = true
+release_channel.workspace = true
+rpc.workspace = true
+settings.workspace = true
+text.workspace = true
+time.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+collections = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }
+rpc = { workspace = true, features = ["test-support"] }
+client = { workspace = true, features = ["test-support"] }
+semver.workspace = true
+settings = { workspace = true, features = ["test-support"] }
+util = { workspace = true, features = ["test-support"] }
+http_client = { workspace = true, features = ["test-support"] }

crates/channel/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/channel/src/channel.rs

@@ -0,0 +1,17 @@
+mod channel_buffer;
+mod channel_store;
+
+use client::{Client, UserStore};
+use gpui::{App, Entity};
+use std::sync::Arc;
+
+pub use channel_buffer::{ACKNOWLEDGE_DEBOUNCE_INTERVAL, ChannelBuffer, ChannelBufferEvent};
+pub use channel_store::{Channel, ChannelEvent, ChannelMembership, ChannelStore};
+
+#[cfg(test)]
+mod channel_store_tests;
+
+pub fn init(client: &Arc<Client>, user_store: Entity<UserStore>, cx: &mut App) {
+    channel_store::init(client, user_store, cx);
+    channel_buffer::init(&client.clone().into());
+}

crates/channel/src/channel_buffer.rs

@@ -0,0 +1,295 @@
+use crate::{Channel, ChannelStore};
+use anyhow::Result;
+use client::{ChannelId, Client, Collaborator, UserStore, ZED_ALWAYS_ACTIVE};
+use collections::HashMap;
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task};
+use language::proto::serialize_version;
+use rpc::{
+    AnyProtoClient, TypedEnvelope,
+    proto::{self, PeerId},
+};
+use std::{sync::Arc, time::Duration};
+use text::{BufferId, ReplicaId};
+use util::ResultExt;
+
+pub const ACKNOWLEDGE_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(250);
+
+pub(crate) fn init(client: &AnyProtoClient) {
+    client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer);
+    client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators);
+}
+
+pub struct ChannelBuffer {
+    pub channel_id: ChannelId,
+    connected: bool,
+    rejoining: bool,
+    collaborators: HashMap<PeerId, Collaborator>,
+    user_store: Entity<UserStore>,
+    channel_store: Entity<ChannelStore>,
+    buffer: Entity<language::Buffer>,
+    buffer_epoch: u64,
+    client: Arc<Client>,
+    subscription: Option<client::Subscription>,
+    acknowledge_task: Option<Task<Result<()>>>,
+}
+
+pub enum ChannelBufferEvent {
+    CollaboratorsChanged,
+    Disconnected,
+    Connected,
+    BufferEdited,
+    ChannelChanged,
+}
+
+impl EventEmitter<ChannelBufferEvent> for ChannelBuffer {}
+
+impl ChannelBuffer {
+    pub(crate) async fn new(
+        channel: Arc<Channel>,
+        client: Arc<Client>,
+        user_store: Entity<UserStore>,
+        channel_store: Entity<ChannelStore>,
+        cx: &mut AsyncApp,
+    ) -> Result<Entity<Self>> {
+        let response = client
+            .request(proto::JoinChannelBuffer {
+                channel_id: channel.id.0,
+            })
+            .await?;
+        let buffer_id = BufferId::new(response.buffer_id)?;
+        let base_text = response.base_text;
+        let operations = response
+            .operations
+            .into_iter()
+            .map(language::proto::deserialize_operation)
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let buffer = cx.new(|cx| {
+            let capability = channel_store.read(cx).channel_capability(channel.id);
+            language::Buffer::remote(
+                buffer_id,
+                ReplicaId::new(response.replica_id as u16),
+                capability,
+                base_text,
+            )
+        });
+        buffer.update(cx, |buffer, cx| buffer.apply_ops(operations, cx));
+
+        let subscription = client.subscribe_to_entity(channel.id.0)?;
+
+        anyhow::Ok(cx.new(|cx| {
+            cx.subscribe(&buffer, Self::on_buffer_update).detach();
+            cx.on_release(Self::release).detach();
+            let mut this = Self {
+                buffer,
+                buffer_epoch: response.epoch,
+                client,
+                connected: true,
+                rejoining: false,
+                collaborators: Default::default(),
+                acknowledge_task: None,
+                channel_id: channel.id,
+                subscription: Some(subscription.set_entity(&cx.entity(), &cx.to_async())),
+                user_store,
+                channel_store,
+            };
+            this.replace_collaborators(response.collaborators, cx);
+            this
+        }))
+    }
+
+    fn release(&mut self, _: &mut App) {
+        if self.connected {
+            if let Some(task) = self.acknowledge_task.take() {
+                task.detach();
+            }
+            self.client
+                .send(proto::LeaveChannelBuffer {
+                    channel_id: self.channel_id.0,
+                })
+                .log_err();
+        }
+    }
+
+    pub fn connected(&mut self, cx: &mut Context<Self>) {
+        self.connected = true;
+        self.rejoining = false;
+        if self.subscription.is_none() {
+            let Ok(subscription) = self.client.subscribe_to_entity(self.channel_id.0) else {
+                return;
+            };
+            self.subscription = Some(subscription.set_entity(&cx.entity(), &cx.to_async()));
+            cx.emit(ChannelBufferEvent::Connected);
+        }
+    }
+
+    pub(crate) fn set_rejoining(&mut self, rejoining: bool) {
+        self.rejoining = rejoining;
+    }
+
+    pub fn remote_id(&self, cx: &App) -> BufferId {
+        self.buffer.read(cx).remote_id()
+    }
+
+    pub fn user_store(&self) -> &Entity<UserStore> {
+        &self.user_store
+    }
+
+    pub(crate) fn replace_collaborators(
+        &mut self,
+        collaborators: Vec<proto::Collaborator>,
+        cx: &mut Context<Self>,
+    ) {
+        let mut new_collaborators = HashMap::default();
+        for collaborator in collaborators {
+            if let Ok(collaborator) = Collaborator::from_proto(collaborator) {
+                new_collaborators.insert(collaborator.peer_id, collaborator);
+            }
+        }
+
+        for old_collaborator in self.collaborators.values() {
+            if !new_collaborators.contains_key(&old_collaborator.peer_id) {
+                self.buffer.update(cx, |buffer, cx| {
+                    buffer.remove_peer(old_collaborator.replica_id, cx)
+                });
+            }
+        }
+        self.collaborators = new_collaborators;
+        cx.emit(ChannelBufferEvent::CollaboratorsChanged);
+        cx.notify();
+    }
+
+    async fn handle_update_channel_buffer(
+        this: Entity<Self>,
+        update_channel_buffer: TypedEnvelope<proto::UpdateChannelBuffer>,
+        mut cx: AsyncApp,
+    ) -> Result<()> {
+        let ops = update_channel_buffer
+            .payload
+            .operations
+            .into_iter()
+            .map(language::proto::deserialize_operation)
+            .collect::<Result<Vec<_>, _>>()?;
+
+        this.update(&mut cx, |this, cx| {
+            cx.notify();
+            this.buffer
+                .update(cx, |buffer, cx| buffer.apply_ops(ops, cx))
+        });
+
+        Ok(())
+    }
+
+    async fn handle_update_channel_buffer_collaborators(
+        this: Entity<Self>,
+        message: TypedEnvelope<proto::UpdateChannelBufferCollaborators>,
+        mut cx: AsyncApp,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, cx| {
+            this.replace_collaborators(message.payload.collaborators, cx);
+            cx.emit(ChannelBufferEvent::CollaboratorsChanged);
+            cx.notify();
+        });
+        Ok(())
+    }
+
+    fn on_buffer_update(
+        &mut self,
+        _: Entity<language::Buffer>,
+        event: &language::BufferEvent,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            language::BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => {
+                if *ZED_ALWAYS_ACTIVE
+                    && let language::Operation::UpdateSelections { selections, .. } = operation
+                    && selections.is_empty()
+                {
+                    return;
+                }
+                let operation = language::proto::serialize_operation(operation);
+                if self.rejoining {
+                    return;
+                }
+                self.client
+                    .send(proto::UpdateChannelBuffer {
+                        channel_id: self.channel_id.0,
+                        operations: vec![operation],
+                    })
+                    .log_err();
+            }
+            language::BufferEvent::Edited { .. } => {
+                cx.emit(ChannelBufferEvent::BufferEdited);
+            }
+            _ => {}
+        }
+    }
+
+    pub fn acknowledge_buffer_version(&mut self, cx: &mut Context<ChannelBuffer>) {
+        let buffer = self.buffer.read(cx);
+        let version = buffer.version();
+        let buffer_id = buffer.remote_id().into();
+        let client = self.client.clone();
+        let epoch = self.epoch();
+
+        self.acknowledge_task = Some(cx.spawn(async move |_, cx| {
+            cx.background_executor()
+                .timer(ACKNOWLEDGE_DEBOUNCE_INTERVAL)
+                .await;
+            client
+                .send(proto::AckBufferOperation {
+                    buffer_id,
+                    epoch,
+                    version: serialize_version(&version),
+                })
+                .ok();
+            Ok(())
+        }));
+    }
+
+    pub fn epoch(&self) -> u64 {
+        self.buffer_epoch
+    }
+
+    pub fn buffer(&self) -> Entity<language::Buffer> {
+        self.buffer.clone()
+    }
+
+    pub fn collaborators(&self) -> &HashMap<PeerId, Collaborator> {
+        &self.collaborators
+    }
+
+    pub fn channel(&self, cx: &App) -> Option<Arc<Channel>> {
+        self.channel_store
+            .read(cx)
+            .channel_for_id(self.channel_id)
+            .cloned()
+    }
+
+    pub(crate) fn disconnect(&mut self, cx: &mut Context<Self>) {
+        log::info!("channel buffer {} disconnected", self.channel_id);
+        if self.connected {
+            self.connected = false;
+            self.rejoining = false;
+            self.subscription.take();
+            cx.emit(ChannelBufferEvent::Disconnected);
+            cx.notify()
+        }
+    }
+
+    pub(crate) fn channel_changed(&mut self, cx: &mut Context<Self>) {
+        cx.emit(ChannelBufferEvent::ChannelChanged);
+        cx.notify()
+    }
+
+    pub fn is_connected(&self) -> bool {
+        self.connected
+    }
+
+    pub fn replica_id(&self, cx: &App) -> ReplicaId {
+        self.buffer.read(cx).replica_id()
+    }
+}

crates/channel/src/channel_store/channel_index.rs

@@ -0,0 +1,120 @@
+use crate::Channel;
+use client::ChannelId;
+use collections::BTreeMap;
+use rpc::proto;
+use std::sync::Arc;
+
+#[derive(Default, Debug)]
+pub struct ChannelIndex {
+    channels_ordered: Vec<ChannelId>,
+    channels_by_id: BTreeMap<ChannelId, Arc<Channel>>,
+}
+
+impl ChannelIndex {
+    pub fn by_id(&self) -> &BTreeMap<ChannelId, Arc<Channel>> {
+        &self.channels_by_id
+    }
+
+    pub fn ordered_channels(&self) -> &[ChannelId] {
+        &self.channels_ordered
+    }
+
+    pub fn clear(&mut self) {
+        self.channels_ordered.clear();
+        self.channels_by_id.clear();
+    }
+
+    /// Delete the given channels from this index.
+    pub fn delete_channels(&mut self, channels: &[ChannelId]) {
+        self.channels_by_id
+            .retain(|channel_id, _| !channels.contains(channel_id));
+        self.channels_ordered
+            .retain(|channel_id| !channels.contains(channel_id));
+    }
+
+    pub fn bulk_insert(&mut self) -> ChannelPathsInsertGuard<'_> {
+        ChannelPathsInsertGuard {
+            channels_ordered: &mut self.channels_ordered,
+            channels_by_id: &mut self.channels_by_id,
+        }
+    }
+}
+
+/// A guard for ensuring that the paths index maintains its sort and uniqueness
+/// invariants after a series of insertions
+#[derive(Debug)]
+pub struct ChannelPathsInsertGuard<'a> {
+    channels_ordered: &'a mut Vec<ChannelId>,
+    channels_by_id: &'a mut BTreeMap<ChannelId, Arc<Channel>>,
+}
+
+impl ChannelPathsInsertGuard<'_> {
+    pub fn insert(&mut self, channel_proto: proto::Channel) -> bool {
+        let mut ret = false;
+        let parent_path = channel_proto
+            .parent_path
+            .iter()
+            .map(|cid| ChannelId(*cid))
+            .collect();
+        if let Some(existing_channel) = self.channels_by_id.get_mut(&ChannelId(channel_proto.id)) {
+            let existing_channel = Arc::make_mut(existing_channel);
+
+            ret = existing_channel.visibility != channel_proto.visibility()
+                || existing_channel.name != channel_proto.name
+                || existing_channel.parent_path != parent_path
+                || existing_channel.channel_order != channel_proto.channel_order;
+
+            existing_channel.visibility = channel_proto.visibility();
+            existing_channel.name = channel_proto.name.into();
+            existing_channel.parent_path = parent_path;
+            existing_channel.channel_order = channel_proto.channel_order;
+        } else {
+            self.channels_by_id.insert(
+                ChannelId(channel_proto.id),
+                Arc::new(Channel {
+                    id: ChannelId(channel_proto.id),
+                    visibility: channel_proto.visibility(),
+                    name: channel_proto.name.into(),
+                    parent_path,
+                    channel_order: channel_proto.channel_order,
+                }),
+            );
+            self.insert_root(ChannelId(channel_proto.id));
+        }
+        ret
+    }
+
+    fn insert_root(&mut self, channel_id: ChannelId) {
+        self.channels_ordered.push(channel_id);
+    }
+}
+
+impl Drop for ChannelPathsInsertGuard<'_> {
+    fn drop(&mut self) {
+        self.channels_ordered.sort_by(|a, b| {
+            let a = channel_path_sorting_key(*a, self.channels_by_id);
+            let b = channel_path_sorting_key(*b, self.channels_by_id);
+            a.cmp(b)
+        });
+        self.channels_ordered.dedup();
+    }
+}
+
+fn channel_path_sorting_key(
+    id: ChannelId,
+    channels_by_id: &BTreeMap<ChannelId, Arc<Channel>>,
+) -> impl Iterator<Item = (i32, ChannelId)> {
+    let (parent_path, order_and_id) =
+        channels_by_id
+            .get(&id)
+            .map_or((&[] as &[_], None), |channel| {
+                (
+                    channel.parent_path.as_slice(),
+                    Some((channel.channel_order, channel.id)),
+                )
+            });
+    parent_path
+        .iter()
+        .filter_map(|id| Some((channels_by_id.get(id)?.channel_order, *id)))
+        .chain(order_and_id)
+}

crates/channel/src/channel_store_tests.rs

@@ -0,0 +1,274 @@
+use super::*;
+use client::{Client, UserStore};
+use clock::FakeSystemClock;
+use gpui::{App, AppContext as _, Entity};
+use http_client::FakeHttpClient;
+use rpc::proto::{self};
+use settings::SettingsStore;
+
+#[gpui::test]
+fn test_update_channels(cx: &mut App) {
+    let channel_store = init_test(cx);
+
+    update_channels(
+        &channel_store,
+        proto::UpdateChannels {
+            channels: vec![
+                proto::Channel {
+                    id: 1,
+                    name: "b".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: Vec::new(),
+                    channel_order: 1,
+                },
+                proto::Channel {
+                    id: 2,
+                    name: "a".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: Vec::new(),
+                    channel_order: 2,
+                },
+            ],
+            ..Default::default()
+        },
+        cx,
+    );
+    assert_channels(
+        &channel_store,
+        &[
+            //
+            (0, "b".to_string()),
+            (0, "a".to_string()),
+        ],
+        cx,
+    );
+
+    update_channels(
+        &channel_store,
+        proto::UpdateChannels {
+            channels: vec![
+                proto::Channel {
+                    id: 3,
+                    name: "x".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: vec![1],
+                    channel_order: 1,
+                },
+                proto::Channel {
+                    id: 4,
+                    name: "y".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: vec![2],
+                    channel_order: 1,
+                },
+            ],
+            ..Default::default()
+        },
+        cx,
+    );
+    assert_channels(
+        &channel_store,
+        &[
+            (0, "b".to_string()),
+            (1, "x".to_string()),
+            (0, "a".to_string()),
+            (1, "y".to_string()),
+        ],
+        cx,
+    );
+}
+
+#[gpui::test]
+fn test_update_channels_order_independent(cx: &mut App) {
+    /// Based on: https://stackoverflow.com/a/59939809
+    fn unique_permutations<T: Clone>(items: Vec<T>) -> Vec<Vec<T>> {
+        if items.len() == 1 {
+            vec![items]
+        } else {
+            let mut output: Vec<Vec<T>> = vec![];
+
+            for (ix, first) in items.iter().enumerate() {
+                let mut remaining_elements = items.clone();
+                remaining_elements.remove(ix);
+                for mut permutation in unique_permutations(remaining_elements) {
+                    permutation.insert(0, first.clone());
+                    output.push(permutation);
+                }
+            }
+            output
+        }
+    }
+
+    let test_data = vec![
+        proto::Channel {
+            id: 6,
+            name: "β".to_string(),
+            visibility: proto::ChannelVisibility::Members as i32,
+            parent_path: vec![1, 3],
+            channel_order: 1,
+        },
+        proto::Channel {
+            id: 5,
+            name: "α".to_string(),
+            visibility: proto::ChannelVisibility::Members as i32,
+            parent_path: vec![1],
+            channel_order: 2,
+        },
+        proto::Channel {
+            id: 3,
+            name: "x".to_string(),
+            visibility: proto::ChannelVisibility::Members as i32,
+            parent_path: vec![1],
+            channel_order: 1,
+        },
+        proto::Channel {
+            id: 4,
+            name: "y".to_string(),
+            visibility: proto::ChannelVisibility::Members as i32,
+            parent_path: vec![2],
+            channel_order: 1,
+        },
+        proto::Channel {
+            id: 1,
+            name: "b".to_string(),
+            visibility: proto::ChannelVisibility::Members as i32,
+            parent_path: Vec::new(),
+            channel_order: 1,
+        },
+        proto::Channel {
+            id: 2,
+            name: "a".to_string(),
+            visibility: proto::ChannelVisibility::Members as i32,
+            parent_path: Vec::new(),
+            channel_order: 2,
+        },
+    ];
+
+    let channel_store = init_test(cx);
+    let permutations = unique_permutations(test_data);
+
+    for test_instance in permutations {
+        channel_store.update(cx, |channel_store, _| channel_store.reset());
+
+        update_channels(
+            &channel_store,
+            proto::UpdateChannels {
+                channels: test_instance,
+                ..Default::default()
+            },
+            cx,
+        );
+
+        assert_channels(
+            &channel_store,
+            &[
+                (0, "b".to_string()),
+                (1, "x".to_string()),
+                (2, "β".to_string()),
+                (1, "α".to_string()),
+                (0, "a".to_string()),
+                (1, "y".to_string()),
+            ],
+            cx,
+        );
+    }
+}
+
+#[gpui::test]
+fn test_dangling_channel_paths(cx: &mut App) {
+    let channel_store = init_test(cx);
+
+    update_channels(
+        &channel_store,
+        proto::UpdateChannels {
+            channels: vec![
+                proto::Channel {
+                    id: 0,
+                    name: "a".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: vec![],
+                    channel_order: 1,
+                },
+                proto::Channel {
+                    id: 1,
+                    name: "b".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: vec![0],
+                    channel_order: 1,
+                },
+                proto::Channel {
+                    id: 2,
+                    name: "c".to_string(),
+                    visibility: proto::ChannelVisibility::Members as i32,
+                    parent_path: vec![0, 1],
+                    channel_order: 1,
+                },
+            ],
+            ..Default::default()
+        },
+        cx,
+    );
+    // Sanity check
+    assert_channels(
+        &channel_store,
+        &[
+            //
+            (0, "a".to_string()),
+            (1, "b".to_string()),
+            (2, "c".to_string()),
+        ],
+        cx,
+    );
+
+    update_channels(
+        &channel_store,
+        proto::UpdateChannels {
+            delete_channels: vec![1, 2],
+            ..Default::default()
+        },
+        cx,
+    );
+
+    // Make sure that the 1/2/3 path is gone
+    assert_channels(&channel_store, &[(0, "a".to_string())], cx);
+}
+
+fn init_test(cx: &mut App) -> Entity<ChannelStore> {
+    let settings_store = SettingsStore::test(cx);
+    cx.set_global(settings_store);
+    release_channel::init(semver::Version::new(0, 0, 0), cx);
+
+    let clock = Arc::new(FakeSystemClock::new());
+    let http = FakeHttpClient::with_404_response();
+    let client = Client::new(clock, http, cx);
+    let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
+
+    client::init(&client, cx);
+    crate::init(&client, user_store, cx);
+
+    ChannelStore::global(cx)
+}
+
+fn update_channels(
+    channel_store: &Entity<ChannelStore>,
+    message: proto::UpdateChannels,
+    cx: &mut App,
+) {
+    let task = channel_store.update(cx, |store, cx| store.update_channels(message, cx));
+    assert!(task.is_none());
+}
+
+#[track_caller]
+fn assert_channels(
+    channel_store: &Entity<ChannelStore>,
+    expected_channels: &[(usize, String)],
+    cx: &mut App,
+) {
+    let actual = channel_store.update(cx, |store, _| {
+        store
+            .ordered_channels()
+            .map(|(depth, channel)| (depth, channel.name.to_string()))
+            .collect::<Vec<_>>()
+    });
+    assert_eq!(actual, expected_channels);
+}