Move FrameMsg_NewFrame/NewFrameProxy to mojom

content/browser/renderer_host/render_process_host_impl.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 159 matching lines @@
   bool IsProcessBackgrounded() const override;
   void IncrementServiceWorkerRefCount() override;
   void DecrementServiceWorkerRefCount() override;
   void IncrementSharedWorkerRefCount() override;
   void DecrementSharedWorkerRefCount() override;
   void ForceReleaseWorkerRefCounts() override;
   bool IsWorkerRefCountDisabled() override;
   void PurgeAndSuspend() override;
 
   mojom::RouteProvider* GetRemoteRouteProvider();
-  mojom::Renderer* GetRendererInterface();
+
+  static mojom::Renderer* GetRendererInterface(RenderProcessHost* host);

[ncarter (slow), 2016/10/03 22:45:09]

I'm okay with this approach. Putting a static method in RPHI that accepts an
RPH* seems to be an established pattern -- RegisterHost, IsSuitableHost, and a
few others work that way.

Really the existence of this pattern is a sign that something is lacking in the
RenderProcessHost/RenderProcessHostImpl/MockRenderProcessHost design, which I
would characterize as some combination of, "RenderProcessHost is doing
double-duty as both the public interface of RenderProcessHostImpl and as the
base class for a Mock version of RenderProcessHostImpl," "RenderProcessHostImpl
is too big to mock."

Historically, MockRenderProcessHost used to inherit from RenderProcessHostImpl
(this changed as part of the content api extraction:
https://chromium.googlesource.com/chromium/src/+/f3b1a084a01ab82caf998daefcb9...
)

One fix would be for us to extract a content-private class
{RenderProcessHostBase : public RenderProcessHost}, and move methods there from
both the public interface (like RenderProcessHost::Init) and static methods from
RenderProcessHostImpl. RPH -> RPHB would be a safe cast.

A more extreme fix, would be to make RPH->RPHI a safe cast, ideally by moving
the child-process-launcher behaviors into an interface that's mockable, and
making RPHI a final class. MockRPH would really only exist as a
RenderProcessHostFactory that passes a mock process-laucher-delegate or whatever
instance to the RPHI ctor, plus some easy way to get at the IPC::TestSink and
friends. This actually sounds pretty good to me as an end state, though the
reality of what the code needs to get done seems like it could throw any number
of wrenches in the feasibility of this idea.

I've put the above griping into a bug: 652474

 
   // IPC::Sender via RenderProcessHost.
   bool Send(IPC::Message* msg) override;
 
   // IPC::Listener via RenderProcessHost.
   bool OnMessageReceived(const IPC::Message& msg) override;
   void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
   void OnBadMessageReceived(const IPC::Message& message) override;
 
@@ skipping 377 matching lines @@
   // Therefore a proper shutdown event to unblock the UI thread is not
   // possible without massive refactoring shutdown code.
   // Luckily Android never performs a clean shutdown. So explicitly
   // ignore this problem.
   base::WaitableEvent never_signaled_;
 #endif
 
   scoped_refptr<ResourceMessageFilter> resource_message_filter_;
 
   mojom::RouteProviderAssociatedPtr remote_route_provider_;
-  mojom::RendererAssociatedPtr renderer_interface_;
 
   // A WeakPtrFactory which is reset every time Cleanup() runs. Used to vend
   // WeakPtrs which are invalidated any time the RPHI is recycled.
   std::unique_ptr<base::WeakPtrFactory<RenderProcessHostImpl>>
       instance_weak_factory_;
 
   base::WeakPtrFactory<RenderProcessHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_