Use GpuPreferences to avoid directly accessing switches in gpu related code

gpu/command_buffer/service/in_process_command_buffer.h

 // Copyright 2013 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "gpu/command_buffer/client/gpu_control.h"
 #include "gpu/command_buffer/common/command_buffer.h"
+#include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/gpu_export.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gpu_preference.h"
 
 namespace base {
 class SequenceChecker;
 }
 
 namespace gfx {
 class GLContext;
 class GLShareGroup;
 class GLSurface;
 class Size;
 }
 
 #if defined(OS_ANDROID)
 namespace gfx {
 class SurfaceTexture;
 }
 namespace gpu {
 class StreamTextureManagerInProcess;
 }
 #endif
 
 namespace gpu {
+struct GpuPreferences;
 class SyncPointClient;
 class SyncPointOrderData;
 class SyncPointManager;
 class ValueStateMap;
 
 namespace gles2 {
 class FramebufferCompletenessCache;
 class GLES2Decoder;
 class MailboxManager;
 class ProgramCache;
@@ skipping 67 matching lines @@
   int32_t GetExtraCommandBufferData() const override;
   uint64_t GenerateFenceSyncRelease() override;
   bool IsFenceSyncRelease(uint64_t release) override;
   bool IsFenceSyncFlushed(uint64_t release) override;
   bool IsFenceSyncFlushReceived(uint64_t release) override;
   void SignalSyncToken(const SyncToken& sync_token,
                        const base::Closure& callback) override;
   bool CanWaitUnverifiedSyncToken(const SyncToken* sync_token) override;
 
   // The serializer interface to the GPU service (i.e. thread).
   class Service {

[piman, 2016/02/24 22:19:08]

There is a derived class on Android, for WebView (in
android_webvier/browser/deferred_gpu_command_service.h), that needs to inject
the GpuPreferences taken from the command line. Maybe pass the GpuPreferences
via the constructor?

[Peng, 2016/02/25 16:18:36]

Done.

    public:
     Service();
     virtual ~Service();
 
     virtual void AddRef() const = 0;
     virtual void Release() const = 0;
 
     // Queues a task to run as soon as possible.
     virtual void ScheduleTask(const base::Closure& task) = 0;
 
     // Schedules |callback| to run at an appropriate time for performing delayed
     // work.
     virtual void ScheduleDelayedWork(const base::Closure& task) = 0;
 
     virtual bool UseVirtualizedGLContexts() = 0;
     virtual scoped_refptr<gles2::ShaderTranslatorCache>
         shader_translator_cache() = 0;
     virtual scoped_refptr<gles2::FramebufferCompletenessCache>
     framebuffer_completeness_cache() = 0;
     virtual SyncPointManager* sync_point_manager() = 0;
+    const gpu::GpuPreferences& gpu_preferences();
     scoped_refptr<gfx::GLShareGroup> share_group();
     scoped_refptr<gles2::MailboxManager> mailbox_manager();
     scoped_refptr<gles2::SubscriptionRefSet> subscription_ref_set();
     scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state();
     gpu::gles2::ProgramCache* program_cache();
 
    private:
+    gpu::GpuPreferences gpu_preferences_;
     scoped_refptr<gfx::GLShareGroup> share_group_;
     scoped_refptr<gles2::MailboxManager> mailbox_manager_;
     scoped_refptr<gles2::SubscriptionRefSet> subscription_ref_set_;
     scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state_;
     scoped_ptr<gpu::gles2::ProgramCache> program_cache_;
   };
 
 #if defined(OS_ANDROID)
   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(uint32_t stream_id);
   uint32_t CreateStreamTexture(uint32_t texture_id);
@@ skipping 137 matching lines @@
   SyncPointManager* sync_point_manager_;  // Non-owning.
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
   scoped_refptr<gpu::gles2::FramebufferCompletenessCache>
       framebuffer_completeness_cache_;
   DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_