gpu_control_list.cc | Explore in Territory

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "gpu/config/gpu_control_list.h"

#include <utility>

#include "base/json/values_util.h"
#include "base/logging.h"
#include "base/not_fatal_until.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/system/sys_info.h"
#include "base/values.h"
#include "build/build_config.h"
#include "components/crash/core/common/crash_key.h"
#include "gpu/config/gpu_util.h"
#include "third_party/re2/src/re2/re2.h"

namespace gpu {
namespace {

// Break a version string into segments.  Return true if each segment is
// a valid number, and not all segment is 0.
bool ProcessVersionString(const std::string& version_string,
                          char splitter,
                          std::vector<std::string>* version) { … }

// Compare two number strings using numerical ordering.
// Return  0 if number = number_ref,
//         1 if number > number_ref,
//        -1 if number < number_ref.
int CompareNumericalNumberStrings(
    const std::string& number, const std::string& number_ref) { … }

// Compare two number strings using lexical ordering.
// Return  0 if number = number_ref,
//         1 if number > number_ref,
//        -1 if number < number_ref.
// We only compare as many digits as number_ref contains.
// If number_ref is xxx, it's considered as xxx*
// For example: CompareLexicalNumberStrings("121", "12") returns 0,
//              CompareLexicalNumberStrings("12", "121") returns -1.
int CompareLexicalNumberStrings(
    const std::string& number, const std::string& number_ref) { … }

// A mismatch is identified only if both |input| and |pattern| are not empty.
bool StringMismatch(const std::string& input, const std::string& pattern) { … }

bool StringMismatch(const std::string& input, const char* pattern) { … }

bool ProcessANGLEGLRenderer(const std::string& gl_renderer,
                            std::string* vendor,
                            std::string* renderer,
                            std::string* version) { … }

}  // namespace

bool GpuControlList::Version::Contains(const std::string& version_string,
                                       char splitter) const { … }

// static
int GpuControlList::Version::Compare(
    const std::vector<std::string>& version,
    const std::vector<std::string>& version_ref,
    VersionStyle version_style) { … }

bool GpuControlList::More::GLVersionInfoMismatch(
    const std::string& gl_version_string) const { … }

// static
GpuControlList::GLType GpuControlList::More::GetDefaultGLType() { … }

void GpuControlList::Entry::LogControlListMatch(
    const std::string& control_list_logging_name) const { … }

bool GpuControlList::DriverInfo::Contains(
    const std::vector<GPUInfo::GPUDevice>& gpus) const { … }

bool GpuControlList::GLStrings::Contains(const GPUInfo& gpu_info) const { … }

bool GpuControlList::MachineModelInfo::Contains(const GPUInfo& gpu_info) const { … }

bool GpuControlList::More::Contains(const GPUInfo& gpu_info) const { … }

bool GpuControlList::Conditions::Contains(OsType target_os_type,
                                          const std::string& target_os_version,
                                          const GPUInfo& gpu_info) const { … }

bool GpuControlList::Entry::Contains(OsType target_os_type,
                                     const std::string& target_os_version,
                                     const GPUInfo& gpu_info) const { … }

bool GpuControlList::Entry::AppliesToTestGroup(
    uint32_t target_test_group) const { … }

bool GpuControlList::Conditions::NeedsMoreInfo(const GPUInfo& gpu_info) const { … }

bool GpuControlList::Entry::NeedsMoreInfo(const GPUInfo& gpu_info,
                                          bool consider_exceptions) const { … }

base::Value::List GpuControlList::Entry::GetFeatureNames(
    const FeatureMap& feature_map) const { … }

GpuControlList::GpuControlList(base::span<const Entry> data) : … { … }

GpuControlList::~GpuControlList() = default;

std::set<int32_t> GpuControlList::MakeDecision(GpuControlList::OsType os,
                                               const std::string& os_version,
                                               const GPUInfo& gpu_info) { … }

std::set<int32_t> GpuControlList::MakeDecision(GpuControlList::OsType os,
                                               const std::string& os_version,
                                               const GPUInfo& gpu_info,
                                               uint32_t target_test_group) { … }

const std::vector<uint32_t>& GpuControlList::GetActiveEntries() const { … }

std::vector<uint32_t> GpuControlList::GetEntryIDsFromIndices(
    const std::vector<uint32_t>& entry_indices) const { … }

std::vector<std::string> GpuControlList::GetDisabledExtensions() { … }

std::vector<std::string> GpuControlList::GetDisabledWebGLExtensions() { … }

void GpuControlList::GetReasons(base::Value::List& problem_list,
                                const std::string& tag,
                                const std::vector<uint32_t>& entries) const { … }

size_t GpuControlList::num_entries() const { … }

uint32_t GpuControlList::max_entry_id() const { … }

// static
GpuControlList::OsType GpuControlList::GetOsType() { … }

void GpuControlList::AddSupportedFeature(
    const std::string& feature_name, int feature_id) { … }

// static
bool GpuControlList::AreEntryIndicesValid(
    const std::vector<uint32_t>& entry_indices,
    size_t total_entries) { … }

}  // namespace gpu
chromium/gpu/config/gpu_control_list.cc
