Switch back to the viewer when clicking a recording URI (#9064)

### Related

- Follow-up to #9018

### What

So far, clicking on a recording URI in the redap browser would silently
load the recording in the background. With this PR, the UI switches back
to viewer mode whenever a new recording is loaded, unless the user
cmd/ctrl- or middle-clicked the link, in which case the UI remains in
redap browser mode (mimicking the load tab in the background behaviour
of browser).

This involved a number of changes:
- `RecordingUri` is now removed, because the default `arrow_ui` handling
of links is sufficient.
- `rerun://` links are globally handled by the viewer, taking into
account the same-tab/new-tab behaviour in egui `OpenUrl` event.
- `ui.re_hyperlink` can now be specified is the new-tab behaviour is
forced or not. It is the case for our documentation link, but not for
generic urls (e.g. from `arrow_ui()`
- Some cleanup around `redap::Scheme` happened.

Author: abey79

Cargo.lock

@@ -5910,10 +5910,8 @@ dependencies = [
  "egui_plot",
  "itertools 0.13.0",
  "nohash-hasher",
- "re_data_source",
  "re_data_ui",
  "re_format",
- "re_log",
  "re_log_types",
  "re_tracing",
  "re_types",
@@ -6447,7 +6445,6 @@ dependencies = [
  "re_log_types",
  "re_protos",
  "re_sorbet",
- "re_types",
  "re_types_core",
  "re_ui",
  "re_view_dataframe",
@@ -7220,6 +7217,7 @@ dependencies = [
  "re_data_source",
  "re_entity_db",
  "re_format",
+ "re_grpc_client",
  "re_log",
  "re_log_types",
  "re_math",

crates/store/re_data_source/src/data_source.rs

@@ -4,6 +4,7 @@ use re_smart_channel::{Receiver, SmartChannelSource, SmartMessageSource};
 
 #[cfg(not(target_arch = "wasm32"))]
 use anyhow::Context as _;
+use re_grpc_client::redap;
 
 /// Somewhere we can get Rerun data from.
 #[derive(Debug, Clone)]
@@ -49,63 +50,67 @@ impl DataSource {
     ///
     /// Tries to figure out if it looks like a local path,
     /// a web-socket address, or a http url.
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn from_uri(file_source: re_log_types::FileSource, mut uri: String) -> Self {
-        use itertools::Itertools as _;
+    #[cfg_attr(target_arch = "wasm32", expect(clippy::needless_pass_by_value))]
+    pub fn from_uri(_file_source: re_log_types::FileSource, mut uri: String) -> Self {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            use itertools::Itertools as _;
 
-        fn looks_like_windows_abs_path(path: &str) -> bool {
-            let path = path.as_bytes();
-            // "C:/" etc
-            path.get(1).copied() == Some(b':') && path.get(2).copied() == Some(b'/')
-        }
+            fn looks_like_windows_abs_path(path: &str) -> bool {
+                let path = path.as_bytes();
+                // "C:/" etc
+                path.get(1).copied() == Some(b':') && path.get(2).copied() == Some(b'/')
+            }
 
-        fn looks_like_a_file_path(uri: &str) -> bool {
-            // How do we distinguish a file path from a web url? "example.zip" could be either.
+            fn looks_like_a_file_path(uri: &str) -> bool {
+                // How do we distinguish a file path from a web url? "example.zip" could be either.
 
-            if uri.starts_with('/') {
-                return true; // Unix absolute path
-            }
-            if looks_like_windows_abs_path(uri) {
-                return true;
+                if uri.starts_with('/') {
+                    return true; // Unix absolute path
+                }
+                if looks_like_windows_abs_path(uri) {
+                    return true;
+                }
+
+                // We use a simple heuristic here: if there are multiple dots, it is likely an url,
+                // like "example.com/foo.zip".
+                // If there is only one dot, we treat it as an extension and look it up in a list of common
+                // file extensions:
+
+                let parts = uri.split('.').collect_vec();
+                if parts.len() <= 1 {
+                    true // No dots. Weird. Let's assume it is a file path.
+                } else if parts.len() == 2 {
+                    // Extension or `.com` etc?
+                    re_data_loader::is_supported_file_extension(parts[1])
+                } else {
+                    false // Too many dots; assume an url
+                }
             }
 
-            // We use a simple heuristic here: if there are multiple dots, it is likely an url,
-            // like "example.com/foo.zip".
-            // If there is only one dot, we treat it as an extension and look it up in a list of common
-            // file extensions:
-
-            let parts = uri.split('.').collect_vec();
-            if parts.len() <= 1 {
-                true // No dots. Weird. Let's assume it is a file path.
-            } else if parts.len() == 2 {
-                // Extension or `.com` etc?
-                re_data_loader::is_supported_file_extension(parts[1])
-            } else {
-                false // Too many dots; assume an url
+            // Reading from standard input in non-TTY environments (e.g. GitHub Actions, but I'm sure we can
+            // come up with more convoluted than that…) can lead to many unexpected,
+            // platform-specific problems that aren't even necessarily consistent across runs.
+            //
+            // In order to avoid having to swallow errors based on unreliable heuristics (or inversely:
+            // throwing errors when we shouldn't), we just make reading from standard input explicit.
+            if uri == "-" {
+                return Self::Stdin;
             }
-        }
 
-        // Reading from standard input in non-TTY environments (e.g. GitHub Actions, but I'm sure we can
-        // come up with more convoluted than that…) can lead to many unexpected,
-        // platform-specific problems that aren't even necessarily consistent across runs.
-        //
-        // In order to avoid having to swallow errors based on unreliable heuristics (or inversely:
-        // throwing errors when we shouldn't), we just make reading from standard input explicit.
-        if uri == "-" {
-            return Self::Stdin;
-        }
+            let path = std::path::Path::new(&uri).to_path_buf();
 
-        let path = std::path::Path::new(&uri).to_path_buf();
+            if uri.starts_with("file://") || path.exists() {
+                return Self::FilePath(_file_source, path);
+            }
 
-        if uri.starts_with("rerun://")
-            || uri.starts_with("rerun+http://")
-            || uri.starts_with("rerun+https://")
-        {
-            return Self::RerunGrpcUrl { url: uri };
+            if looks_like_a_file_path(&uri) {
+                return Self::FilePath(_file_source, path);
+            }
         }
 
-        if uri.starts_with("file://") || path.exists() {
-            Self::FilePath(file_source, path)
+        if redap::Scheme::try_from(uri.as_ref()).is_ok() {
+            Self::RerunGrpcUrl { url: uri }
         } else if (uri.starts_with("http://") || uri.starts_with("https://"))
             && (uri.ends_with(".rrd") || uri.ends_with(".rbl"))
         {
@@ -115,8 +120,6 @@ impl DataSource {
             }
         } else if uri.starts_with("http://") || uri.starts_with("https://") {
             Self::MessageProxy { url: uri }
-        } else if looks_like_a_file_path(&uri) {
-            Self::FilePath(file_source, path)
         } else if uri.ends_with(".rrd") || uri.ends_with(".rbl") {
             Self::RrdHttpUrl {
                 url: uri,

crates/store/re_grpc_client/src/redap/address.rs

@@ -20,8 +20,8 @@ pub enum ConnectionError {
     #[error("server is expecting an unencrypted connection (try `rerun+http://` if you are sure)")]
     UnencryptedServer,
 
-    #[error("invalid or missing scheme (expected `rerun(+http|+https)://`)")]
-    InvalidScheme,
+    #[error(transparent)]
+    InvalidScheme(#[from] InvalidScheme),
 
     #[error("unexpected endpoint: {0}")]
     UnexpectedEndpoint(String),
@@ -36,6 +36,10 @@ pub enum ConnectionError {
     CannotLoadUrlAsRecording { url: String },
 }
 
+#[derive(thiserror::Error, Debug)]
+#[error("invalid or missing scheme (expected `rerun(+http|+https)://`)")]
+pub struct InvalidScheme;
+
 /// The different schemes supported by Rerun.
 ///
 /// We support `rerun`, `rerun+http`, and `rerun+https`.
@@ -64,6 +68,40 @@ impl Scheme {
             Self::RerunHttp => "http",
         }
     }
+
+    /// Converts a rerun url into a canonical http or https url.
+    fn canonical_url(&self, url: &str) -> String {
+        match self {
+            Self::Rerun => {
+                debug_assert!(url.starts_with("rerun://"));
+                url.replace("rerun://", "https://")
+            }
+            Self::RerunHttp => {
+                debug_assert!(url.starts_with("rerun+http://"));
+                url.replace("rerun+http://", "http://")
+            }
+            Self::RerunHttps => {
+                debug_assert!(url.starts_with("rerun+https://"));
+                url.replace("rerun+https://", "https://")
+            }
+        }
+    }
+}
+
+impl TryFrom<&str> for Scheme {
+    type Error = InvalidScheme;
+
+    fn try_from(url: &str) -> Result<Self, Self::Error> {
+        if url.starts_with("rerun://") {
+            Ok(Self::Rerun)
+        } else if url.starts_with("rerun+http://") {
+            Ok(Self::RerunHttp)
+        } else if url.starts_with("rerun+https://") {
+            Ok(Self::RerunHttps)
+        } else {
+            Err(InvalidScheme)
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
@@ -139,18 +177,8 @@ impl Origin {
 /// Parses a URL and returns the [`Origin`] and the canonical URL (i.e. one that
 ///  starts with `http://` or `https://`).
 fn replace_and_parse(value: &str) -> Result<(Origin, url::Url), ConnectionError> {
-    let (scheme, rewritten) = if value.starts_with("rerun://") {
-        Ok((Scheme::Rerun, value.replace("rerun://", "https://")))
-    } else if value.starts_with("rerun+http://") {
-        Ok((Scheme::RerunHttp, value.replace("rerun+http://", "http://")))
-    } else if value.starts_with("rerun+https://") {
-        Ok((
-            Scheme::RerunHttps,
-            value.replace("rerun+https://", "https://"),
-        ))
-    } else {
-        Err(ConnectionError::InvalidScheme)
-    }?;
+    let scheme = Scheme::try_from(value)?;
+    let rewritten = scheme.canonical_url(value);
 
     // We have to first rewrite the endpoint, because `Url` does not allow
     // `.set_scheme()` for non-opaque origins, nor does it return a proper

crates/store/re_grpc_client/src/redap/mod.rs

@@ -19,7 +19,7 @@ use re_protos::{
 
 mod address;
 
-pub use address::{ConnectionError, Origin, RedapAddress};
+pub use address::{ConnectionError, InvalidScheme, Origin, RedapAddress, Scheme};
 
 use crate::spawn_future;
 use crate::StreamError;