gpu: Some code cleanups.

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 16 matching lines @@
 #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/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/renderer_host/render_widget_host_impl.h"
-#include "content/browser/renderer_host/render_widget_host_view_frame_subscriber.h"
 #include "content/browser/service_manager/service_manager_context.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/gpu_host_messages.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/browser/render_process_host.h"
-#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/connection_filter.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_type.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
@@ skipping 132 matching lines @@
 // only be accessed from the IO thread.
 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)
-void SendGpuProcessMessageByHostId(int host_id, IPC::Message* message) {
-  GpuProcessHost* host = GpuProcessHost::FromID(host_id);
-  if (host) {
-    host->Send(message);
-  } else {
-    delete message;
-  }
-}
-#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
 };
 
-void HostLoadedShader(int host_id,
-                      const std::string& key,
-                      const std::string& data) {
-  GpuProcessHost* host = GpuProcessHost::FromID(host_id);
-  if (host)
-    host->LoadedShader(key, data);
-}
-
 }  // anonymous namespace
 
 class GpuProcessHost::ConnectionFilterImpl : public ConnectionFilter {
  public:
   ConnectionFilterImpl() {
     registry_.AddInterface(
         base::Bind(
             &memory_instrumentation::CoordinatorImpl::BindCoordinatorRequest,
             base::Unretained(
                 memory_instrumentation::CoordinatorImpl::GetInstance())),
@@ skipping 301 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_, BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
-          base::Bind(&SendGpuProcessMessageByHostId, host_id_));
+          host_id_, base::ThreadTaskRunnerHandle::Get(),
+          base::Bind(base::IgnoreResult(&GpuProcessHost::Send),

[piman, 2017/04/06 20:51:14]

So, if the weak_ptr is null, the message will be leaked. Do we still need a
trampoline, maybe?

[sadrul, 2017/04/07 02:16:12]

Good catch! Done. (... although maybe IPC::Sender::Send() could be updated to
take a unique_ptr<Message>)

[piman, 2017/04/07 18:16:41]

That would be ideal... but I think there's so many implementations and callers
to fixup, and given that this is essentially deprecated (vs mojo), so usage
should go down over time, it may not be worth it to go and fix.

+                     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));
@@ skipping 551 matching lines @@
 }
 
 void GpuProcessHost::CreateChannelCache(int32_t client_id) {
   TRACE_EVENT0("gpu", "GpuProcessHost::CreateChannelCache");
 
   scoped_refptr<gpu::ShaderDiskCache> cache =
       GetShaderCacheFactorySingleton()->Get(client_id);
   if (!cache.get())
     return;
 
-  cache->set_shader_loaded_callback(base::Bind(&HostLoadedShader, host_id_));
+  cache->set_shader_loaded_callback(base::Bind(&GpuProcessHost::LoadedShader,
+                                               weak_ptr_factory_.GetWeakPtr()));
 
   client_id_to_shader_cache_[client_id] = cache;
 }
 
 }  // namespace content