Move GPU device/driver info related code from content to gpu.

gpu/config/gpu_control_list.h

 // Copyright (c) 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 CONTENT_BROWSER_GPU_GPU_CONTROL_LIST_H_
-#define CONTENT_BROWSER_GPU_GPU_CONTROL_LIST_H_
+#ifndef GPU_CONFIG_GPU_CONTROL_LIST_H_
+#define GPU_CONFIG_GPU_CONTROL_LIST_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "build/build_config.h"
-#include "content/common/content_export.h"
+#include "gpu/gpu_export.h"
 
-namespace content {
+namespace gpu {
 struct GPUInfo;
 
-class CONTENT_EXPORT GpuControlList {
+class GPU_EXPORT GpuControlList {
  public:
   enum OsType {
     kOsLinux,
     kOsMacosx,
     kOsWin,
     kOsChromeOS,
     kOsAndroid,
     kOsAny,
     kOsUnknown
   };
@@ skipping 79 matching lines @@
     kBetween,  // <= * <=
     kEQ,  // =
     kLT,  // <
     kLE,  // <=
     kGT,  // >
     kGE,  // >=
     kAny,
     kUnknown  // Indicates the data is invalid.
   };
 
-  class CONTENT_EXPORT VersionInfo {
+  class GPU_EXPORT VersionInfo {
    public:
     // If version_style is empty, it defaults to kNumerical.
     VersionInfo(const std::string& version_op,
                 const std::string& version_style,
                 const std::string& version_string,
                 const std::string& version_string2);
     ~VersionInfo();
 
     // Determines if a given version is included in the VersionInfo range.
     // "splitter" divides version string into segments.
@@ skipping 29 matching lines @@
     static int Compare(const std::vector<std::string>& version,
                        const std::vector<std::string>& version_ref,
                        VersionStyle version_style);
 
     NumericOp op_;
     VersionStyle version_style_;
     std::vector<std::string> version_;
     std::vector<std::string> version2_;
   };
 
-  class CONTENT_EXPORT OsInfo {
+  class GPU_EXPORT OsInfo {
    public:
     OsInfo(const std::string& os,
            const std::string& version_op,
            const std::string& version_string,
            const std::string& version_string2);
     ~OsInfo();
 
     // Determines if a given os/version is included in the OsInfo set.
     bool Contains(OsType type, const std::string& version) const;
 
     // Determines if the VersionInfo contains valid information.
     bool IsValid() const;
 
     OsType type() const;
 
     // Maps string to OsType; returns kOsUnknown if it's not a valid os.
     static OsType StringToOsType(const std::string& os);
 
    private:
     OsType type_;
     scoped_ptr<VersionInfo> version_info_;
   };
 
-  class CONTENT_EXPORT StringInfo {
+  class GPU_EXPORT StringInfo {
    public:
     StringInfo(const std::string& string_op, const std::string& string_value);
 
     // Determines if a given string is included in the StringInfo.
     bool Contains(const std::string& value) const;
 
     // Determines if the StringInfo contains valid information.
     bool IsValid() const;
 
    private:
     enum Op {
       kContains,
       kBeginWith,
       kEndWith,
       kEQ,  // =
       kUnknown  // Indicates StringInfo data is invalid.
     };
 
     // Maps string to Op; returns kUnknown if it's not a valid Op.
     static Op StringToOp(const std::string& string_op);
 
     Op op_;
     std::string value_;
   };
 
-  class CONTENT_EXPORT FloatInfo {
+  class GPU_EXPORT FloatInfo {
    public:
     FloatInfo(const std::string& float_op,
               const std::string& float_value,
               const std::string& float_value2);
 
     // Determines if a given float is included in the FloatInfo.
     bool Contains(float value) const;
 
     // Determines if the FloatInfo contains valid information.
     bool IsValid() const;
 
    private:
     NumericOp op_;
     float value_;
     float value2_;
   };
 
-  class CONTENT_EXPORT IntInfo {
+  class GPU_EXPORT IntInfo {
    public:
     IntInfo(const std::string& int_op,
             const std::string& int_value,
             const std::string& int_value2);
 
     // Determines if a given int is included in the IntInfo.
     bool Contains(int value) const;
 
     // Determines if the IntInfo contains valid information.
     bool IsValid() const;
 
    private:
     NumericOp op_;
     int value_;
     int value2_;
   };
 
-  class CONTENT_EXPORT MachineModelInfo {
+  class GPU_EXPORT MachineModelInfo {
    public:
     MachineModelInfo(const std::string& name_op,
                      const std::string& name_value,
                      const std::string& version_op,
                      const std::string& version_string,
                      const std::string& version_string2);
     ~MachineModelInfo();
 
     // Determines if a given name/version is included in the MachineModelInfo.
     bool Contains(const std::string& name, const std::string& version) const;
 
     // Determines if the MachineModelInfo contains valid information.
     bool IsValid() const;
 
    private:
     scoped_ptr<StringInfo> name_info_;
     scoped_ptr<VersionInfo> version_info_;
   };
 
   class GpuControlListEntry;
   typedef scoped_refptr<GpuControlListEntry> ScopedGpuControlListEntry;
 
   typedef base::hash_map<std::string, int> FeatureMap;
 
-  class CONTENT_EXPORT GpuControlListEntry
+  class GPU_EXPORT GpuControlListEntry
       : public base::RefCounted<GpuControlListEntry> {
    public:
     // Constructs GpuControlListEntry from DictionaryValue loaded from json.
     // Top-level entry must have an id number.  Others are exceptions.
     static ScopedGpuControlListEntry GetEntryFromValue(
         const base::DictionaryValue* value, bool top_level,
         const FeatureMap& feature_map,
         bool supports_feature_type_all);
 
     // Determines if a given os/gc/machine_model/driver is included in the
@@ skipping 189 matching lines @@
 
   bool contains_unknown_fields_;
 
   bool needs_more_info_;
 
   // The features a GpuControlList recognizes and handles.
   FeatureMap feature_map_;
   bool supports_feature_type_all_;
 };
 
-}  // namespace content
+}  // namespace gpu
 
-#endif  // CONTENT_BROWSER_GPU_GPU_CONTROL_LIST_H_
+#endif  // GPU_CONFIG_GPU_CONTROL_LIST_H_