1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112


gpu / config / gpu_driver_bug_list.cc [blame]

// 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.

#include "gpu/config/gpu_driver_bug_list.h"

#include "base/check_op.h"
#include "gpu/config/gpu_driver_bug_list_autogen.h"
#include "gpu/config/gpu_driver_bug_workaround_type.h"
#include "gpu/config/gpu_switches.h"
#include "gpu/config/gpu_util.h"

namespace gpu {

namespace {

struct GpuDriverBugWorkaroundInfo {
  GpuDriverBugWorkaroundType type;
  const char* name;
};

const std::array<GpuDriverBugWorkaroundInfo,
                 NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES>
    kFeatureList = {{
#define GPU_OP(type, name) { type, #name },
        GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
#undef GPU_OP
    }};

}  // namespace anonymous

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

GpuDriverBugList::~GpuDriverBugList() = default;

// static
std::unique_ptr<GpuDriverBugList> GpuDriverBugList::Create() {
  return Create(GetGpuDriverBugListEntries());
}

// static
std::unique_ptr<GpuDriverBugList> GpuDriverBugList::Create(
    base::span<const GpuControlList::Entry> data) {
  std::unique_ptr<GpuDriverBugList> list(new GpuDriverBugList(data));

  DCHECK_EQ(NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES, kFeatureList.size());
  for (const auto& feature : kFeatureList) {
    list->AddSupportedFeature(feature.name, feature.type);
  }
  return list;
}

std::string GpuDriverBugWorkaroundTypeToString(
    GpuDriverBugWorkaroundType type) {
  if (type < NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES)
    return kFeatureList[type].name;
  else
    return "unknown";
}

// static
void GpuDriverBugList::AppendWorkaroundsFromCommandLine(
    std::set<int>* workarounds,
    const base::CommandLine& command_line) {
  DCHECK(workarounds);
  for (const auto& feature : kFeatureList) {
    if (command_line.HasSwitch(feature.name)) {
      // Check for disabling workaround flag.
      if (command_line.GetSwitchValueASCII(feature.name) == "0") {
        workarounds->erase(feature.type);
        continue;
      }

      // Removing conflicting workarounds.
      switch (feature.type) {
        case FORCE_HIGH_PERFORMANCE_GPU:
          workarounds->erase(FORCE_LOW_POWER_GPU);
          workarounds->insert(FORCE_HIGH_PERFORMANCE_GPU);
          break;
        case FORCE_LOW_POWER_GPU:
          workarounds->erase(FORCE_HIGH_PERFORMANCE_GPU);
          workarounds->insert(FORCE_LOW_POWER_GPU);
          break;
        default:
          workarounds->insert(feature.type);
          break;
      }
    }
  }
}

// static
void GpuDriverBugList::AppendAllWorkarounds(
    std::vector<const char*>* workarounds) {
  DCHECK_EQ(NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES, kFeatureList.size());
  DCHECK(workarounds->empty());
  workarounds->resize(NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES);
  size_t i = 0;
  for (const auto& feature : kFeatureList) {
    (*workarounds)[i++] = feature.name;
  }
}

// static
bool GpuDriverBugList::AreEntryIndicesValid(
    const std::vector<uint32_t>& entry_indices) {
  return GpuControlList::AreEntryIndicesValid(
      entry_indices, GetGpuDriverBugListEntries().size());
}

}  // namespace gpu