Service CreateNewWindow on the UI thread with a new mojo interface

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 239 matching lines @@
 const size_t kImageCacheSingleAllocationByteLimit = 64 * 1024 * 1024;
 
 #if defined(OS_ANDROID)
 // Unique identifier for each output surface created.
 uint32_t g_next_compositor_frame_sink_id = 1;
 #endif
 
 // An implementation of mojom::RenderMessageFilter which can be mocked out
 // for tests which may indirectly send messages over this interface.
 mojom::RenderMessageFilter* g_render_message_filter_for_testing;
+mojom::RenderMessageFilterUI* g_render_message_filter_ui_for_testing;
 
 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl>>::DestructorAtExit
     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 
 // v8::MemoryPressureLevel should correspond to base::MemoryPressureListener.
 static_assert(static_cast<v8::MemoryPressureLevel>(
     base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) ==
         v8::MemoryPressureLevel::kNone, "none level not align");
@@ skipping 261 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
+mojom::RenderMessageFilterUI*
+RenderThreadImpl::current_render_message_filter_ui() {
+  if (g_render_message_filter_ui_for_testing)
+    return g_render_message_filter_ui_for_testing;
+  DCHECK(current());
+  return current()->render_message_filter_ui();
+}
+
+// static
 void RenderThreadImpl::SetRenderMessageFilterForTesting(
     mojom::RenderMessageFilter* render_message_filter) {
   g_render_message_filter_for_testing = render_message_filter;
 }
 
+void RenderThreadImpl::SetRenderMessageFilterUIForTesting(
+    mojom::RenderMessageFilterUI* render_message_filter_ui) {
+  g_render_message_filter_ui_for_testing = render_message_filter_ui;
+}
+
 // 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,
     std::unique_ptr<blink::scheduler::RendererScheduler> scheduler,
     const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue)
     : ChildThreadImpl(Options::Builder()
                           .InBrowserProcess(params)
                           .AutoStartServiceManagerConnection(false)
@@ skipping 1492 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();
 }
 
+mojom::RenderMessageFilterUI* RenderThreadImpl::render_message_filter_ui() {
+  if (!render_message_filter_ui_) {
+    GetChannel()->GetRemoteAssociatedInterface(&render_message_filter_ui_);
+  }
+
+  DCHECK(render_message_filter_ui_);
+  return render_message_filter_ui_.get();
+}
+
 gpu::GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
   if (!gpu_channel_)
     return nullptr;
   if (gpu_channel_->IsLost())
     return nullptr;
   return gpu_channel_.get();
 }
 
 void RenderThreadImpl::OnFieldTrialGroupFinalized(
     const std::string& trial_name,
@@ skipping 381 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content