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_)
-    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::ContentVideoViewOverlayAllocator::GetInstance()
                 ->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