gpu: Completely remove GpuProcessHostUIShim.

content/browser/gpu/gpu_process_host.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/browser/gpu/gpu_process_host.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 11 matching lines @@
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/tracing/common/tracing_switches.h"
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/browser_main_loop.h"
+#include "content/browser/field_trial_recorder.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_main_thread_factory.h"
-#include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/gpu/shader_cache_factory.h"
 #include "content/browser/service_manager/service_manager_context.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/in_process_child_thread_params.h"
 #include "content/common/service_manager/child_connection.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/gpu_utils.h"
 #include "content/public/common/connection_filter.h"
@@ skipping 18 matching lines @@
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "ui/display/display_switches.h"
 #include "ui/gfx/switches.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/latency/latency_info.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
+#include "content/public/browser/android/java_interfaces.h"
+#include "media/mojo/interfaces/android_overlay.mojom.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "content/common/sandbox_win.h"
 #include "sandbox/win/src/sandbox_policy.h"
 #include "ui/gfx/switches.h"
 #include "ui/gfx/win/rendering_window_manager.h"
 #endif
 
@@ skipping 103 matching lines @@
 GpuProcessHost* g_gpu_process_hosts[GpuProcessHost::GPU_PROCESS_KIND_COUNT];
 
 void RunCallbackOnIO(GpuProcessHost::GpuProcessKind kind,
                      bool force_create,
                      const base::Callback<void(GpuProcessHost*)>& callback) {
   GpuProcessHost* host = GpuProcessHost::Get(kind, force_create);
   callback.Run(host);
 }
 
 #if defined(USE_OZONE)
+// The ozone platform use this callback to send IPC messages to the gpu process.
 void SendGpuProcessMessage(base::WeakPtr<GpuProcessHost> host,
                            IPC::Message* message) {
   if (host)
     host->Send(message);
   else
     delete message;
 }
+
+void RouteMessageToOzoneOnUI(const IPC::Message& message) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ui::OzonePlatform::GetInstance()
+      ->GetGpuPlatformSupportHost()
+      ->OnMessageReceived(message);
+}
+
 #endif  // defined(USE_OZONE)
 
+void OnGpuProcessHostDestroyedOnUI(int host_id, const std::string& message) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  GpuDataManagerImpl::GetInstance()->AddLogMessage(
+      logging::LOG_ERROR, "GpuProcessHostUIShim", message);
+#if defined(USE_OZONE)
+  ui::OzonePlatform::GetInstance()
+      ->GetGpuPlatformSupportHost()
+      ->OnChannelDestroyed(host_id);
+#endif
+}
+
 // NOTE: changes to this class need to be reviewed by the security team.
 class GpuSandboxedProcessLauncherDelegate
     : public SandboxedProcessLauncherDelegate {
  public:
   explicit GpuSandboxedProcessLauncherDelegate(
       const base::CommandLine& cmd_line)
 #if defined(OS_WIN)
       : cmd_line_(cmd_line)
 #endif
   {
@@ skipping 83 matching lines @@
   SandboxType GetSandboxType() override {
     return SANDBOX_TYPE_GPU;
   }
 
  private:
 #if defined(OS_WIN)
   base::CommandLine cmd_line_;
 #endif  // OS_WIN
 };
 
+#if defined(OS_ANDROID)
+template <typename Interface>
+void BindJavaInterface(mojo::InterfaceRequest<Interface> request) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  content::GetGlobalJavaInterfaces()->GetInterface(std::move(request));
+}
+#endif  // defined(OS_ANDROID)
+
 }  // anonymous namespace
 
 class GpuProcessHost::ConnectionFilterImpl : public ConnectionFilter {
  public:
   ConnectionFilterImpl() {
-    GpuProcessHostUIShim::RegisterUIThreadMojoInterfaces(&registry_);
+    auto task_runner = BrowserThread::GetTaskRunnerForThread(BrowserThread::UI);
+    registry_.AddInterface(base::Bind(&FieldTrialRecorder::Create),
+                           task_runner);
+    registry_.AddInterface(
+        base::Bind(
+            &memory_instrumentation::CoordinatorImpl::BindCoordinatorRequest,
+            base::Unretained(
+                memory_instrumentation::CoordinatorImpl::GetInstance())),
+        task_runner);
+#if defined(OS_ANDROID)
+    registry_.AddInterface(
+        base::Bind(&BindJavaInterface<media::mojom::AndroidOverlayProvider>),
+        task_runner);
+#endif
   }
 
  private:
   // ConnectionFilter:
   void OnBindInterface(const service_manager::ServiceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle* interface_pipe,
                        service_manager::Connector* connector) override {
     if (registry_.CanBindInterface(interface_name)) {
       registry_.BindInterface(source_info.identity, interface_name,
@@ skipping 134 matching lines @@
           switches::kInProcessGPU)) {
     in_process_ = true;
   }
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
   // it for 'gpu thread' mode and only create one instance of host and thread.
   DCHECK(!in_process_ || g_gpu_process_hosts[kind] == NULL);
 
   g_gpu_process_hosts[kind] = this;
 
-  // Post a task to create the corresponding GpuProcessHostUIShim. The
-  // GpuProcessHostUIShim will be destroyed when the GpuProcessHost is
-  // destroyed, which happens when the corresponding GPU process terminates or
-  // fails to launch. On browser exit, the shim can be leaked.
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&GpuProcessHostUIShim::Create), host_id));
-
   process_.reset(new BrowserChildProcessHostImpl(
       PROCESS_TYPE_GPU, this, mojom::kGpuServiceName));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   DCHECK(CalledOnValidThread());
 
   SendOutstandingReplies();
 
   // In case we never started, clean up.
@@ skipping 67 matching lines @@
         break;
     }
   }
 
   // If there are any remaining offscreen contexts at the point the
   // GPU process exits, assume something went wrong, and block their
   // URLs from accessing client 3D APIs without prompting.
   if (block_offscreen_contexts)
     BlockLiveOffscreenContexts();
 
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&GpuProcessHostUIShim::Destroy,
-                                     host_id_,
-                                     message));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&OnGpuProcessHostDestroyedOnUI, host_id_, message));
 }
 
 bool GpuProcessHost::Init() {
   init_start_time_ = base::TimeTicks::Now();
 
   TRACE_EVENT_INSTANT0("gpu", "LaunchGpuProcess", TRACE_EVENT_SCOPE_THREAD);
 
   // May be null during test execution.
   if (ServiceManagerConnection::GetForProcess()) {
     ServiceManagerConnection::GetForProcess()->AddConnectionFilter(
@@ skipping 32 matching lines @@
   gpu_main_ptr_->CreateGpuService(
       std::move(request), gpu_host_binding_.CreateInterfacePtrAndBind(),
       gpu_preferences, activity_flags_.CloneHandle());
 
 #if defined(USE_OZONE)
   // Ozone needs to send the primary DRM device to GPU process as early as
   // possible to ensure the latter always has a valid device. crbug.com/608839
   ui::OzonePlatform::GetInstance()
       ->GetGpuPlatformSupportHost()
       ->OnGpuProcessLaunched(
-          host_id_, base::ThreadTaskRunnerHandle::Get(),
+          host_id_, BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
+          base::ThreadTaskRunnerHandle::Get(),
           base::Bind(&SendGpuProcessMessage, weak_ptr_factory_.GetWeakPtr()));
 #endif
 
   return true;
 }
 
-void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) {
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&RouteToGpuProcessHostUIShimTask, host_id_, message));
-}
-
 bool GpuProcessHost::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
   if (process_->GetHost()->IsChannelOpening()) {
     queued_messages_.push(msg);
     return true;
   }
 
   bool result = process_->Send(msg);
   if (!result) {
     // Channel is hosed, but we may not get destroyed for a while. Send
     // outstanding channel creation failures now so that the caller can restart
     // with a new process/channel without waiting.
     SendOutstandingReplies();
   }
   return result;
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
-  RouteOnUIThread(message);
+#if defined(USE_OZONE)
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&RouteMessageToOzoneOnUI, message));
+#endif
   return true;
 }
 
 void GpuProcessHost::OnChannelConnected(int32_t peer_pid) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelConnected");
 
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
@@ skipping 515 matching lines @@
   if (!cache.get())
     return;
 
   cache->set_shader_loaded_callback(base::Bind(&GpuProcessHost::LoadedShader,
                                                weak_ptr_factory_.GetWeakPtr()));
 
   client_id_to_shader_cache_[client_id] = cache;
 }
 
 }  // namespace content