gpu: Some code cleanups.

services/ui/gpu/gpu_service.cc

 // Copyright 2016 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 "services/ui/gpu/gpu_service.h"
 
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
 #include "base/memory/shared_memory.h"
@@ skipping 214 matching lines @@
 
 void GpuService::DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                                         int client_id,
                                         const gpu::SyncToken& sync_token) {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::DestroyGpuMemoryBuffer, weak_ptr_,
                               id, client_id, sync_token));
     return;
   }
-  if (gpu_channel_manager_)

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

This used to be necessary (in GpuChildThread) because some IPCs could be
pipelined (from the host) after initialization, but initialization could fail
(so we wouldn't create the GpuChannelManager), so the GPU process could see
these messages come in before the process exited.

Is it not possible any more?

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

We tear-down the mojo connection if the initialization fails [1]. So I think
this should now be safe?

[1]
https://cs.chromium.org/chromium/src/content/gpu/gpu_child_thread.cc?type=cs&...

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

Ok. It does rely on the fact that gpu_service_.reset() happens in the same task
as the gpu_service_->Bind(std::move(request)); there. Worth a comment and/or
moving the dead_on_arrival_ path before the Bind.

[sadrul, 2017/04/07 22:57:03]

Sounds good. Moved Bind() to happen after the check for dead_on_arrival_, and
added a comment.

-    gpu_channel_manager_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
+  gpu_channel_manager_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
 }
 
 void GpuService::GetVideoMemoryUsageStats(
     const GetVideoMemoryUsageStatsCallback& callback) {
   if (io_runner_->BelongsToCurrentThread()) {
     auto wrap_callback = WrapCallback(io_runner_, callback);
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::GetVideoMemoryUsageStats, weak_ptr_,
                               wrap_callback));
     return;
   }
   gpu::VideoMemoryUsageStats video_memory_usage_stats;
-  if (gpu_channel_manager_) {
-    gpu_channel_manager_->gpu_memory_manager()->GetVideoMemoryUsageStats(
-        &video_memory_usage_stats);
-  }
+  gpu_channel_manager_->gpu_memory_manager()->GetVideoMemoryUsageStats(
+      &video_memory_usage_stats);
   callback.Run(video_memory_usage_stats);
 }
 
 void GpuService::RequestCompleteGpuInfo(
     const RequestCompleteGpuInfoCallback& callback) {
   if (io_runner_->BelongsToCurrentThread()) {
     auto wrap_callback = WrapCallback(io_runner_, callback);
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::RequestCompleteGpuInfo, weak_ptr_,
                               wrap_callback));
@@ skipping 114 matching lines @@
                            base::Bind(cb, base::Passed(std::move(handle))));
         },
         io_runner_, callback);
     main_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GpuService::EstablishGpuChannel, weak_ptr_, client_id,
                    client_tracing_id, is_gpu_host, wrap_callback));
     return;
   }
 
-  if (!gpu_channel_manager_) {
-    callback.Run(mojo::ScopedMessagePipeHandle());
-    return;
-  }
-
   gpu::GpuChannel* gpu_channel = gpu_channel_manager_->EstablishChannel(
       client_id, client_tracing_id, is_gpu_host);
 
   mojo::MessagePipe pipe;
   gpu_channel->Init(base::MakeUnique<gpu::SyncChannelFilteredSender>(
       pipe.handle0.release(), gpu_channel, io_runner_, shutdown_event_));
 
   media_gpu_channel_manager_->AddChannel(client_id);
 
   callback.Run(std::move(pipe.handle1));
 }
 
 void GpuService::CloseChannel(int32_t client_id) {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::CloseChannel, weak_ptr_, client_id));
     return;
   }
-  if (!gpu_channel_manager_)
-    return;
   gpu_channel_manager_->RemoveChannel(client_id);
 }
 
 void GpuService::LoadedShader(const std::string& data) {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::LoadedShader, weak_ptr_, data));
     return;
   }
-  if (!gpu_channel_manager_)
-    return;
   gpu_channel_manager_->PopulateShaderCache(data);
 }
 
 void GpuService::DestroyingVideoSurface(
     int32_t surface_id,
     const DestroyingVideoSurfaceCallback& callback) {
   DCHECK(io_runner_->BelongsToCurrentThread());
 #if defined(OS_ANDROID)
   main_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           [](int32_t surface_id) {
             media::AVDACodecAllocator::Instance()->OnSurfaceDestroyed(
                 surface_id);
           },
           surface_id),
       callback);
 #else
   NOTREACHED() << "DestroyingVideoSurface() not supported on this platform.";
 #endif
 }
 
 void GpuService::WakeUpGpu() {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(FROM_HERE,
                            base::Bind(&GpuService::WakeUpGpu, weak_ptr_));
     return;
   }
 #if defined(OS_ANDROID)
-  if (!gpu_channel_manager_)
-    return;
   gpu_channel_manager_->WakeUpGpu();
 #else
   NOTREACHED() << "WakeUpGpu() not supported on this platform.";
 #endif
 }
 
 void GpuService::GpuSwitched() {
   DVLOG(1) << "GPU: GPU has switched";
   if (!in_host_process_)
     ui::GpuSwitchingManager::GetInstance()->NotifyGpuSwitched();
 }
 
 void GpuService::DestroyAllChannels() {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(
         FROM_HERE, base::Bind(&GpuService::DestroyAllChannels, weak_ptr_));
     return;
   }
-  if (!gpu_channel_manager_)
-    return;
   DVLOG(1) << "GPU: Removing all contexts";
   gpu_channel_manager_->DestroyAllChannels();
 }
 
 void GpuService::Crash() {
   DCHECK(io_runner_->BelongsToCurrentThread());
   DVLOG(1) << "GPU: Simulating GPU crash";
   // Good bye, cruel world.
   volatile int* it_s_the_end_of_the_world_as_we_know_it = NULL;
   *it_s_the_end_of_the_world_as_we_know_it = 0xdead;
@@ skipping 24 matching lines @@
 
 void GpuService::Stop(const StopCallback& callback) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   main_runner_->PostTaskAndReply(FROM_HERE, base::Bind([] {
                                    base::MessageLoop::current()->QuitWhenIdle();
                                  }),
                                  callback);
 }
 
 }  // namespace ui