Convert network hints to Mojo

components/network_hints/renderer/renderer_preconnect.cc

Index: components/network_hints/renderer/renderer_preconnect.cc
diff --git a/components/network_hints/renderer/renderer_preconnect.cc b/components/network_hints/renderer/renderer_preconnect.cc
index b353cb1cb4a4ff9025f084bb69a5d04d40e65e26..61d1f2605463b6cb1e03ac0a3c208f8757649cdc 100644
--- a/components/network_hints/renderer/renderer_preconnect.cc
+++ b/components/network_hints/renderer/renderer_preconnect.cc
@@ -7,8 +7,9 @@
 #include "components/network_hints/renderer/renderer_preconnect.h"
 
 #include "components/network_hints/common/network_hints_common.h"
-#include "components/network_hints/common/network_hints_messages.h"
+#include "components/network_hints/public/cpp/network_hints_param_traits.h"
 #include "content/public/renderer/render_thread.h"
+#include "services/shell/public/cpp/interface_provider.h"
 
 using content::RenderThread;
 
@@ -24,8 +25,16 @@ void RendererPreconnect::Preconnect(const GURL& url, bool allow_credentials) {
   if (!url.is_valid())
     return;
 
-  RenderThread::Get()->Send(
-      new NetworkHintsMsg_Preconnect(url, allow_credentials, 1));
+  GetNetworkHints().Preconnect(url, allow_credentials, 1);
+}
+
+mojom::NetworkHints& RendererPreconnect::GetNetworkHints() {
+  DCHECK(content::RenderThread::Get());
+  if (!network_hints_) {

[dcheng, 2016/07/20 13:59:50]

Some places like to cache this interface ptr while others just set up the
message pipe each time from scratch. What's the preferred practice?

Also, how much overhead is there from an interface ptr? Is it expected that each
class that wants to talk to this thing grabs its own interface ptr? When does it
make sense to coordinate through some sort of central location instead of having
this code duplicated?

[tibell, 2016/07/21 00:12:07]

Caching is preferred if you don't know for sure the connection will be used, as
the handshake messages sent back and forth to establish the connection aren't
free. Having one or a few connections per e.g. render thread to the same service
is OK. One per message would be a bit too inefficient.

[dcheng, 2016/07/21 02:43:13]

I guess it's inevitable, but I think it's a bit to figure out what the right
behavior is everywhere: for example, I had a similar question in
https://codereview.chromium.org/2063683002/diff/320001/chrome/renderer/page_l...
(since it sets up / tears down the connection every time it makes the call, but
apparently it's only called once per main frame load)

Just something to keep in mind... the code duplication is also pretty sad.

[tibell, 2016/07/21 05:09:45]

Agreed. sammc@ has a CL that makes InterfacePtr do this lazy init by itself but
there wasn't wide agreement on it being the right thing to do.

+    RenderThread::Get()->GetRemoteInterfaces()->GetInterface(
+        mojo::GetProxy(&network_hints_));
+  }
+  return *network_hints_;
 }
 
 }  // namespace network_hints