Move GPU preliminary info collection back to UI thread.

content/browser/gpu/gpu_blacklist.h

 // 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.
 
 #ifndef CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #define CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 27 matching lines @@
     kOsUnknown
   };
 
   enum OsFilter {
     // In loading, ignore all entries that belong to other OS.
     kCurrentOsOnly,
     // In loading, keep all entries. This is for testing only.
     kAllOs
   };
 
-  explicit GpuBlacklist(const std::string& browser_info_string);
+  explicit GpuBlacklist(const std::string& browser_version_string);
   ~GpuBlacklist();
 
   // Loads blacklist information from a json file.
   // If failed, the current GpuBlacklist is un-touched.
   bool LoadGpuBlacklist(const std::string& json_context, OsFilter os_filter);
   bool LoadGpuBlacklist(const base::DictionaryValue& parsed_json,
                         OsFilter os_filter);
 
   // Collects system information and combines them with gpu_info and blacklist
   // information to determine gpu feature flags.
@@ skipping 44 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownField);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownExceptionField);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownFeature);
 
   enum BrowserVersionSupport {
     kSupported,
     kUnsupported,
     kMalformed
   };
 
-  enum BrowserChannel {
-    kStable,
-    kBeta,
-    kDev,
-    kCanary,
-    kUnknown
-  };
-
   class VersionInfo {
    public:
     VersionInfo(const std::string& version_op,
                 const std::string& version_string,
                 const std::string& version_string2);
     ~VersionInfo();
 
     // Determines if a given version is included in the VersionInfo range.
     bool Contains(const Version& version) const;
 
@@ skipping 76 matching lines @@
   class GpuBlacklistEntry : public base::RefCounted<GpuBlacklistEntry> {
    public:
     // Constructs GpuBlacklistEntry from DictionaryValue loaded from json.
     // Top-level entry must have an id number.  Others are exceptions.
     static ScopedGpuBlacklistEntry GetGpuBlacklistEntryFromValue(
         base::DictionaryValue* value, bool top_level);
 
     // Determines if a given os/gc/driver is included in the Entry set.
     bool Contains(OsType os_type,
                   const Version& os_version,
-                  BrowserChannel channel,
                   const content::GPUInfo& gpu_info) const;
 
     // Returns the OsType.
     OsType GetOsType() const;
 
     // Returns the entry's unique id.  0 is reserved.
     uint32 id() const;
 
     // Returns whether the entry is disabled.
     bool disabled() const;
@@ skipping 51 matching lines @@
                          const std::string& vendor_value);
 
     bool SetGLRendererInfo(const std::string& renderer_op,
                            const std::string& renderer_value);
 
     bool SetBlacklistedFeatures(
         const std::vector<std::string>& blacklisted_features);
 
     void AddException(ScopedGpuBlacklistEntry exception);
 
-    void AddBrowserChannel(BrowserChannel channel);
-
     uint32 id_;
     bool disabled_;
     std::string description_;
     std::vector<int> cr_bugs_;
     std::vector<int> webkit_bugs_;
     scoped_ptr<OsInfo> os_info_;
     uint32 vendor_id_;
     std::vector<uint32> device_id_list_;
     scoped_ptr<StringInfo> driver_vendor_info_;
     scoped_ptr<VersionInfo> driver_version_info_;
     scoped_ptr<VersionInfo> driver_date_info_;
     scoped_ptr<StringInfo> gl_vendor_info_;
     scoped_ptr<StringInfo> gl_renderer_info_;
     scoped_ptr<GpuFeatureFlags> feature_flags_;
     std::vector<ScopedGpuBlacklistEntry> exceptions_;
-    std::vector<BrowserChannel> browser_channels_;
     bool contains_unknown_fields_;
     bool contains_unknown_features_;
   };
 
   // Gets the current OS type.
   static OsType GetOsType();
 
   void Clear();
 
   // Check if the entry is supported by the current version of browser.
   // By default, if there is no browser version information in the entry,
   // return kSupported;
   BrowserVersionSupport IsEntrySupportedByCurrentBrowserVersion(
       base::DictionaryValue* value);
 
   // Returns the number of entries.  This is only for tests.
   size_t num_entries() const;
 
   // Check if any entries contain unknown fields.  This is only for tests.
   bool contains_unknown_fields() const { return contains_unknown_fields_; }
 
-  // The browser_info_string's format is "version channel".
-  // For example, "13.0.123.4 canary".
-  void SetBrowserInfo(const std::string& browser_info_string);
-
-  static BrowserChannel StringToBrowserChannel(const std::string& value);
+  void SetBrowserVersion(const std::string& version_string);
 
   scoped_ptr<Version> version_;
   std::vector<ScopedGpuBlacklistEntry> blacklist_;
 
   scoped_ptr<Version> browser_version_;
-  BrowserChannel browser_channel_;
 
   // This records all the blacklist entries that are appliable to the current
   // user machine.  It is updated everytime DetermineGpuFeatureFlags() is
   // called and is used later by GetGpuFeatureFlagEntries().
   std::vector<ScopedGpuBlacklistEntry> active_entries_;
 
   uint32 max_entry_id_;
 
   bool contains_unknown_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBlacklist);
 };
 
 #endif  // CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_