mus+ash: Enable Chrome HW rendering in mus+ash

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 436 matching lines @@
   attributes.bind_generates_resource = false;
   attributes.lose_context_when_out_of_memory = true;
   const bool automatic_flushes = false;
   return make_scoped_refptr(new ContextProviderCommandBuffer(
       std::move(gpu_channel_host), stream_id, stream_priority,
       gpu::kNullSurfaceHandle,
       GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext"),
       automatic_flushes, support_locking, limits, attributes, nullptr, type));
 }
 
+bool IsRunningInMash() {
+  const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
+  return cmdline->HasSwitch(switches::kIsRunningInMash);
+}
+
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   ~MemoryObserver() override {}
 
   void WillProcessTask(const base::PendingTask& pending_task) override {}
 
@@ skipping 167 matching lines @@
 #if defined(USE_EXTERNAL_POPUP_MENU)
   // On Mac and Android Java UI, the select popups are rendered by the browser.
   blink::WebView::setUseExternalPopupMenus(true);
 #endif
 
   lazy_tls.Pointer()->Set(this);
 
   // Register this object as the main thread.
   ChildProcess::current()->set_main_thread(this);
 
+#if defined(MOJO_SHELL_CLIENT)
+  if (IsRunningInMash()) {
+    auto* shell_connection = ChildThread::Get()->GetMojoShellConnection();
+    ui::GpuService::Initialize(shell_connection->GetConnector());
+  }
+#endif
+
   InitializeWebKit(resource_task_queue);
 
   // In single process the single process is all there is.
   webkit_shared_timer_suspended_ = false;
   widget_count_ = 0;
   hidden_widget_count_ = 0;
   idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
   idle_notifications_to_skip_ = 0;
 
   appcache_dispatcher_.reset(
       new AppCacheDispatcher(Get(), new AppCacheFrontendImpl()));
   dom_storage_dispatcher_.reset(new DomStorageDispatcher());
   main_thread_indexed_db_dispatcher_.reset(new IndexedDBDispatcher(
       thread_safe_sender()));
   main_thread_cache_storage_dispatcher_.reset(
       new CacheStorageDispatcher(thread_safe_sender()));
   embedded_worker_dispatcher_.reset(new EmbeddedWorkerDispatcher());
 
   // Note: This may reorder messages from the ResourceDispatcher with respect to
   // other subsystems.
   resource_dispatch_throttler_.reset(new ResourceDispatchThrottler(
       static_cast<RenderThread*>(this), renderer_scheduler_.get(),
       base::TimeDelta::FromSecondsD(kThrottledResourceRequestFlushPeriodS),
       kMaxResourceRequestsPerFlushWhenThrottled));
   resource_dispatcher()->set_message_sender(resource_dispatch_throttler_.get());
 
-  media_stream_center_ = NULL;
+  media_stream_center_ = nullptr;
 
   blob_message_filter_ = new BlobMessageFilter(GetFileThreadMessageLoopProxy());
   AddFilter(blob_message_filter_.get());
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
   vc_manager_.reset(new VideoCaptureImplManager());
   AddFilter(vc_manager_->video_capture_message_filter());
 
   browser_plugin_manager_.reset(new BrowserPluginManager());
@@ skipping 189 matching lines @@
   if (blink_platform_impl_) {
     // Crash the process if they fail to close after a generous amount of time.
     bool all_closed = blink_platform_impl_->web_database_observer_impl()
         ->WaitForAllDatabasesToClose(base::TimeDelta::FromSeconds(60));
     CHECK(all_closed);
   }
 
   // Shutdown in reverse of the initialization order.
   if (devtools_agent_message_filter_.get()) {
     RemoveFilter(devtools_agent_message_filter_.get());
-    devtools_agent_message_filter_ = NULL;
+    devtools_agent_message_filter_ = nullptr;
   }
 
   RemoveFilter(audio_input_message_filter_.get());
-  audio_input_message_filter_ = NULL;
+  audio_input_message_filter_ = nullptr;
 
 #if defined(ENABLE_WEBRTC)
   RTCPeerConnectionHandler::DestructAllHandlers();
   // |peer_connection_factory_| cannot be deleted until after the main message
   // loop has been destroyed.  This is because there may be pending tasks that
   // hold on to objects produced by the PC factory that depend on threads owned
   // by the PC factory.  Once those tasks have been freed, the factory can be
   // deleted.
 #endif
   RemoveFilter(vc_manager_->video_capture_message_filter());
   vc_manager_.reset();
 
   RemoveFilter(db_message_filter_.get());
-  db_message_filter_ = NULL;
+  db_message_filter_ = nullptr;
 
   // Shutdown the file thread if it's running.
   if (file_thread_)
     file_thread_->Stop();
 
   if (compositor_message_filter_.get()) {
     RemoveFilter(compositor_message_filter_.get());
-    compositor_message_filter_ = NULL;
+    compositor_message_filter_ = nullptr;
   }
 
 #if defined(OS_ANDROID)
   if (sync_compositor_message_filter_) {
     RemoveFilter(sync_compositor_message_filter_.get());
     sync_compositor_message_filter_ = nullptr;
   }
   stream_texture_factory_ = nullptr;
 #endif
 
   media_thread_.reset();
 
   blink_platform_impl_->SetCompositorThread(nullptr);
 
   compositor_thread_.reset();
 
   // AudioMessageFilter may be accessed on |media_thread_|, so shutdown after.
   RemoveFilter(audio_message_filter_.get());
-  audio_message_filter_ = NULL;
+  audio_message_filter_ = nullptr;
 
   categorized_worker_pool_->Shutdown();
 
   main_input_callback_.Cancel();
   input_handler_manager_.reset();
   if (input_event_filter_.get()) {
     RemoveFilter(input_event_filter_.get());
-    input_event_filter_ = NULL;
+    input_event_filter_ = nullptr;
   }
 
   // RemoveEmbeddedWorkerRoute may be called while deleting
   // EmbeddedWorkerDispatcher. So it must be deleted before deleting
   // RenderThreadImpl.
   embedded_worker_dispatcher_.reset();
 
   // Ramp down IDB before we ramp down WebKit (and V8), since IDB classes might
   // hold pointers to V8 objects (e.g., via pending requests).
   main_thread_indexed_db_dispatcher_.reset();
 
-  main_thread_compositor_task_runner_ = NULL;
+  main_thread_compositor_task_runner_ = nullptr;
 
   gpu_factories_.clear();
 
   // Context providers must be released prior to destroying the GPU channel.
   shared_worker_context_provider_ = nullptr;
   shared_main_thread_contexts_ = nullptr;
 
   if (gpu_channel_.get())
     gpu_channel_->DestroyChannel();
 
@@ skipping 18 matching lines @@
   // Delay shutting down DiscardableSharedMemoryManager until blink::shutdown
   // is complete, because blink::shutdown destructs Blink Resources and they
   // may try to unlock their underlying discardable memory.
   ChildThreadImpl::ShutdownDiscardableSharedMemoryManager();
 
   // The message loop must be cleared after shutting down
   // the DiscardableSharedMemoryManager, which needs to send messages
   // to the browser process.
   main_message_loop_.reset();
 
-  lazy_tls.Pointer()->Set(NULL);
+  lazy_tls.Pointer()->Set(nullptr);
 }
 
 bool RenderThreadImpl::Send(IPC::Message* msg) {
   // There are cases where we want to pump asynchronous messages while waiting
   // synchronously for the replies to the message to be sent here. However, this
   // may create an opportunity for re-entrancy into WebKit and other subsystems,
   // so we need to take care to disable callbacks, timers, and pending network
   // loads that could trigger such callbacks.
   bool pumping_events = false;
   if (msg->is_sync()) {
@@ skipping 502 matching lines @@
 #if defined(OS_ANDROID)
 
 scoped_refptr<StreamTextureFactory> RenderThreadImpl::GetStreamTexureFactory() {
   DCHECK(IsMainThread());
   if (!stream_texture_factory_.get() ||
       stream_texture_factory_->ContextGL()->GetGraphicsResetStatusKHR() !=
           GL_NO_ERROR) {
     scoped_refptr<ContextProviderCommandBuffer> shared_context_provider =
         SharedMainThreadContextProvider();
     if (!shared_context_provider) {
-      stream_texture_factory_ = NULL;
-      return NULL;
+      stream_texture_factory_ = nullptr;
+      return nullptr;
     }
     DCHECK(shared_context_provider->GetCommandBufferProxy());
     DCHECK(shared_context_provider->GetCommandBufferProxy()->channel());
     stream_texture_factory_ =
         StreamTextureFactory::Create(std::move(shared_context_provider));
   }
   return stream_texture_factory_;
 }
 
 bool RenderThreadImpl::EnableStreamTextureCopy() {
@@ skipping 146 matching lines @@
   // more informative stack, since we will otherwise just crash later when we
   // try to restart it.
   CHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSingleProcess));
   ChildThreadImpl::OnChannelError();
 }
 
 bool RenderThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
   base::ObserverListBase<RenderThreadObserver>::Iterator it(&observers_);
   RenderThreadObserver* observer;
-  while ((observer = it.GetNext()) != NULL) {
+  while ((observer = it.GetNext()) != nullptr) {
     if (observer->OnControlMessageReceived(msg))
       return true;
   }
 
   // Some messages are handled by delegates.
   if (appcache_dispatcher_->OnMessageReceived(msg) ||
       dom_storage_dispatcher_->OnMessageReceived(msg) ||
       embedded_worker_dispatcher_->OnMessageReceived(msg)) {
     return true;
   }
@@ skipping 85 matching lines @@
   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
 
   if (gpu_channel_) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (!gpu_channel_->IsLost())
       return gpu_channel_;
 
     // Recreate the channel if it has been lost.
     gpu_channel_->DestroyChannel();
-    gpu_channel_ = NULL;
+    gpu_channel_ = nullptr;
   }
 
-  // Ask the browser for the channel name.
-  int client_id = 0;
-  IPC::ChannelHandle channel_handle;
-  gpu::GPUInfo gpu_info;
-  if (!Send(new ChildProcessHostMsg_EstablishGpuChannel(
-          cause_for_gpu_launch, &client_id, &channel_handle, &gpu_info)) ||
+  if (!IsRunningInMash()) {
+    int client_id = 0;
+    IPC::ChannelHandle channel_handle;
+    gpu::GPUInfo gpu_info;
+    // Ask the browser for the channel name.
+    if (!Send(new ChildProcessHostMsg_EstablishGpuChannel(
+            cause_for_gpu_launch, &client_id, &channel_handle, &gpu_info)) ||
 #if defined(OS_POSIX)
-      channel_handle.socket.fd == -1 ||
+        channel_handle.socket.fd == -1 ||
 #endif
-      channel_handle.name.empty()) {
-    // Otherwise cancel the connection.
-    return NULL;
+        channel_handle.name.empty()) {
+      // Otherwise cancel the connection.
+      return nullptr;
+    }
+    GetContentClient()->SetGpuInfo(gpu_info);
+
+    // Cache some variables that are needed on the compositor thread for our
+    // implementation of GpuChannelHostFactory.
+    io_thread_task_runner_ = ChildProcess::current()->io_task_runner();
+
+    gpu_channel_ =
+        gpu::GpuChannelHost::Create(this, client_id, gpu_info, channel_handle,
+                                    ChildProcess::current()->GetShutDownEvent(),
+                                    gpu_memory_buffer_manager());
+  } else {
+#if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
+    gpu_channel_ = ui::GpuService::GetInstance()->EstablishGpuChannelSync();
+#else
+    NOTREACHED();
+#endif
   }
-
-  GetContentClient()->SetGpuInfo(gpu_info);
-
-  // Cache some variables that are needed on the compositor thread for our
-  // implementation of GpuChannelHostFactory.
-  io_thread_task_runner_ = ChildProcess::current()->io_task_runner();
-
-  gpu_channel_ = gpu::GpuChannelHost::Create(
-      this, client_id, gpu_info, channel_handle,
-      ChildProcess::current()->GetShutDownEvent(), gpu_memory_buffer_manager());
   return gpu_channel_;
 }
 
 std::unique_ptr<cc::OutputSurface>
 RenderThreadImpl::CreateCompositorOutputSurface(
     bool use_software,
     int routing_id,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
     const GURL& url) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
 
 #if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
-  auto shell_connection = MojoShellConnection::GetForProcess();
+  auto* shell_connection = MojoShellConnection::GetForProcess();
   if (shell_connection && !use_software &&
       command_line.HasSwitch(switches::kUseMusInRenderer)) {
-    ui::GpuService::Initialize(shell_connection->GetConnector());
     RenderWidgetMusConnection* connection =
         RenderWidgetMusConnection::GetOrCreate(routing_id);
     return connection->CreateOutputSurface();
   }
 #endif
 
   uint32_t output_surface_id = g_next_output_surface_id++;
 
   if (command_line.HasSwitch(switches::kEnableVulkan)) {
     scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider =
@@ skipping 386 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content