Provide a Mojo equivalent of ThreadSafeSender.

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 94 matching lines @@
 #include "content/renderer/input/input_handler_manager.h"
 #include "content/renderer/input/main_thread_input_event_filter.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
 #include "content/renderer/media/media_stream_center.h"
 #include "content/renderer/media/midi_message_filter.h"
 #include "content/renderer/media/render_media_client.h"
 #include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
+#include "content/renderer/mojo/thread_safe_associated_interface_ptr_provider.h"
 #include "content/renderer/net_info_helper.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/render_frame_proxy.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/scheduler/resource_dispatch_throttler.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 #include "content/renderer/service_worker/embedded_worker_instance_client_impl.h"
 #include "content/renderer/service_worker/service_worker_context_client.h"
@@ skipping 454 matching lines @@
 
 // static
 mojom::RenderMessageFilter* RenderThreadImpl::current_render_message_filter() {
   if (g_render_message_filter_for_testing)
     return g_render_message_filter_for_testing;
   DCHECK(current());
   return current()->render_message_filter();
 }
 
 // static
+const scoped_refptr<mojom::ThreadSafeRenderMessageFilterAssociatedPtr>&
+RenderThreadImpl::current_thread_safe_render_message_filter() {
+  DCHECK(current());
+  return current()->thread_safe_render_message_filter();
+}
+
+// static
 void RenderThreadImpl::SetRenderMessageFilterForTesting(
     mojom::RenderMessageFilter* render_message_filter) {
   g_render_message_filter_for_testing = render_message_filter;
 }
 
 // In single-process mode used for debugging, we don't pass a renderer client
 // ID via command line because RenderThreadImpl lives in the same process as
 // the browser
 RenderThreadImpl::RenderThreadImpl(
     const InProcessChildThreadParams& params,
@@ skipping 86 matching lines @@
       kMaxResourceRequestsPerFlushWhenThrottled));
   resource_dispatcher()->set_message_sender(resource_dispatch_throttler_.get());
 
   media_stream_center_ = nullptr;
 
   blob_message_filter_ = new BlobMessageFilter(GetFileThreadTaskRunner());
   AddFilter(blob_message_filter_.get());
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
+  thread_safe_associated_interface_ptr_provider_ =
+      base::MakeUnique<ThreadSafeAssociatedInterfacePtrProvider>(channel());

[yzshen1, 2016/11/28 18:05:45]

I thought channel()'s return value didn't pass ownership to the caller?

[Jay Civelli, 2016/11/28 18:46:10]

It does not pass ownership. Here we are taking ownership of the new
ThreadSafeAssociatedInterfacePtrProvider we create, which takes a Channel* and
does not take ownership of it.

[yzshen1, 2016/11/28 18:50:21]

Ah, I see, it calls the constructor of ThreadSafeAssociatedInterfacePtrProvider
with a channel argument!

At a quick glance, it seems like a cast.

Thanks for explaining!

Still LGTM

+  thread_safe_render_message_filter_ =
+      thread_safe_associated_interface_ptr_provider_
+          ->CreateInterfacePtr<mojom::RenderMessageFilter>();
+
   vc_manager_.reset(new VideoCaptureImplManager());
 
   browser_plugin_manager_.reset(new BrowserPluginManager());
   AddObserver(browser_plugin_manager_.get());
 
 #if BUILDFLAG(ENABLE_WEBRTC)
   peer_connection_tracker_.reset(new PeerConnectionTracker());
   AddObserver(peer_connection_tracker_.get());
 
   p2p_socket_dispatcher_ = new P2PSocketDispatcher(GetIOTaskRunner().get());
@@ skipping 1407 matching lines @@
     GetChannel()->GetRemoteAssociatedInterface(&render_frame_message_filter_);
   return render_frame_message_filter_.get();
 }
 
 mojom::RenderMessageFilter* RenderThreadImpl::render_message_filter() {
   if (!render_message_filter_)
     GetChannel()->GetRemoteAssociatedInterface(&render_message_filter_);
   return render_message_filter_.get();
 }
 
+const scoped_refptr<mojom::ThreadSafeRenderMessageFilterAssociatedPtr>&
+RenderThreadImpl::thread_safe_render_message_filter() {
+  return thread_safe_render_message_filter_;
+}
+
 gpu::GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
   if (!gpu_channel_)
     return nullptr;
   if (gpu_channel_->IsLost())
     return nullptr;
   return gpu_channel_.get();
 }
 
 void RenderThreadImpl::CreateView(mojom::CreateViewParamsPtr params) {
   CompositorDependencies* compositor_deps = this;
@@ skipping 357 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content