Convert SetIsIncognitoProcess to use mojo.

content/renderer/render_thread_impl.cc

 // 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.
 
 #include "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 1154 matching lines @@
 void RenderThreadImpl::AddFilter(IPC::MessageFilter* filter) {
   channel()->AddFilter(filter);
 }
 
 void RenderThreadImpl::RemoveFilter(IPC::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
 void RenderThreadImpl::AddObserver(RenderThreadObserver* observer) {
   observers_.AddObserver(observer);
+  observer->RegisterMojoInterfaces(&associated_interfaces_);
 }
 
 void RenderThreadImpl::RemoveObserver(RenderThreadObserver* observer) {
   observers_.RemoveObserver(observer);
+  // TODO: unregister the mojo interfaces?? How?

[nigeltao1, 2016/12/01 00:30:16]

This TODO might be related. Either way, I'm also not 100% confident if there are
any thread-safety or lifetime issues with calling
InterfaceRegistry::RemoveInterface.

[Ken Rockot(use gerrit already), 2016/12/01 18:46:30]

Ah, missed this.

First, as a general rule, unless a class is documented as thread-safe, it's not
thread-safe. And if a class is not thread-safe, we already must take care to
only use it from a single thread. This AssociatedInterfaceRegistry is therefore
only used on one thread, the same thread which owns and exclusively calls into
RenderThreadImpl (that's the main thread, FWIW).

In fact it's trivial to see that the AssociatedInterfaceRegistry is directly
owned by the RenderThreadImpl and therefore must still be valid if the
RenderThreadImpl is still valid.

I think it would be reasonable to add an
RenderThreadObserver::UnregisterMojoInterfaces call which uses
AssociatedInterfaceRegistry::RemoveInterface. It seems slightly unfortunate
since it would be easy to forget to implement this, but there are relatively few
RenderThreadObservers in the world, so I might feel worse about adding anything
more complex.

[nigeltao1, 2016/12/02 05:36:54]

Done, although just dropping some printf's here confirms that not every
AddObserver is currently balanced by a RemoveObserver, so I haven't (manually or
otherwise) tested the RemoveInterface codepath. As you already said, though,
ChromeRenderThreadObserver is never removed, so I assume that it's OK.

 }
 
 void RenderThreadImpl::SetResourceDispatcherDelegate(
     ResourceDispatcherDelegate* delegate) {
   resource_dispatcher()->set_delegate(delegate);
 }
 
 void RenderThreadImpl::InitializeCompositorThread() {
   base::Thread::Options options;
 #if defined(OS_ANDROID)
@@ skipping 1315 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content