Add a JS API for detecting WebGL availability.

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 178 matching lines @@
 
 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),
+      complete_gpu_info_available_(false),
       observer_list_(new GpuDataManagerObserverList),
       software_rendering_(false) {
   Initialize();
 }
 
 void GpuDataManager::Initialize() {
   // User flags need to be collected before any further initialization.
   user_flags_.Initialize();
 
   if (!user_flags_.skip_gpu_data_loading()) {
     content::GPUInfo gpu_info;
     gpu_info_collector::CollectPreliminaryGraphicsInfo(&gpu_info);
-    UpdateGpuInfo(gpu_info);
+    {
+      base::AutoLock auto_lock(gpu_info_lock_);
+      gpu_info_ = gpu_info;
+    }
   }
 
 #if defined(OS_MACOSX)
   CGDisplayRegisterReconfigurationCallback(DisplayReconfigCallback, this);
 #endif
 }
 
 GpuDataManager::~GpuDataManager() {
 #if defined(OS_MACOSX)
   CGDisplayRemoveReconfigurationCallback(DisplayReconfigCallback, this);
 #endif
 }
 
 // static
 GpuDataManager* GpuDataManager::GetInstance() {
   return Singleton<GpuDataManager>::get();
 }
 
 void GpuDataManager::RequestCompleteGpuInfoIfNeeded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (complete_gpu_info_already_requested_)
+
+  if (complete_gpu_info_already_requested_ || complete_gpu_info_available_)
     return;
   complete_gpu_info_already_requested_ = true;
 
   GpuProcessHost::SendOnIO(
       0,
       content::CAUSE_FOR_GPU_LAUNCH_GPUDATAMANAGER_REQUESTCOMPLETEGPUINFOIFNEEDED,
       new GpuMsg_CollectGraphicsInfo());
 }
 
 void GpuDataManager::UpdateGpuInfo(const content::GPUInfo& gpu_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  complete_gpu_info_available_ = true;
+  complete_gpu_info_already_requested_ = true;
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     if (!Merge(&gpu_info_, gpu_info))
       return;
-  }
-
-  NotifyGpuInfoUpdate();
-
-  {
-    base::AutoLock auto_lock(gpu_info_lock_);
     content::GetContentClient()->SetGpuInfo(gpu_info_);
   }
 
   UpdateGpuFeatureFlags();
+  // We have to update GpuFeatureFlags before notify all the observers.
+  NotifyGpuInfoUpdate();
 }
 
 const content::GPUInfo& GpuDataManager::gpu_info() const {
   base::AutoLock auto_lock(gpu_info_lock_);
   return gpu_info_;
 }
 
 Value* GpuDataManager::GetFeatureStatus() {
   bool gpu_access_blocked = !GpuAccessAllowed();
 
@@ skipping 281 matching lines @@
 #endif
 
   return info;
 }
 
 void GpuDataManager::NotifyGpuInfoUpdate() {
   observer_list_->Notify(&GpuDataManager::Observer::OnGpuInfoUpdate);
 }
 
 void GpuDataManager::UpdateGpuFeatureFlags() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&GpuDataManager::UpdateGpuFeatureFlags,
-                   base::Unretained(this)));
-    return;
-  }
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GpuBlacklist* gpu_blacklist = GetGpuBlacklist();
   // We don't set a lock around modifying gpu_feature_flags_ since it's just an
   // int.
   if (!gpu_blacklist) {
     gpu_feature_flags_.set_flags(0);
     return;
   }
 
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_feature_flags_ = gpu_blacklist->DetermineGpuFeatureFlags(
         GpuBlacklist::kOsAny, NULL, gpu_info_);
   }
 
-  // Notify clients that GpuInfo state has changed
-  NotifyGpuInfoUpdate();
-
   uint32 flags = gpu_feature_flags_.flags();
   uint32 max_entry_id = gpu_blacklist->max_entry_id();
   bool disabled = false;
   if (flags == 0) {
     UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
         0, max_entry_id + 1);
   } else {
     std::vector<uint32> flag_entries;
     gpu_blacklist->GetGpuFeatureFlagEntries(
         GpuFeatureFlags::kGpuFeatureAll, flag_entries, disabled);
@@ skipping 162 matching lines @@
 bool GpuDataManager::supportsAccelerated2dCanvas() const {
   if (gpu_info_.can_lose_context)
     return false;
 #if defined(USE_SKIA)
   return true;
 #else
   return false;
 #endif
 }