Do not create GpuVideoAcceleratorFactories if kDisableGpuCompositing is set

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 1369 matching lines @@
   return result;
 }
 
 void RenderThreadImpl::PostponeIdleNotification() {
   idle_notifications_to_skip_ = 2;
 }
 
 media::GpuVideoAcceleratorFactories* RenderThreadImpl::GetGpuFactories() {
   DCHECK(IsMainThread());
 
+  // XXX: solution1
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableGpuCompositing))
+    return nullptr;
+
   if (!gpu_factories_.empty()) {
     scoped_refptr<ContextProviderCommandBuffer> shared_context_provider =
         gpu_factories_.back()->ContextProviderMainThread();
     if (shared_context_provider) {
       cc::ContextProvider::ScopedContextLock lock(
           shared_context_provider.get());
       if (lock.ContextGL()->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
         return gpu_factories_.back();
       } else {
         scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
             GetMediaThreadTaskRunner();
         media_task_runner->PostTask(
             FROM_HERE,
             base::Bind(
                 base::IgnoreResult(
                     &RendererGpuVideoAcceleratorFactories::CheckContextLost),
                 base::Unretained(gpu_factories_.back())));
       }
     }
   }
 
-  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host =
       EstablishGpuChannelSync(CAUSE_FOR_GPU_LAUNCH_MEDIA_CONTEXT);
   if (!gpu_channel_host)
     return nullptr;
   scoped_refptr<ContextProviderCommandBuffer> media_context_provider =
       CreateOffscreenContext(
           gpu_channel_host, command_buffer_metrics::RENDER_WORKER_CONTEXT,
           gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::NORMAL);
   if (!media_context_provider->BindToCurrentThread())
     return nullptr;
   media_context_provider->SetupLock();
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
       GetMediaThreadTaskRunner();
   const bool enable_video_accelerator =
       !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
   const bool enable_gpu_memory_buffer_video_frames =
+      // XXX: solution2
+      // !cmd_line->HasSwitch(switches::kDisableGpuCompositing) &&
 #if defined(OS_MACOSX) || defined(OS_LINUX)
       !cmd_line->HasSwitch(switches::kDisableGpuMemoryBufferVideoFrames);
 #else
       cmd_line->HasSwitch(switches::kEnableGpuMemoryBufferVideoFrames);
 #endif
   std::vector<unsigned> image_texture_targets;
   std::string video_frame_image_texture_target_string =
       cmd_line->GetSwitchValueASCII(switches::kVideoImageTextureTarget);
   StringToUintVector(video_frame_image_texture_target_string,
                      &image_texture_targets);
@@ skipping 643 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content