Use GpuPreferences to avoid directly accessing switches in gpu related code

content/gpu/gpu_child_thread.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/gpu/gpu_child_thread.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/gpu/establish_channel_params.h"
 #include "content/common/gpu/gpu_host_messages.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/media/gpu_video_decode_accelerator.h"
 #include "content/gpu/gpu_process_control_impl.h"
 #include "content/gpu/gpu_watchdog_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/gpu/content_gpu_client.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/config/gpu_info_collector.h"
+#include "gpu/config/gpu_switches.h"
+#include "gpu/config/gpu_util.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace content {
 namespace {
 
 static base::LazyInstance<scoped_refptr<ThreadSafeSender> >
     g_thread_safe_sender = LAZY_INSTANCE_INITIALIZER;
 
+bool GetSizeTFromSwitch(const base::CommandLine* command_line,
+                        const base::StringPiece& switch_string,
+                        size_t* value) {
+  if (!command_line->HasSwitch(switch_string))
+    return false;
+  std::string switch_value(command_line->GetSwitchValueASCII(switch_string));
+  return base::StringToSizeT(switch_value, value);
+}
+
+gpu::GpuPreferences GetGpuPreferencesFromCommandLine() {
+  // TODO(penghuang): share below code with
+  // android_webview/browser/deferred_gpu_command_service.cc
+  // For any modification of below code, deferred_gpu_command_service.cc should
+  // be updated as well.
+  DCHECK(base::CommandLine::InitializedForCurrentProcess());
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  gpu::GpuPreferences gpu_preferences;
+  gpu_preferences.single_process =
+      command_line->HasSwitch(switches::kSingleProcess);
+  gpu_preferences.in_process_gpu =
+      command_line->HasSwitch(switches::kInProcessGPU);
+  gpu_preferences.ui_prioritize_in_gpu_process =
+      command_line->HasSwitch(switches::kUIPrioritizeInGpuProcess);
+  gpu_preferences.compile_shader_always_succeeds =
+      command_line->HasSwitch(switches::kCompileShaderAlwaysSucceeds);
+  gpu_preferences.disable_gl_error_limit =
+    command_line->HasSwitch(switches::kDisableGLErrorLimit);
+  gpu_preferences.disable_glsl_translator =
+    command_line->HasSwitch(switches::kDisableGLSLTranslator);
+  gpu_preferences.disable_gpu_driver_bug_workarounds =
+    command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds);
+  gpu_preferences.disable_shader_name_hashing =
+    command_line->HasSwitch(switches::kDisableShaderNameHashing);
+  gpu_preferences.enable_gpu_command_logging =
+    command_line->HasSwitch(switches::kEnableGPUCommandLogging);
+  gpu_preferences.enable_gpu_debugging =
+    command_line->HasSwitch(switches::kEnableGPUDebugging);
+  gpu_preferences.enable_gpu_service_logging_gpu =
+    command_line->HasSwitch(switches::kEnableGPUServiceLoggingGPU);
+  gpu_preferences.disable_gpu_program_cache =
+    command_line->HasSwitch(switches::kDisableGpuProgramCache);
+  gpu_preferences.enforce_gl_minimums =
+    command_line->HasSwitch(switches::kEnforceGLMinimums);
+  if (GetSizeTFromSwitch(command_line, switches::kForceGpuMemAvailableMb,
+                         &gpu_preferences.force_gpu_mem_available)) {
+    gpu_preferences.force_gpu_mem_available *= 1024 * 1024;
+  }
+  if (GetSizeTFromSwitch(command_line, switches::kGpuProgramCacheSizeKb,
+                         &gpu_preferences.gpu_program_cache_size)) {
+    gpu_preferences.gpu_program_cache_size *= 1024;
+  }
+  gpu_preferences.enable_share_group_async_texture_upload =
+    command_line->HasSwitch(switches::kEnableShareGroupAsyncTextureUpload);
+  gpu_preferences.enable_subscribe_uniform_extension =
+    command_line->HasSwitch(switches::kEnableSubscribeUniformExtension);
+  gpu_preferences.enable_threaded_texture_mailboxes =
+    command_line->HasSwitch(switches::kEnableThreadedTextureMailboxes);
+  gpu_preferences.gl_shader_interm_output =
+    command_line->HasSwitch(switches::kGLShaderIntermOutput);
+  gpu_preferences.emulate_shader_precision =
+    command_line->HasSwitch(switches::kEmulateShaderPrecision);
+  gpu_preferences.enable_gl_path_rendering =
+    command_line->HasSwitch(switches::kEnableGLPathRendering);
+  gpu_preferences.enable_gpu_service_logging =
+      command_line->HasSwitch(switches::kEnableGPUServiceLogging);
+  gpu_preferences.enable_gpu_service_tracing =
+      command_line->HasSwitch(switches::kEnableGPUServiceTracing);
+  gpu_preferences.enable_unsafe_es3_apis =
+    command_line->HasSwitch(switches::kEnableUnsafeES3APIs);
+  return gpu_preferences;
+}
+
 bool GpuProcessLogMessageHandler(int severity,
                                  const char* file, int line,
                                  size_t message_start,
                                  const std::string& str) {
   std::string header = str.substr(0, message_start);
   std::string message = str.substr(message_start);
 
   g_thread_safe_sender.Get()->Send(
       new GpuHostMsg_OnLogMessage(severity, header, message));
 
@@ skipping 76 matching lines @@
   if (message_filter)
     builder.AddStartupFilter(message_filter);
 #endif
 
   return builder.Build();
 }
 
 }  // namespace
 
 GpuChildThread::GpuChildThread(
+    const gpu::GpuPreferences* gpu_preferences,
     GpuWatchdogThread* watchdog_thread,
     bool dead_on_arrival,
     const gpu::GPUInfo& gpu_info,
     const DeferredMessages& deferred_messages,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory,
     gpu::SyncPointManager* sync_point_manager)
     : ChildThreadImpl(GetOptions(gpu_memory_buffer_factory)),
+      gpu_preferences_(gpu_preferences ?
+          *gpu_preferences : GetGpuPreferencesFromCommandLine()),

[boliu, 2016/02/26 22:17:32]

Don't do this. Either make the caller construct a GpuPreferences, or don't have
the parameter at all.

Again, this suggests once again there should not be two copies of
GetGpuPreferencesFromCommandLine. Maybe it should be a method in the public
content API?

[Peng, 2016/02/29 16:09:22]

Removed the gpu_preferences for this constructor. But for the other
constructor, may I ask why we cannot use a pointer there? The GpuChildThread are
created in several places. To modify there places to supply a GpuPreferences is
inconvenient. That is why piman@ suggested we put the GpuPreference and parse
the command line in this class.
I would like to put GetGpuPreferencesFromCommandLine() in content/public, but it
has a little problem. Seems content/public/common are used by browser, gpu and
renderer processes, but this function uses gpu::GpuPreferences and it is in the
gpu/command_buffer/service . I believe gpu service code should not be used by
renderer and browser processes indirectly, right? Any suggestion?

[boliu, 2016/02/29 16:26:40]

const* is generally against the style guide. Either it should be const&, or just
non-const* for an output parameter.
Webview only needs it from browser side, so the public API only needs to be in
content/public/browser. But inside content, it's needed from child as well. I
don't know if there is any precedence for something like that. Ask piman or
another content owner maybe?

[Peng, 2016/02/29 19:29:50]

https://google.github.io/styleguide/cppguide.html#Reference_Arguments

Base on google code style. non-const references is disallowed, but const pointer
is OK.
piman@ LGTMed the duplicate code in DeferredGpuCommandService & GpuChildThread
(I think he doesn't object it as a short term solution, but he is OOO, I cannot
confirm it right now). In followup CLs, we will get rid of gpu related switches
by sending gpu::GpuPreferences from browser to gpu service. It will remove those
duplicate code.
I filed a new issue for it(http://crbug.com/590825), and added it in the TODO
inline comment.

[boliu, 2016/02/29 19:48:22]

My earlier point was that some of these switches should not be removed. How are
you going to deal with the duplicated code then?

[Peng, 2016/02/29 20:30:49]

If some switches cannot be removed, we will only removed them from gpu process's
command line, and keep them for browser process's command line, so we will only
parse command line in browser code (process), and pass the preferences to gpu
service code (process) by IPC or a parameter.

       dead_on_arrival_(dead_on_arrival),
       sync_point_manager_(sync_point_manager),
       gpu_info_(gpu_info),
       deferred_messages_(deferred_messages),
       in_browser_process_(false),
       gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {
   watchdog_thread_ = watchdog_thread;
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
   g_thread_safe_sender.Get() = thread_safe_sender();
 }
 
 GpuChildThread::GpuChildThread(
+    const gpu::GpuPreferences* gpu_preferences,
     const InProcessChildThreadParams& params,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory,
     gpu::SyncPointManager* sync_point_manager)
     : ChildThreadImpl(ChildThreadImpl::Options::Builder()
                           .InBrowserProcess(params)
                           .AddStartupFilter(new GpuMemoryBufferMessageFilter(
                               gpu_memory_buffer_factory))
                           .Build()),
+      gpu_preferences_(gpu_preferences ?
+          *gpu_preferences : GetGpuPreferencesFromCommandLine()),

[boliu, 2016/02/26 22:17:32]

ditto

       dead_on_arrival_(false),
       sync_point_manager_(sync_point_manager),
       in_browser_process_(true),
       gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
   DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kSingleProcess) ||
          base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 173 matching lines @@
   }
 
   // We don't need to pipe log messages if we are running the GPU thread in
   // the browser process.
   if (!in_browser_process_)
     logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
 
   // Defer creation of the render thread. This is to prevent it from handling
   // IPC messages before the sandbox has been enabled and all other necessary
   // initialization has succeeded.
-  gpu_channel_manager_.reset(new GpuChannelManager(
-      this, watchdog_thread_.get(), base::ThreadTaskRunnerHandle::Get().get(),
-      ChildProcess::current()->io_task_runner(),
-      ChildProcess::current()->GetShutDownEvent(), sync_point_manager_,
-      gpu_memory_buffer_factory_));
+  gpu_channel_manager_.reset(
+      new GpuChannelManager(gpu_preferences_, this, watchdog_thread_.get(),
+                            base::ThreadTaskRunnerHandle::Get().get(),
+                            ChildProcess::current()->io_task_runner(),
+                            ChildProcess::current()->GetShutDownEvent(),
+                            sync_point_manager_, gpu_memory_buffer_factory_));
 
 #if defined(USE_OZONE)
   ui::OzonePlatform::GetInstance()
       ->GetGpuPlatformSupport()
       ->OnChannelEstablished(this);
 #endif
 }
 
 void GpuChildThread::OnFinalize() {
   // Quit the GPU process
@@ skipping 150 matching lines @@
 
 void GpuChildThread::BindProcessControlRequest(
     mojo::InterfaceRequest<ProcessControl> request) {
   DVLOG(1) << "GPU: Binding ProcessControl request";
   DCHECK(process_control_);
   process_control_bindings_.AddBinding(process_control_.get(),
                                        std::move(request));
 }
 
 }  // namespace content