Convert SetIsIncognitoProcess to use mojo.

chrome/renderer/chrome_render_thread_observer.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 "chrome/renderer/chrome_render_thread_observer.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
@@ skipping 216 matching lines @@
                           std::move(request));
 }
 
 }  // namespace
 
 bool ChromeRenderThreadObserver::is_incognito_process_ = false;
 
 ChromeRenderThreadObserver::ChromeRenderThreadObserver()
     : field_trial_syncer_(this),
       visited_link_slave_(new visitedlink::VisitedLinkSlave),
+      renderer_binding_(this),
       weak_factory_(this) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
   RenderThread* thread = RenderThread::Get();
   resource_delegate_.reset(new RendererResourceDelegate());
   thread->SetResourceDispatcherDelegate(resource_delegate_.get());
 
   thread->GetInterfaceRegistry()->AddInterface(
       base::Bind(CreateResourceUsageReporter, weak_factory_.GetWeakPtr()));
@@ skipping 18 matching lines @@
   WebSecurityPolicy::registerURLSchemeAsNoAccess(native_scheme);
   WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs(
       native_scheme);
 
   thread->GetInterfaceRegistry()->AddInterface(
       visited_link_slave_->GetBindCallback());
 }
 
 ChromeRenderThreadObserver::~ChromeRenderThreadObserver() {}
 
+void ChromeRenderThreadObserver::RegisterMojoInterfaces(
+    content::AssociatedInterfaceRegistry* associated_interfaces) {
+  associated_interfaces->AddInterface(
+      base::Bind(&ChromeRenderThreadObserver::OnRendererInterfaceRequest,
+                 base::Unretained(this)));

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

BTW, I am not 100% confident that this is correct wrt lifetime issues. See also
the new "TODO: unregister the mojo interfaces?" in
content/renderer/render_thread_impl.cc.

Can you please take another look at this?

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

To clarify, in this case it is technically fine since the
ChromeRenderThreadObserver is never removed and therefore lives as long as the
RenderThreadImpl.

But it would be good to explicitly unregister as mentioned in other comments, so
that the correct usage pattern is demonstrated by this CL.

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

Done.

+}
+
+void ChromeRenderThreadObserver::OnRendererInterfaceRequest(
+    chrome::mojom::RendererAssociatedRequest request) {
+  DCHECK(!renderer_binding_.is_bound());
+  renderer_binding_.Bind(std::move(request));
+}
+
 bool ChromeRenderThreadObserver::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeRenderThreadObserver, message)
-    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetIsIncognitoProcess,
-                        OnSetIsIncognitoProcess)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetFieldTrialGroup, OnSetFieldTrialGroup)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetContentSettingRules,
                         OnSetContentSettingRules)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ChromeRenderThreadObserver::OnRenderProcessShutdown() {
   visited_link_slave_.reset();
 }
 
 void ChromeRenderThreadObserver::OnFieldTrialGroupFinalized(
     const std::string& trial_name,
     const std::string& group_name) {
   content::RenderThread::Get()->Send(
       new ChromeViewHostMsg_FieldTrialActivated(trial_name));
 }
 
-void ChromeRenderThreadObserver::OnSetIsIncognitoProcess(
-    bool is_incognito_process) {
-  is_incognito_process_ = is_incognito_process;
+void ChromeRenderThreadObserver::InitialConfiguration(
+    chrome::mojom::InitialConfigurationParamsPtr params) {
+  is_incognito_process_ = params->is_incognito_process;
 }
 
 void ChromeRenderThreadObserver::OnSetContentSettingRules(
     const RendererContentSettingRules& rules) {
   content_setting_rules_ = rules;
 }
 
 void ChromeRenderThreadObserver::OnSetFieldTrialGroup(
     const std::string& trial_name,
     const std::string& group_name) {
   field_trial_syncer_.OnSetFieldTrialGroup(trial_name, group_name);
 }
 
 const RendererContentSettingRules*
 ChromeRenderThreadObserver::content_setting_rules() const {
   return &content_setting_rules_;
 }