Add a command-line switch --skip-gpu-data-loading.

content/browser/gpu/gpu_data_manager.cc

 // Copyright (c) 2011 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/browser/gpu/gpu_data_manager.h"
 
 #if defined(OS_MACOSX)
 #include <CoreGraphics/CGDisplayConfiguration.h>
 #endif
 
@@ skipping 135 matching lines @@
 #endif  // OS_WIN
 
 }  // namespace anonymous
 
 GpuDataManager::UserFlags::UserFlags()
     : disable_accelerated_2d_canvas_(false),
       disable_accelerated_compositing_(false),
       disable_accelerated_layers_(false),
       disable_experimental_webgl_(false),
       disable_gl_multisampling_(false),
-      ignore_gpu_blacklist_(false) {
+      ignore_gpu_blacklist_(false),
+      skip_gpu_data_loading_(false) {
 }
 
 void GpuDataManager::UserFlags::Initialize() {
   const CommandLine& browser_command_line =
       *CommandLine::ForCurrentProcess();
 
   disable_accelerated_2d_canvas_ = browser_command_line.HasSwitch(
       switches::kDisableAccelerated2dCanvas);
   disable_accelerated_compositing_ = browser_command_line.HasSwitch(
       switches::kDisableAcceleratedCompositing);
   disable_accelerated_layers_ = browser_command_line.HasSwitch(
       switches::kDisableAcceleratedLayers);
   disable_experimental_webgl_ = browser_command_line.HasSwitch(
       switches::kDisableExperimentalWebGL);
   disable_gl_multisampling_ = browser_command_line.HasSwitch(
       switches::kDisableGLMultisampling);
 
   ignore_gpu_blacklist_ = browser_command_line.HasSwitch(
       switches::kIgnoreGpuBlacklist);
+  skip_gpu_data_loading_ = browser_command_line.HasSwitch(
+      switches::kSkipGpuDataLoading);
 
   use_gl_ = browser_command_line.GetSwitchValueASCII(switches::kUseGL);
 
   ApplyPolicies();
 }
 
 void GpuDataManager::UserFlags::ApplyPolicies() {
   if (disable_accelerated_compositing_) {
     disable_accelerated_2d_canvas_ = true;
     disable_accelerated_layers_ = true;
   }
 }
 
 GpuDataManager::GpuDataManager()
     : complete_gpu_info_already_requested_(false) {
   Initialize();
 }
 
 void GpuDataManager::Initialize() {
+  // User flags need to be collected before any further initialization.
+  user_flags_.Initialize();
+
   // Certain tests doesn't go through the browser startup path that
   // initializes GpuDataManager on FILE thread; therefore, it is initialized
   // on UI thread later, and we skip the preliminary gpu info collection
   // in such situation.
-  if (BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
+  if (!user_flags_.skip_gpu_data_loading() &&
+      BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     content::GPUInfo gpu_info;
     gpu_info_collector::CollectPreliminaryGraphicsInfo(&gpu_info);
     UpdateGpuInfo(gpu_info);
   }
 
-  user_flags_.Initialize();
-
 #if defined(OS_MACOSX)
   CGDisplayRegisterReconfigurationCallback(DisplayReconfigCallback, this);
 #endif
 }
 
 GpuDataManager::~GpuDataManager() {
 #if defined(OS_MACOSX)
   CGDisplayRemoveReconfigurationCallback(DisplayReconfigCallback, this);
 #endif
 }
@@ skipping 137 matching lines @@
         DictionaryValue* problem = new DictionaryValue();
         problem->SetString(
             "description", kGpuFeatureInfo[i].disabled_description);
         problem->Set("crBugs", new ListValue());
         problem->Set("webkitBugs", new ListValue());
         problem_list->Append(problem);
       }
     }
 
     GpuBlacklist* blacklist = GetGpuBlacklist();
-    if (blacklist && (!UseGLIsOSMesaOrAny()))
+    if (blacklist)
       blacklist->GetBlacklistReasons(problem_list);
 
     status->Set("problems", problem_list);
   }
 
   return status;
 }
 
 std::string GpuDataManager::GetBlacklistVersion() const {
   GpuBlacklist* blacklist = GetGpuBlacklist();
@@ skipping 14 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   log_messages_.Append(msg);
 }
 
 const ListValue& GpuDataManager::log_messages() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return log_messages_;
 }
 
 GpuFeatureFlags GpuDataManager::GetGpuFeatureFlags() {
-  if (UseGLIsOSMesaOrAny())
-    return GpuFeatureFlags();
   return gpu_feature_flags_;
 }
 
 bool GpuDataManager::GpuAccessAllowed() {
-  if (UseGLIsOSMesaOrAny())
-    return true;
-
   // We only need to block GPU process if more features are disallowed other
   // than those in the preliminary gpu feature flags because the latter work
   // through renderer commandline switches.
   uint32 mask = (~(preliminary_gpu_feature_flags_.flags()));
   return (gpu_feature_flags_.flags() & mask) == 0;
 }
 
 void GpuDataManager::AddGpuInfoUpdateCallback(Callback0::Type* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   gpu_info_update_callbacks_.insert(callback);
@@ skipping 270 matching lines @@
 GpuBlacklist* GpuDataManager::GetGpuBlacklist() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (user_flags_.ignore_gpu_blacklist())
     return NULL;
   // No need to return an empty blacklist.
   if (gpu_blacklist_.get() != NULL && gpu_blacklist_->max_entry_id() == 0)
     return NULL;
   return gpu_blacklist_.get();
 }
 
-bool GpuDataManager::UseGLIsOSMesaOrAny() {
-  return (user_flags_.use_gl() == "any" ||
-          user_flags_.use_gl() == gfx::kGLImplementationOSMesaName);
-}
-
 bool GpuDataManager::Merge(content::GPUInfo* object,
                            const content::GPUInfo& other) {
   if (object->device_id != other.device_id ||
       object->vendor_id != other.vendor_id) {
     *object = other;
     return true;
   }
 
   bool changed = false;
   if (!object->finalized) {
@@ skipping 55 matching lines @@
 bool GpuDataManager::supportsAccelerated2dCanvas() const {
   if (gpu_info_.can_lose_context)
     return false;
 #if defined(USE_SKIA)
   return true;
 #else
   return false;
 #endif
 }