The naive rename strategy to just append Get doesn't work here, because RenderFrame already exposes GetInterface{Provider,Registry}, which return a service_manager::Interface{Provider,Registry}, while the blink versions return blink::Interface{Provider,Registry}.

Initially, I thought we could just have the WebFrameClient methods return a service_manager::InterfaceProvider/service_manager::InterfaceRegistry and wrap it in Blink. That way, RenderFrameImpl can use the same implementation to override two different methods--a slight abuse of C++, but nothing too horrible.

Note: an assumption is we don't want to use the service_manager interfaces directly in Blink. They do include a lot of random headers, such as <string>.

So fixing this for WebFrameClient is pretty straightforward. However, we also have Platform::interfaceProvider() in the Blink public API. Since it's in platform, any code in Blink can call out to this InterfaceProvider. This leaves several different options:
1. Change it to return a service_manager::InterfaceProvider as well, and force all callers to wrap it in an adapter.

Not very pleasant for Blink callers, but it works. But it'd be best to avoid this if possible, since the temptation to simply #include service_manager's InterfaceProvider seems pretty high. It also seems a bit heavy (we have to create an extra temporary every time just to do talk to the InterfaceProvider). It's also tricky to get the threading right with this version.

2. Remove this function and just expose getInterface() directly.

Works until you run into things like DocumentWebSocketChannel [1] which use the InterfaceProvider interface to abstract away whether it's communicating with the frame provider or the platform provider. We could create a wrapper for just this instance, but it doesn't seem like good design.

3. Change it to return a service_manager::InterfaceProvider and provide a static Platform method to return the wrapped version.

Doesn't create an adapter each time code needs to talk to the interface provider, but this will leave a non-static interfaceProvider() on Platform still, which doesn't seem good either.

4. Keep InterfaceProvider in the public API. For Platform, pass as a blink::InterfaceProvider. For WebFrameClient, pass as a service_manager::Interface{Provider,Registry} and wrap in blink.

A bit ugly, because the blink API is inconsistent. But it probably works? This is the alternative I'm currently leaning towards...

Hopefully in the future we can just use the same interface throughout and avoid all this trouble.