Blazor API Review: IUriHelper (#12425)

* Rename IUriHelper -> NavigationManager

- Remove IUriHelper interface
- Rename to NavigationManager
- Remove all traces of old naming

There's no functional or design change in this commit - just removing
all traces of the old name. The next few iterations will try to improve
the design.

* Minor API tweaks to NavigationManager

Making Initialize protected causes problems because right now the
server-side code needs to deal with one of two different
implementations, hence an exchange type is used. I followed the same
pattern that was used for auth for symmetry but I have some *cool*
thoughts.

- We can remove this when we remove stateful prerendering
- I have another idea to banish this pattern to the land of wind and
ghosts

If this ends up sticking around longer than a week in the code, lets
discuss other ideas and try to improve the pattern.

* Use hub method for server-side navigation

* Get rid of async local

* Add hub method test

* Misc bikeshedding

* Update src/Components/Server/src/Circuits/DefaultCircuitFactory.cs

Co-Authored-By: campersau <buchholz.bastian@googlemail.com>

* PR feedback

Author: rynowak

src/Components/Blazor/Blazor/ref/Microsoft.AspNetCore.Blazor.netstandard2.0.cs

@@ -1,6 +1,15 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+namespace Microsoft.AspNetCore.Blazor
+{
+    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+    public static partial class JSInteropMethods
+    {
+        [Microsoft.JSInterop.JSInvokableAttribute("NotifyLocationChanged")]
+        public static void NotifyLocationChanged(string uri, bool isInterceptedLink) { }
+    }
+}
 namespace Microsoft.AspNetCore.Blazor.Hosting
 {
     public static partial class BlazorWebAssemblyHost
@@ -68,18 +77,6 @@ protected override void HandleException(System.Exception exception) { }
         protected override System.Threading.Tasks.Task UpdateDisplayAsync(in Microsoft.AspNetCore.Components.Rendering.RenderBatch batch) { throw null; }
     }
 }
-namespace Microsoft.AspNetCore.Blazor.Services
-{
-    public partial class WebAssemblyUriHelper : Microsoft.AspNetCore.Components.UriHelperBase
-    {
-        internal WebAssemblyUriHelper() { }
-        public static readonly Microsoft.AspNetCore.Blazor.Services.WebAssemblyUriHelper Instance;
-        protected override void EnsureInitialized() { }
-        protected override void NavigateToCore(string uri, bool forceLoad) { }
-        [Microsoft.JSInterop.JSInvokableAttribute("NotifyLocationChanged")]
-        public static void NotifyLocationChanged(string newAbsoluteUri, bool isInterceptedLink) { }
-    }
-}
 namespace Microsoft.AspNetCore.Components.Builder
 {
     public static partial class ComponentsApplicationBuilderExtensions

src/Components/Blazor/Blazor/src/Hosting/WebAssemblyHostBuilder.cs

@@ -92,16 +92,16 @@ private void CreateServiceProvider()
             services.AddSingleton<IWebAssemblyHost, WebAssemblyHost>();
             services.AddSingleton<IJSRuntime>(WebAssemblyJSRuntime.Instance);
             services.AddSingleton<IComponentContext, WebAssemblyComponentContext>();
-            services.AddSingleton<IUriHelper>(WebAssemblyUriHelper.Instance);
+            services.AddSingleton<NavigationManager>(WebAssemblyNavigationManager.Instance);
             services.AddSingleton<INavigationInterception>(WebAssemblyNavigationInterception.Instance);
             services.AddSingleton<ILoggerFactory, WebAssemblyLoggerFactory>();
             services.AddSingleton<HttpClient>(s =>
             {
                 // Creating the URI helper needs to wait until the JS Runtime is initialized, so defer it.
-                var uriHelper = s.GetRequiredService<IUriHelper>();
+                var navigationManager = s.GetRequiredService<NavigationManager>();
                 return new HttpClient
                 {
-                    BaseAddress = new Uri(WebAssemblyUriHelper.Instance.GetBaseUri())
+                    BaseAddress = new Uri(navigationManager.BaseUri)
                 };
             });
 

src/Components/Blazor/Blazor/src/JSInteropMethods.cs

@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.ComponentModel;
+using Microsoft.AspNetCore.Blazor.Services;
+using Microsoft.JSInterop;
+
+namespace Microsoft.AspNetCore.Blazor
+{
+    /// <summary>
+    /// Contains methods called by interop. Intended for framework use only, not supported for use in application
+    /// code.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static class JSInteropMethods
+    {
+        /// <summary>
+        /// For framework use only.
+        /// </summary>
+        [JSInvokable(nameof(NotifyLocationChanged))]
+        public static void NotifyLocationChanged(string uri, bool isInterceptedLink)
+        {
+            WebAssemblyNavigationManager.Instance.SetLocation(uri, isInterceptedLink);
+        }
+    }
+}

src/Components/Blazor/Blazor/src/Services/WebAssemblyNavigationInterception.cs

@@ -3,7 +3,7 @@
 
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.Routing;
-using Interop = Microsoft.AspNetCore.Components.Web.BrowserUriHelperInterop;
+using Interop = Microsoft.AspNetCore.Components.Web.BrowserNavigationManagerInterop;
 
 namespace Microsoft.AspNetCore.Blazor.Services
 {

src/Components/Blazor/Blazor/src/Services/WebAssemblyNavigationManager.cs

@@ -0,0 +1,53 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Components;
+using Interop = Microsoft.AspNetCore.Components.Web.BrowserNavigationManagerInterop;
+
+namespace Microsoft.AspNetCore.Blazor.Services
+{
+    /// <summary>
+    /// Default client-side implementation of <see cref="NavigationManager"/>.
+    /// </summary>
+    internal class WebAssemblyNavigationManager : NavigationManager
+    {
+        /// <summary>
+        /// Gets the instance of <see cref="WebAssemblyNavigationManager"/>.
+        /// </summary>
+        public static readonly WebAssemblyNavigationManager Instance = new WebAssemblyNavigationManager();
+
+        // For simplicity we force public consumption of the BrowserNavigationManager through
+        // a singleton. Only a single instance can be updated by the browser through
+        // interop. We can construct instances for testing.
+        internal WebAssemblyNavigationManager()
+        {
+        }
+
+        protected override void EnsureInitialized()
+        {
+            // As described in the comment block above, BrowserNavigationManager is only for
+            // client-side (Mono) use, so it's OK to rely on synchronicity here.
+            var baseUri = WebAssemblyJSRuntime.Instance.Invoke<string>(Interop.GetBaseUri);
+            var uri = WebAssemblyJSRuntime.Instance.Invoke<string>(Interop.GetLocationHref);
+            Initialize(baseUri, uri);
+        }
+
+        public void SetLocation(string uri, bool isInterceptedLink)
+        {
+            Uri = uri;
+            NotifyLocationChanged(isInterceptedLink);
+        }
+
+        /// <inheritdoc />
+        protected override void NavigateToCore(string uri, bool forceLoad)
+        {
+            if (uri == null)
+            {
+                throw new ArgumentNullException(nameof(uri));
+            }
+
+            WebAssemblyJSRuntime.Instance.Invoke<object>(Interop.NavigateTo, uri, forceLoad);
+        }
+    }
+}

src/Components/Blazor/Blazor/src/Services/WebAssemblyUriHelper.cs

@@ -266,16 +266,6 @@ public sealed partial class InjectAttribute : System.Attribute
     {
         public InjectAttribute() { }
     }
-    public partial interface IUriHelper
-    {
-        event System.EventHandler<Microsoft.AspNetCore.Components.Routing.LocationChangedEventArgs> OnLocationChanged;
-        string GetAbsoluteUri();
-        string GetBaseUri();
-        void NavigateTo(string uri);
-        void NavigateTo(string uri, bool forceLoad);
-        System.Uri ToAbsoluteUri(string href);
-        string ToBaseRelativePath(string baseUri, string locationAbsolute);
-    }
     [System.AttributeUsageAttribute(System.AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
     public sealed partial class LayoutAttribute : System.Attribute
     {
@@ -302,6 +292,20 @@ public partial class NavigationException : System.Exception
         public NavigationException(string uri) { }
         public string Location { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
+    public abstract partial class NavigationManager
+    {
+        protected NavigationManager() { }
+        public string BaseUri { get { throw null; } protected set { } }
+        public string Uri { get { throw null; } protected set { } }
+        public event System.EventHandler<Microsoft.AspNetCore.Components.Routing.LocationChangedEventArgs> LocationChanged { add { } remove { } }
+        protected virtual void EnsureInitialized() { }
+        protected void Initialize(string baseUri, string uri) { }
+        public void NavigateTo(string uri, bool forceLoad = false) { }
+        protected abstract void NavigateToCore(string uri, bool forceLoad);
+        protected void NotifyLocationChanged(bool isInterceptedLink) { }
+        public System.Uri ToAbsoluteUri(string relativeUri) { throw null; }
+        public string ToBaseRelativePath(string uri) { throw null; }
+    }
     public abstract partial class OwningComponentBase : Microsoft.AspNetCore.Components.ComponentBase, System.IDisposable
     {
         protected OwningComponentBase() { }
@@ -383,23 +387,6 @@ public sealed partial class RouteAttribute : System.Attribute
         public RouteAttribute(string template) { }
         public string Template { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public abstract partial class UriHelperBase : Microsoft.AspNetCore.Components.IUriHelper
-    {
-        protected UriHelperBase() { }
-        public event System.EventHandler<Microsoft.AspNetCore.Components.Routing.LocationChangedEventArgs> OnLocationChanged { add { } remove { } }
-        protected virtual void EnsureInitialized() { }
-        public string GetAbsoluteUri() { throw null; }
-        public virtual string GetBaseUri() { throw null; }
-        public virtual void InitializeState(string uriAbsolute, string baseUriAbsolute) { }
-        public void NavigateTo(string uri) { }
-        public void NavigateTo(string uri, bool forceLoad) { }
-        protected abstract void NavigateToCore(string uri, bool forceLoad);
-        protected void SetAbsoluteBaseUri(string baseUri) { }
-        protected void SetAbsoluteUri(string uri) { }
-        public System.Uri ToAbsoluteUri(string href) { throw null; }
-        public string ToBaseRelativePath(string baseUri, string locationAbsolute) { throw null; }
-        protected void TriggerOnLocationChanged(bool isinterceptedLink) { }
-    }
 }
 namespace Microsoft.AspNetCore.Components.CompilerServices
 {
@@ -637,16 +624,17 @@ public enum RenderTreeFrameType : short
 }
 namespace Microsoft.AspNetCore.Components.Routing
 {
+    public partial interface IHostEnvironmentNavigationManager
+    {
+        void Initialize(string baseUri, string uri);
+    }
     public partial interface INavigationInterception
     {
         System.Threading.Tasks.Task EnableNavigationInterceptionAsync();
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public readonly partial struct LocationChangedEventArgs
+    public partial class LocationChangedEventArgs : System.EventArgs
     {
-        private readonly object _dummy;
-        private readonly int _dummyPrimitive;
-        public LocationChangedEventArgs(string location, bool isNavigationIntercepted) { throw null; }
+        public LocationChangedEventArgs(string location, bool isNavigationIntercepted) { }
         public bool IsNavigationIntercepted { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public string Location { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }

src/Components/Components/ref/Microsoft.AspNetCore.Components.netstandard2.0.cs

@@ -6,7 +6,7 @@
 namespace Microsoft.AspNetCore.Components
 {
     /// <summary>
-    /// Exception thrown when an <see cref="IUriHelper"/> is not able to navigate to a different url.
+    /// Exception thrown when an <see cref="NavigationManager"/> is not able to navigate to a different url.
     /// </summary>
     public class NavigationException : Exception
     {