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/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 @@
 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) {
+void SendGpuProcessMessage(base::WeakPtr<GpuProcessHost> host,
+                           IPC::Message* message) {
+  if (host)
     host->Send(message);
-  } else {
+  else
     delete message;
-  }
 }
-#endif
+#endif  // defined(USE_OZONE)
 
 // 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 84 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() {
     GpuProcessHostUIShim::RegisterUIThreadMojoInterfaces(&registry_);
   }
 
  private:
   // ConnectionFilter:
@@ skipping 292 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(&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;
 }
 
-void GpuProcessHost::AddFilter(IPC::MessageFilter* filter) {
-  DCHECK(CalledOnValidThread());
-  process_->GetHost()->AddFilter(filter);
-}
-
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   RouteOnUIThread(message);
   return true;
 }
 
 void GpuProcessHost::OnChannelConnected(int32_t peer_pid) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelConnected");
 
   while (!queued_messages_.empty()) {
@@ skipping 506 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