gpu: Replace more chrome ipc with mojom api.

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 410 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback, handles));
 }
 
 // static
 void GpuProcessHost::SendOnIO(GpuProcessKind kind,
                               bool force_create,
                               IPC::Message* message) {
+#if !defined(OS_WIN)
+  DCHECK_NE(kind, GpuProcessHost::GPU_PROCESS_KIND_UNSANDBOXED);
+#endif
   if (!BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&SendGpuProcessMessage, kind, force_create, message))) {
     delete message;
   }
 }
 
 // static
 void GpuProcessHost::CallOnIO(
     GpuProcessKind kind,
     bool force_create,
     const base::Callback<void(GpuProcessHost*)>& callback) {
+#if !defined(OS_WIN)
+  DCHECK_NE(kind, GpuProcessHost::GPU_PROCESS_KIND_UNSANDBOXED);
+#endif
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RunCallbackOnIO, kind, force_create, callback));
 }
 
 service_manager::InterfaceProvider* GpuProcessHost::GetRemoteInterfaces() {
   return process_->child_connection()->GetRemoteInterfaces();
 }
 
 // static
@@ skipping 222 matching lines @@
   DCHECK(CalledOnValidThread());
   process_->GetHost()->AddFilter(filter);
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_Initialized, OnInitialized)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GpuMemoryBufferCreated,
                         OnGpuMemoryBufferCreated)
-#if defined(OS_ANDROID)
-    IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyingVideoSurfaceAck,
-                        OnDestroyingVideoSurfaceAck)
-#endif
     IPC_MESSAGE_HANDLER(GpuHostMsg_FieldTrialActivated, OnFieldTrialActivated);
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHost::OnChannelConnected(int32_t peer_pid) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelConnected");
 
@@ skipping 71 matching lines @@
 
   Send(new GpuMsg_DestroyGpuMemoryBuffer(id, client_id, sync_token));
 }
 
 #if defined(OS_ANDROID)
 void GpuProcessHost::SendDestroyingVideoSurface(int surface_id,
                                                 const base::Closure& done_cb) {
   TRACE_EVENT0("gpu", "GpuProcessHost::SendDestroyingVideoSurface");
   DCHECK(send_destroying_video_surface_done_cb_.is_null());
   DCHECK(!done_cb.is_null());
-  if (Send(new GpuMsg_DestroyingVideoSurface(surface_id))) {
-    send_destroying_video_surface_done_cb_ = done_cb;
-  } else {
-    done_cb.Run();
-  }
+  send_destroying_video_surface_done_cb_ = done_cb;
+  gpu_service_ptr_->DestroyingVideoSurface(
+      surface_id, base::Bind(&GpuProcessHost::OnDestroyingVideoSurfaceAck,
+                             weak_ptr_factory_.GetWeakPtr()));
 }
 #endif
 
 void GpuProcessHost::OnInitialized(
     bool result,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info) {
   UMA_HISTOGRAM_BOOLEAN("GPU.GPUProcessInitialized", result);
   initialized_ = result;
   gpu_info_ = gpu_info;
@@ skipping 12 matching lines @@
     mojo::ScopedMessagePipeHandle channel_handle) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelEstablished");
   DCHECK(!channel_requests_.empty());
   DCHECK(channel_requests_.front().Equals(callback));
   channel_requests_.pop();
 
   // Currently if any of the GPU features are blacklisted, we don't establish a
   // GPU channel.
   if (channel_handle.is_valid() &&
       !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(nullptr)) {
-    Send(new GpuMsg_CloseChannel(client_id));
+    gpu_service_ptr_->CloseChannel(client_id);
     callback.Run(IPC::ChannelHandle(), gpu::GPUInfo());
     RouteOnUIThread(
         GpuHostMsg_OnLogMessage(logging::LOG_WARNING, "WARNING",
                                 "Hardware acceleration is unavailable."));
     return;
   }
 
   callback.Run(IPC::ChannelHandle(channel_handle.release()), gpu_info_);
 }
 
 void GpuProcessHost::OnGpuMemoryBufferCreated(
     const gfx::GpuMemoryBufferHandle& handle) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnGpuMemoryBufferCreated");
 
   if (create_gpu_memory_buffer_requests_.empty())
     return;
 
   CreateGpuMemoryBufferCallback callback =
       create_gpu_memory_buffer_requests_.front();
   create_gpu_memory_buffer_requests_.pop();
   callback.Run(handle);
 }
 
 #if defined(OS_ANDROID)
-void GpuProcessHost::OnDestroyingVideoSurfaceAck(int surface_id) {
+void GpuProcessHost::OnDestroyingVideoSurfaceAck() {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnDestroyingVideoSurfaceAck");
   if (!send_destroying_video_surface_done_cb_.is_null())
     base::ResetAndReturn(&send_destroying_video_surface_done_cb_).Run();
 }
 #endif
 
 void GpuProcessHost::OnFieldTrialActivated(const std::string& trial_name) {
   // Activate the trial in the browser process to match its state in the
   // GPU process. This is done by calling FindFullName which finalizes the group
   // and activates the trial.
@@ skipping 340 matching lines @@
                      &prefix);
   return prefix;
 }
 
 void GpuProcessHost::LoadedShader(const std::string& key,
                                   const std::string& data) {
   std::string prefix = GetShaderPrefixKey(data);
   bool prefix_ok = !key.compare(0, prefix.length(), prefix);
   UMA_HISTOGRAM_BOOLEAN("GPU.ShaderLoadPrefixOK", prefix_ok);
   if (prefix_ok)
-    Send(new GpuMsg_LoadedShader(data));
+    gpu_service_ptr_->LoadedShader(data);
 }
 
 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_));
 
   client_id_to_shader_cache_[client_id] = cache;
 }
 
 }  // namespace content