Move GPU preliminary info collection back to UI thread.

content/browser/gpu/gpu_blacklist.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_blacklist.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
@@ skipping 409 matching lines @@
       }
       dictionary_entry_count++;
     }
 
     DictionaryValue* browser_version_value = NULL;
     // browser_version is processed in LoadGpuBlacklist().
     if (value->GetDictionary("browser_version", &browser_version_value))
       dictionary_entry_count++;
   }
 
-  ListValue* channel_list_value = NULL;
-  if (value->GetList("browser_channels", &channel_list_value)) {
-    for (size_t i = 0; i < channel_list_value->GetSize(); ++i) {
-      std::string channel_value;
-      if (!channel_list_value->GetString(i, &channel_value)) {
-        LOG(WARNING) << "Malformed browser_channels entry " << entry->id();
-        return NULL;
-      }
-      BrowserChannel channel = StringToBrowserChannel(channel_value);
-      if (channel == kUnknown) {
-        LOG(WARNING) << "Malformed browser_channels entry " << entry->id();
-        return NULL;
-      }
-      entry->AddBrowserChannel(channel);
-    }
-    dictionary_entry_count++;
-  }
-
   if (value->size() != dictionary_entry_count) {
     LOG(WARNING) << "Entry with unknown fields " << entry->id();
     entry->contains_unknown_fields_ = true;
   }
   return entry;
 }
 
 GpuBlacklist::GpuBlacklistEntry::GpuBlacklistEntry()
     : id_(0),
       disabled_(false),
@@ skipping 108 matching lines @@
   feature_flags_.reset(new GpuFeatureFlags());
   feature_flags_->set_flags(flags);
   return true;
 }
 
 void GpuBlacklist::GpuBlacklistEntry::AddException(
     ScopedGpuBlacklistEntry exception) {
   exceptions_.push_back(exception);
 }
 
-void GpuBlacklist::GpuBlacklistEntry::AddBrowserChannel(
-    BrowserChannel channel) {
-  DCHECK(channel != kUnknown);
-  browser_channels_.push_back(channel);
-}
-
 bool GpuBlacklist::GpuBlacklistEntry::Contains(
-    OsType os_type, const Version& os_version, BrowserChannel channel,
+    OsType os_type, const Version& os_version,
     const content::GPUInfo& gpu_info) const {
   DCHECK(os_type != kOsAny);
   if (os_info_.get() != NULL && !os_info_->Contains(os_type, os_version))
     return false;
   if (vendor_id_ != 0 && vendor_id_ != gpu_info.vendor_id)
     return false;
   if (device_id_list_.size() > 0) {
     bool found = false;
     for (size_t i = 0; i < device_id_list_.size(); ++i) {
       if (device_id_list_[i] == gpu_info.device_id) {
@@ skipping 20 matching lines @@
         !driver_date_info_->Contains(*driver_date))
       return false;
   }
   if (gl_vendor_info_.get() != NULL &&
       !gl_vendor_info_->Contains(gpu_info.gl_vendor))
     return false;
   if (gl_renderer_info_.get() != NULL &&
       !gl_renderer_info_->Contains(gpu_info.gl_renderer))
     return false;
   for (size_t i = 0; i < exceptions_.size(); ++i) {
-    if (exceptions_[i]->Contains(os_type, os_version, channel, gpu_info))
+    if (exceptions_[i]->Contains(os_type, os_version, gpu_info))
       return false;
   }
-  bool rt = true;
-  if (browser_channels_.size() > 0) {
-    rt = false;
-    for (size_t i = 0; i < browser_channels_.size(); ++i) {
-      if (browser_channels_[i] == channel) {
-        rt = true;
-        break;
-      }
-    }
-  }
-  return rt;
+  return true;
 }
 
 GpuBlacklist::OsType GpuBlacklist::GpuBlacklistEntry::GetOsType() const {
   if (os_info_.get() == NULL)
     return kOsAny;
   return os_info_->type();
 }
 
 uint32 GpuBlacklist::GpuBlacklistEntry::id() const {
   return id_;
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::disabled() const {
   return disabled_;
 }
 
 GpuFeatureFlags GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureFlags() const {
   return *feature_flags_;
 }
 
-GpuBlacklist::GpuBlacklist(const std::string& browser_info_string)
+GpuBlacklist::GpuBlacklist(const std::string& browser_version_string)
     : max_entry_id_(0),
       contains_unknown_fields_(false) {
-  SetBrowserInfo(browser_info_string);
+  SetBrowserVersion(browser_version_string);
 }
 
 GpuBlacklist::~GpuBlacklist() {
   Clear();
 }
 
 bool GpuBlacklist::LoadGpuBlacklist(
     const std::string& json_context, GpuBlacklist::OsFilter os_filter) {
   scoped_ptr<Value> root;
   root.reset(base::JSONReader::Read(json_context, false));
@@ skipping 79 matching lines @@
     std::string version_string = base::SysInfo::OperatingSystemVersion();
     size_t pos = version_string.find_first_not_of("0123456789.");
     if (pos != std::string::npos)
       version_string = version_string.substr(0, pos);
     my_os_version.reset(Version::GetVersionFromString(version_string));
     os_version = my_os_version.get();
   }
   DCHECK(os_version != NULL);
 
   for (size_t i = 0; i < blacklist_.size(); ++i) {
-    if (blacklist_[i]->Contains(os, *os_version, browser_channel_, gpu_info)) {
+    if (blacklist_[i]->Contains(os, *os_version, gpu_info)) {
       if (!blacklist_[i]->disabled())
         flags.Combine(blacklist_[i]->GetGpuFeatureFlags());
       active_entries_.push_back(blacklist_[i]);
     }
   }
   return flags;
 }
 
 void GpuBlacklist::GetGpuFeatureFlagEntries(
     GpuFeatureFlags::GpuFeatureType feature,
@@ skipping 112 matching lines @@
       new VersionInfo(version_op, version_string, version_string2));
     if (!browser_version_info->IsValid())
       return kMalformed;
     if (browser_version_info->Contains(*browser_version_))
       return kSupported;
     return kUnsupported;
   }
   return kSupported;
 }
 
-void GpuBlacklist::SetBrowserInfo(const std::string& browser_info_string) {
-  std::vector<std::string> pieces;
-  base::SplitString(browser_info_string, ' ', &pieces);
-  if (pieces.size() != 2) {
-      pieces.resize(2);
-      pieces[0] = "0";
-      pieces[1] = "unknown";
-  }
-
-  browser_version_.reset(Version::GetVersionFromString(pieces[0]));
+void GpuBlacklist::SetBrowserVersion(const std::string& version_string) {
+  browser_version_.reset(Version::GetVersionFromString(version_string));
   DCHECK(browser_version_.get() != NULL);
-
-  browser_channel_ = StringToBrowserChannel(pieces[1]);
 }
 
-// static
-GpuBlacklist::BrowserChannel GpuBlacklist::StringToBrowserChannel(
-    const std::string& value) {
-  if (value == "stable")
-    return kStable;
-  if (value == "beta")
-    return kBeta;
-  if (value == "dev")
-    return kDev;
-  if (value == "canary")
-    return kCanary;
-  return kUnknown;
-}
-