kc3-lang/angle/src/feature_support_util/feature_support_util.cpp

• Show log

  Commit

• Hash : e4c64c3d
  Author :
  Date : 2018-10-17T14:53:39
  

  Implement new API/interface for the ANGLE feature-support utility.
  
  The original API is designated as version 0.  The new API is
  designated as version 1.  A new function is provided for determing the
  version of the API that can be used.
  
  Bug: angleproject:2794
  Change-Id: I8205b462522cbc34d31643ea14815e187497abed
  Reviewed-on: https://chromium-review.googlesource.com/c/1278836
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
  Commit-Queue: Ian Elliott <ianelliott@google.com>
  

Download

• src/feature_support_util/feature_support_util.cpp

• //
  // Copyright 2018 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // feature_support_util.cpp: Helps Android EGL loader to determine whether to use ANGLE or a native
  // GLES driver.  Helps ANGLE know which work-arounds to use.
  
  #include "feature_support_util.h"
  #include <json/json.h>
  #include <string.h>
  #include <unistd.h>
  #include <fstream>
  #include <list>
  
  // namespace angle_for_android
  //{
  
  #if defined(ANDROID)
  #include <android/log.h>
  
  // Define ANGLE_FEATURE_UTIL_LOG_VERBOSE if you want ALOGV to output
  // ANGLE_FEATURE_UTIL_LOG_VERBOSE is automatically defined when is_debug = true
  
  #define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, "ANGLE", __VA_ARGS__)
  #define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, "ANGLE", __VA_ARGS__)
  #define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, "ANGLE", __VA_ARGS__)
  #define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "ANGLE", __VA_ARGS__)
  #ifdef ANGLE_FEATURE_UTIL_LOG_VERBOSE
  #define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, "ANGLE", __VA_ARGS__)
  #else
  #define ALOGV(...) ((void)0)
  #endif
  #else  // defined(ANDROID)
  #define ALOGE(...) printf(__VA_ARGS__);
  #define ALOGW(...) printf(__VA_ARGS__);
  #define ALOGI(...) printf(__VA_ARGS__);
  #define ALOGD(...) printf(__VA_ARGS__);
  #define ALOGV(...) printf(__VA_ARGS__);
  #endif  // defined(ANDROID)
  
  // JSON values are generally composed of either:
  //  - Objects, which are a set of comma-separated string:value pairs (note the recursive nature)
  //  - Arrays, which are a set of comma-separated values.
  // We'll call the string in a string:value pair the "identifier".  These identifiers are defined
  // below, as follows:
  
  // The JSON identifier for the top-level set of rules.  This is an object, the value of which is an
  // array of rules.  The rules will be processed in order.  For any given type of answer, if a rule
  // matches, the rule's version of the answer (true or false) becomes the new answer.  After all
  // rules are processed, the most-recent answer is the final answer.
  constexpr char kJsonRules[] = "Rules";
  // The JSON identifier for a given rule.  A rule is an object, the first string:value pair is this
  // identifier (i.e. "Rule") as the string and a user-firendly description of the rule:
  constexpr char kJsonRule[] = "Rule";
  // Within a rule, the JSON identifier for one type of answer--whether to allow an application to
  // specify whether to use ANGLE.  The value is a boolean (i.e. true or false), with true allowing
  // the application to specify whether or not to use ANGLE.
  constexpr char kJsonAppChoice[] = "AppChoice";
  // Within a rule, the JSON identifier for one type of answer--whether or not to use ANGLE when an
  // application doesn't specify (or isn't allowed to specify) whether or not to use ANGLE.  The
  // value is a boolean (i.e. true or false).
  constexpr char kJsonNonChoice[] = "NonChoice";
  
  // Within a rule, the JSON identifier for describing one or more applications.  The value is an
  // array of objects, each object of which can specify attributes of an application.
  constexpr char kJsonApplications[] = "Applications";
  // Within an object that describes the attributes of an application, the JSON identifier for the
  // name of the application (e.g. "com.google.maps").  The value is a string.  If any other
  // attributes will be specified, this must be the first attribute specified in the object.
  constexpr char kJsonAppName[] = "AppName";
  // Within an object that describes the attributes of an application, the JSON identifier for the
  // intent of the application to run.  The value is a string.
  constexpr char kJsonIntent[] = "Intent";
  
  // Within a rule, the JSON identifier for describing one or more devices.  The value is an
  // array of objects, each object of which can specify attributes of a device.
  constexpr char kJsonDevices[] = "Devices";
  // Within an object that describes the attributes of a device, the JSON identifier for the
  // manufacturer of the device.  The value is a string.  If any other attributes will be specified,
  // this must be the first attribute specified in the object.
  constexpr char kJsonManufacturer[] = "Manufacturer";
  // Within an object that describes the attributes of a device, the JSON identifier for the
  // model of the device.  The value is a string.
  constexpr char kJsonModel[] = "Model";
  
  // Within an object that describes the attributes of a device, the JSON identifier for describing
  // one or more GPUs/drivers used in the device.  The value is an
  // array of objects, each object of which can specify attributes of a GPU and its driver.
  constexpr char kJsonGPUs[] = "GPUs";
  // Within an object that describes the attributes of a GPU and driver, the JSON identifier for the
  // vendor of the device/driver.  The value is a string.  If any other attributes will be specified,
  // this must be the first attribute specified in the object.
  constexpr char kJsonvendor[] = "vendor";
  // Within an object that describes the attributes of a GPU and driver, the JSON identifier for the
  // deviceId of the device.  The value is an unsigned integer.  If the driver version will be
  // specified, this must preceded the version attributes specified in the object.
  constexpr char kJsondeviceId[] = "deviceId";
  
  // Within an object that describes the attributes of either an application or a GPU, the JSON
  // identifier for the major version of that application or GPU driver.  The value is a positive
  // integer number.  Not specifying a major version implies a wildcard for all values of a version.
  constexpr char kJsonVerMajor[] = "VerMajor";
  // Within an object that describes the attributes of either an application or a GPU, the JSON
  // identifier for the minor version of that application or GPU driver.  The value is a positive
  // integer number.  In order to specify a minor version, it must be specified immediately after the
  // major number associated with it.  Not specifying a minor version implies a wildcard for the
  // minor, subminor, and patch values of a version.
  constexpr char kJsonVerMinor[] = "VerMinor";
  // Within an object that describes the attributes of either an application or a GPU, the JSON
  // identifier for the subminor version of that application or GPU driver.  The value is a positive
  // integer number.  In order to specify a subminor version, it must be specified immediately after
  // the minor number associated with it.  Not specifying a subminor version implies a wildcard for
  // the subminor and patch values of a version.
  constexpr char kJsonVerSubMinor[] = "VerSubMinor";
  // Within an object that describes the attributes of either an application or a GPU, the JSON
  // identifier for the patch version of that application or GPU driver.  The value is a positive
  // integer number.  In order to specify a patch version, it must be specified immediately after the
  // subminor number associated with it.  Not specifying a patch version implies a wildcard for the
  // patch value of a version.
  constexpr char kJsonVerPatch[] = "VerPatch";
  
  // This encapsulates a std::string.  The default constructor (not given a string) assumes that this
  // is a wildcard (i.e. will match all other StringPart objects).
  class StringPart
  {
    public:
      StringPart() : mPart(""), mWildcard(true) {}
      StringPart(std::string part) : mPart(part), mWildcard(false) {}
      ~StringPart() {}
      bool match(StringPart &toCheck)
      {
          return (mWildcard || toCheck.mWildcard || (toCheck.mPart == mPart));
      }
  
    public:
      std::string mPart;
      bool mWildcard;
  };
  
  // This encapsulates a 32-bit unsigned integer.  The default constructor (not given a number)
  // assumes that this is a wildcard (i.e. will match all other IntegerPart objects).
  class IntegerPart
  {
    public:
      IntegerPart() : mPart(0), mWildcard(true) {}
      IntegerPart(uint32_t part) : mPart(part), mWildcard(false) {}
      ~IntegerPart() {}
      bool match(IntegerPart &toCheck)
      {
          return (mWildcard || toCheck.mWildcard || (toCheck.mPart == mPart));
      }
  
    public:
      uint32_t mPart;
      bool mWildcard;
  };
  
  // This encapsulates a list of other classes, which of which will have a match() method.  The
  // common constructor (given a type, but not any list items) assumes that this is a wildcard
  // (i.e. will match all other ListOf<t> objects).
  template <class T>
  class ListOf
  {
    public:
      ListOf(std::string listType) : mListType(listType), mWildcard(true) {}
      ~ListOf() {}
      void addItem(T &toAdd)
      {
          mList.push_back(toAdd);
          mWildcard = false;
      }
      bool match(T &toCheck)
      {
          ALOGV("\t\t Within ListOf<%s> match: wildcards are %s and %s,\n", mListType.c_str(),
                mWildcard ? "true" : "false", toCheck.mWildcard ? "true" : "false");
          if (mWildcard || toCheck.mWildcard)
          {
              return true;
          }
          for (auto &it : mList)
          {
              ALOGV("\t\t   Within ListOf<%s> match: calling match on sub-item is %s,\n",
                    mListType.c_str(), it.match(toCheck) ? "true" : "false");
              if (it.match(toCheck))
              {
                  return true;
              }
          }
          return false;
      }
      T &front() { return (mList.front()); }
      void logListOf(std::string prefix, std::string name)
      {
          if (mWildcard)
          {
              ALOGV("%sListOf%s is wildcarded to always match", prefix.c_str(), name.c_str());
          }
          else
          {
              ALOGV("%sListOf%s is has %d item(s):", prefix.c_str(), name.c_str(),
                    static_cast<int>(mList.size()));
              for (auto &it : mList)
              {
                  it.logItem();
              }
          }
      }
  
    private:
      std::string mListType;
      std::list<T> mList;
  
    public:
      bool mWildcard = true;
  };
  
  // This encapsulates up-to four 32-bit unsigned integers, that represent a potentially-complex
  // version number.  The default constructor (not given any numbers) assumes that this is a wildcard
  // (i.e. will match all other Version objects).  Each part of a Version is stored in an IntegerPart
  // class, and so may be wildcarded as well.
  class Version
  {
    public:
      Version(uint32_t major, uint32_t minor, uint32_t subminor, uint32_t patch)
          : mMajor(major), mMinor(minor), mSubminor(subminor), mPatch(patch), mWildcard(false)
      {
      }
      Version(uint32_t major, uint32_t minor, uint32_t subminor)
          : mMajor(major), mMinor(minor), mSubminor(subminor), mWildcard(false)
      {
      }
      Version(uint32_t major, uint32_t minor) : mMajor(major), mMinor(minor), mWildcard(false) {}
      Version(uint32_t major) : mMajor(major), mWildcard(false) {}
      Version() : mWildcard(true) {}
      Version(const Version &toCopy)
          : mMajor(toCopy.mMajor),
            mMinor(toCopy.mMinor),
            mSubminor(toCopy.mSubminor),
            mPatch(toCopy.mPatch),
            mWildcard(toCopy.mWildcard)
      {
      }
      ~Version() {}
      bool match(Version &toCheck)
      {
          ALOGV("\t\t\t Within Version %d,%d,%d,%d match(%d,%d,%d,%d): wildcards are %s and %s,\n",
                mMajor.mPart, mMinor.mPart, mSubminor.mPart, mPatch.mPart, toCheck.mMajor.mPart,
                toCheck.mMinor.mPart, toCheck.mSubminor.mPart, toCheck.mPatch.mPart,
                mWildcard ? "true" : "false", toCheck.mWildcard ? "true" : "false");
          if (!(mWildcard || toCheck.mWildcard))
          {
              ALOGV("\t\t\t   mMajor match is %s, mMinor is %s, mSubminor is %s, mPatch is %s\n",
                    mMajor.match(toCheck.mMajor) ? "true" : "false",
                    mMinor.match(toCheck.mMinor) ? "true" : "false",
                    mSubminor.match(toCheck.mSubminor) ? "true" : "false",
                    mPatch.match(toCheck.mPatch) ? "true" : "false");
          }
          return (mWildcard || toCheck.mWildcard ||
                  (mMajor.match(toCheck.mMajor) && mMinor.match(toCheck.mMinor) &&
                   mSubminor.match(toCheck.mSubminor) && mPatch.match(toCheck.mPatch)));
      }
      static Version *CreateVersionFromJson(Json::Value &jObject)
      {
          Version *version = nullptr;
          // A major version must be provided before a minor, and so on:
          if (jObject.isMember(kJsonVerMajor) && jObject[kJsonVerMajor].isInt())
          {
              int major = jObject[kJsonVerMajor].asInt();
              if (jObject.isMember(kJsonVerMinor) && jObject[kJsonVerMinor].isInt())
              {
                  int minor = jObject[kJsonVerMinor].asInt();
                  if (jObject.isMember(kJsonVerSubMinor) && jObject[kJsonVerSubMinor].isInt())
                  {
                      int subMinor = jObject[kJsonVerSubMinor].asInt();
                      if (jObject.isMember(kJsonVerPatch) && jObject[kJsonVerPatch].isInt())
                      {
                          int patch = jObject[kJsonVerPatch].asInt();
                          version   = new Version(major, minor, subMinor, patch);
                      }
                      else
                      {
                          version = new Version(major, minor, subMinor);
                      }
                  }
                  else
                  {
                      version = new Version(major, minor);
                  }
              }
              else
              {
                  version = new Version(major);
              }
          }
          // TODO (ianelliott@) (b/113346561) appropriately destruct lists and
          // other items that get created from json parsing
          return version;
      }
      std::string getString()
      {
          if (mWildcard)
          {
              return "*";
          }
          else
          {
              char ret[100];
              // Must at least have a major version:
              if (!mMinor.mWildcard)
              {
                  if (!mSubminor.mWildcard)
                  {
                      if (!mPatch.mWildcard)
                      {
                          snprintf(ret, 100, "%d.%d.%d.%d", mMajor.mPart, mMinor.mPart,
                                   mSubminor.mPart, mPatch.mPart);
                      }
                      else
                      {
                          snprintf(ret, 100, "%d.%d.%d.*", mMajor.mPart, mMinor.mPart,
                                   mSubminor.mPart);
                      }
                  }
                  else
                  {
                      snprintf(ret, 100, "%d.%d.*", mMajor.mPart, mMinor.mPart);
                  }
              }
              else
              {
                  snprintf(ret, 100, "%d.*", mMajor.mPart);
              }
              std::string retString = ret;
              return retString;
          }
      }
  
    public:
      IntegerPart mMajor;
      IntegerPart mMinor;
      IntegerPart mSubminor;
      IntegerPart mPatch;
      bool mWildcard;
  };
  
  // This encapsulates an application, and potentially the application's Version and/or the intent
  // that it is launched with.  The default constructor (not given any values) assumes that this is a
  // wildcard (i.e. will match all other Application objects).  Each part of an Application is stored
  // in a class that may also be wildcarded.
  class Application
  {
    public:
      Application(std::string name, Version &version, std::string intent)
          : mName(name), mVersion(version), mIntent(intent), mWildcard(false)
      {
      }
      Application(std::string name, std::string intent)
          : mName(name), mVersion(), mIntent(intent), mWildcard(false)
      {
      }
      Application(std::string name, Version &version)
          : mName(name), mVersion(version), mIntent(), mWildcard(false)
      {
      }
      Application(std::string name) : mName(name), mVersion(), mIntent(), mWildcard(false) {}
      Application() : mName(), mVersion(), mIntent(), mWildcard(true) {}
      ~Application() {}
      bool match(Application &toCheck)
      {
          return (mWildcard || toCheck.mWildcard ||
                  (toCheck.mName.match(mName) && toCheck.mVersion.match(mVersion) &&
                   toCheck.mIntent.match(mIntent)));
      }
      static Application *CreateApplicationFromJson(Json::Value &jObject)
      {
          Application *application = nullptr;
  
          // If an application is listed, the application's name is required:
          std::string appName = jObject[kJsonAppName].asString();
  
          // The application's version and intent are optional:
          Version *version = Version::CreateVersionFromJson(jObject);
          if (version)
          {
              if (jObject.isMember(kJsonIntent) && jObject[kJsonIntent].isString())
              {
                  application = new Application(appName, *version, jObject[kJsonIntent].asString());
              }
              else
              {
                  application = new Application(appName, *version);
              }
          }
          else
          {
              if (jObject.isMember(kJsonIntent) && jObject[kJsonIntent].isString())
              {
                  application = new Application(appName, jObject[kJsonIntent].asString());
              }
              else
              {
                  application = new Application(appName);
              }
          }
          // TODO (ianelliott@) (b/113346561) appropriately destruct lists and
          // other items that get created from json parsing
          return application;
      }
      void logItem()
      {
          if (mWildcard)
          {
              ALOGV("      Wildcard (i.e. will match all applications)");
          }
          else if (!mVersion.mWildcard)
          {
              if (!mIntent.mWildcard)
              {
                  ALOGV("      Application \"%s\" (version: %s; intent: \"%s\")", mName.mPart.c_str(),
                        mVersion.getString().c_str(), mIntent.mPart.c_str());
              }
              else
              {
                  ALOGV("      Application \"%s\" (version: %s)", mName.mPart.c_str(),
                        mVersion.getString().c_str());
              }
          }
          else if (!mIntent.mWildcard)
          {
              ALOGV("      Application \"%s\" (intent: \"%s\")", mName.mPart.c_str(),
                    mIntent.mPart.c_str());
          }
          else
          {
              ALOGV("      Application \"%s\"", mName.mPart.c_str());
          }
      }
  
    public:
      StringPart mName;
      Version mVersion;
      StringPart mIntent;
      bool mWildcard;
  };
  
  // This encapsulates a GPU and its driver.  The default constructor (not given any values) assumes
  // that this is a wildcard (i.e. will match all other GPU objects).  Each part of a GPU is stored
  // in a class that may also be wildcarded.
  class GPU
  {
    public:
      GPU(std::string vendor, uint32_t deviceId, Version &version)
          : mVendor(vendor), mDeviceId(IntegerPart(deviceId)), mVersion(version), mWildcard(false)
      {
      }
      GPU(uint32_t deviceId, Version &version)
          : mVendor(), mDeviceId(IntegerPart(deviceId)), mVersion(version), mWildcard(false)
      {
      }
      GPU(std::string vendor, uint32_t deviceId)
          : mVendor(vendor), mDeviceId(IntegerPart(deviceId)), mVersion(), mWildcard(false)
      {
      }
      GPU(std::string vendor) : mVendor(vendor), mDeviceId(), mVersion(), mWildcard(false) {}
      GPU(uint32_t deviceId)
          : mVendor(), mDeviceId(IntegerPart(deviceId)), mVersion(), mWildcard(false)
      {
      }
      GPU() : mVendor(), mDeviceId(), mVersion(), mWildcard(true) {}
      bool match(GPU &toCheck)
      {
          ALOGV("\t\t Within GPU match: wildcards are %s and %s,\n", mWildcard ? "true" : "false",
                toCheck.mWildcard ? "true" : "false");
          ALOGV("\t\t   mVendor = \"%s\" and toCheck.mVendor = \"%s\"\n", mVendor.mPart.c_str(),
                toCheck.mVendor.mPart.c_str());
          ALOGV("\t\t   mDeviceId = %d and toCheck.mDeviceId = %d\n", mDeviceId.mPart,
                toCheck.mDeviceId.mPart);
          ALOGV("\t\t   mVendor match is %s, mDeviceId is %s, mVersion is %s\n",
                toCheck.mVendor.match(mVendor) ? "true" : "false",
                toCheck.mDeviceId.match(mDeviceId) ? "true" : "false",
                toCheck.mVersion.match(mVersion) ? "true" : "false");
          return (mWildcard || toCheck.mWildcard ||
                  (toCheck.mVendor.match(mVendor) && toCheck.mDeviceId.match(mDeviceId) &&
                   toCheck.mVersion.match(mVersion)));
      }
      ~GPU() {}
      static GPU *CreateGpuFromJson(Json::Value &jObject)
      {
          GPU *gpu = nullptr;
  
          // If a GPU is listed, the vendor name is required:
          if (jObject.isMember(kJsonvendor) && jObject[kJsonvendor].isString())
          {
              std::string vendor = jObject[kJsonvendor].asString();
              // If a version is given, the deviceId is required:
              if (jObject.isMember(kJsondeviceId) && jObject[kJsondeviceId].isUInt())
              {
                  uint32_t deviceId = jObject[kJsondeviceId].asUInt();
                  Version *version  = Version::CreateVersionFromJson(jObject);
                  if (version)
                  {
                      gpu = new GPU(vendor, deviceId, *version);
                  }
                  else
                  {
                      gpu = new GPU(vendor, deviceId);
                  }
              }
              else
              {
                  gpu = new GPU(vendor);
              }
          }
          else
          {
              ALOGW("Asked to parse a GPU, but no GPU found");
          }
  
          // TODO (ianelliott@) (b/113346561) appropriately destruct lists and
          // other items that get created from json parsing
          return gpu;
      }
      void logItem()
      {
          if (mWildcard)
          {
              ALOGV("          Wildcard (i.e. will match all GPUs)");
          }
          else
          {
              if (!mDeviceId.mWildcard)
              {
                  if (!mVersion.mWildcard)
                  {
                      ALOGV("\t     GPU vendor: %s, deviceId: 0x%x, version: %s",
                            mVendor.mPart.c_str(), mDeviceId.mPart, mVersion.getString().c_str());
                  }
                  else
                  {
                      ALOGV("\t     GPU vendor: %s, deviceId: 0x%x", mVendor.mPart.c_str(),
                            mDeviceId.mPart);
                  }
              }
              else
              {
                  ALOGV("\t     GPU vendor: %s", mVendor.mPart.c_str());
              }
          }
      }
  
    public:
      StringPart mVendor;
      IntegerPart mDeviceId;
      Version mVersion;
      bool mWildcard;
  };
  
  // This encapsulates a device, and potentially the device's model and/or a list of GPUs/drivers
  // associated with the Device.  The default constructor (not given any values) assumes that this is
  // a wildcard (i.e. will match all other Device objects).  Each part of a Device is stored in a
  // class that may also be wildcarded.
  class Device
  {
    public:
      Device(std::string manufacturer, std::string model)
          : mManufacturer(manufacturer), mModel(model), mGpuList("GPU"), mWildcard(false)
      {
      }
      Device(std::string manufacturer)
          : mManufacturer(manufacturer), mModel(), mGpuList("GPU"), mWildcard(false)
      {
      }
      Device() : mManufacturer(), mModel(), mGpuList("GPU"), mWildcard(true) {}
      ~Device() {}
      void addGPU(GPU &gpu) { mGpuList.addItem(gpu); }
      bool match(Device &toCheck)
      {
          ALOGV("\t Within Device match: wildcards are %s and %s,\n", mWildcard ? "true" : "false",
                toCheck.mWildcard ? "true" : "false");
          if (!(mWildcard || toCheck.mWildcard))
          {
              ALOGV("\t   Manufacturer match is %s, model is %s\n",
                    toCheck.mManufacturer.match(mManufacturer) ? "true" : "false",
                    toCheck.mModel.match(mModel) ? "true" : "false");
          }
          ALOGV("\t   Need to check ListOf<GPU>\n");
          return ((mWildcard || toCheck.mWildcard ||
                   // The wildcards can override the Manufacturer/Model check, but not the GPU check
                   (toCheck.mManufacturer.match(mManufacturer) && toCheck.mModel.match(mModel))) &&
                  // Note: toCheck.mGpuList is for the device and must contain exactly one item,
                  // where mGpuList may contain zero or more items:
                  mGpuList.match(toCheck.mGpuList.front()));
      }
      static Device *CreateDeviceFromJson(Json::Value &jObject)
      {
          Device *device = nullptr;
          if (jObject.isMember(kJsonManufacturer) && jObject[kJsonManufacturer].isString())
          {
              std::string manufacturerName = jObject[kJsonManufacturer].asString();
              // We don't let a model be specified without also specifying an Manufacturer:
              if (jObject.isMember(kJsonModel) && jObject[kJsonModel].isString())
              {
                  std::string model = jObject[kJsonModel].asString();
                  device            = new Device(manufacturerName, model);
              }
              else
              {
                  device = new Device(manufacturerName);
              }
          }
          else
          {
              // This case is not treated as an error because a rule may wish to only call out one or
              // more GPUs, and not any specific Manufacturer devices:
              device = new Device();
          }
          // TODO (ianelliott@) (b/113346561) appropriately destruct lists and
          // other items that get created from json parsing
          return device;
      }
      void logItem()
      {
          if (mWildcard)
          {
              if (mGpuList.mWildcard)
              {
                  ALOGV("      Wildcard (i.e. will match all devices)");
                  return;
              }
              else
              {
                  ALOGV(
                      "      Device with any manufacturer and model"
                      ", and with the following GPUs:");
              }
          }
          else
          {
              if (!mModel.mWildcard)
              {
                  ALOGV(
                      "      Device manufacturer: \"%s\" and model \"%s\""
                      ", and with the following GPUs:",
                      mManufacturer.mPart.c_str(), mModel.mPart.c_str());
              }
              else
              {
                  ALOGV(
                      "      Device manufacturer: \"%s\""
                      ", and with the following GPUs:",
                      mManufacturer.mPart.c_str());
              }
          }
          mGpuList.logListOf("        ", "GPUs");
      }
  
    public:
      StringPart mManufacturer;
      StringPart mModel;
      ListOf<GPU> mGpuList;
      bool mWildcard;
  };
  
  // This encapsulates a particular scenario to check against the rules.  A Scenario is similar to a
  // Rule, except that a Rule has answers and potentially many wildcards, and a Scenario is the
  // fully-specified combination of an Application and a Device that is proposed to be run with
  // ANGLE.  It is compared with the list of Rules.
  class Scenario
  {
    public:
      Scenario(const char *appName, const char *deviceMfr, const char *deviceModel)
          : mApplication(Application(appName)), mDevice(Device(deviceMfr, deviceModel))
      {
      }
      ~Scenario() {}
      void logScenario()
      {
          ALOGV("  Scenario to compare against the rules");
          ALOGV("    Application:");
          mApplication.logItem();
          ALOGV("    Device:");
          mDevice.logItem();
      }
  
    public:
      Application mApplication;
      Device mDevice;
  
    private:
      Scenario(Application &app, Device &dev) : mApplication(app), mDevice(dev) {}
      Scenario() : mApplication(), mDevice() {}
  };
  
  // This encapsulates a Rule that provides answers based on whether a particular Scenario matches
  // the Rule.  A Rule always has answers, but can potentially wildcard every item in it (i.e. match
  // every scenario).
  class Rule
  {
    public:
      Rule(std::string description, bool appChoice, bool answer)
          : mDescription(description),
            mAppList("Application"),
            mDevList("Device"),
            mAppChoice(appChoice),
            mAnswer(answer)
      {
      }
      ~Rule() {}
      void addApp(Application &app) { mAppList.addItem(app); }
      void addDev(Device &dev) { mDevList.addItem(dev); }
      bool match(Scenario &toCheck)
      {
          ALOGV("    Within \"%s\" Rule: application match is %s and device match is %s\n",
                mDescription.c_str(), mAppList.match(toCheck.mApplication) ? "true" : "false",
                mDevList.match(toCheck.mDevice) ? "true" : "false");
          return (mAppList.match(toCheck.mApplication) && mDevList.match(toCheck.mDevice));
      }
      bool getAppChoice() { return mAppChoice; }
      bool getAnswer() { return mAnswer; }
      void logRule()
      {
          ALOGV("  Rule: \"%s\" %s ANGLE, and %s the app a choice if matched", mDescription.c_str(),
                mAnswer ? "enables" : "disables", mAppChoice ? "does give" : "does NOT give");
          mAppList.logListOf("    ", "Applications");
          mDevList.logListOf("    ", "Devices");
      }
  
    public:
      std::string mDescription;
      ListOf<Application> mAppList;
      ListOf<Device> mDevList;
      bool mAppChoice;
      bool mAnswer;
  
    private:
      Rule()
          : mDescription(),
            mAppList("Application"),
            mDevList("Device"),
            mAppChoice(false),
            mAnswer(false)
      {
      }
  };
  
  // This encapsulates a list of Rules that Scenarios are matched against.  A Scenario is compared
  // with each Rule, in order.  Any time a Scenario matches a Rule, the current answer is overridden
  // with the answer of the matched Rule.
  class RuleList
  {
    public:
      RuleList() {}
      ~RuleList() {}
      void addRule(Rule &rule) { mRuleList.push_back(rule); }
      bool getAppChoice(Scenario &toCheck)
      {
          // Initialize the choice to the system-wide default (that should be set in the default
          // rule, but just in case, set it here too):
          bool appChoice = true;
          ALOGV("Checking scenario against %d ANGLE-for-Android rules:",
                static_cast<int>(mRuleList.size()));
  
          for (auto &it : mRuleList)
          {
              ALOGV("  Checking Rule: \"%s\" (to see whether there's a match)",
                    it.mDescription.c_str());
              if (it.match(toCheck))
              {
                  ALOGV("  -> Rule matches.  Setting the app choice to %s",
                        it.getAppChoice() ? "true" : "false");
                  appChoice = it.getAppChoice();
              }
              else
              {
                  ALOGV("  -> Rule doesn't match.");
              }
          }
  
          return appChoice;
      }
      bool getAnswer(Scenario &toCheck)
      {
          // Initialize the answer to the system-wide default (that should be set in the default
          // rule, but just in case, set it here too):
          bool answer = false;
          ALOGV("Checking scenario against %d ANGLE-for-Android rules:",
                static_cast<int>(mRuleList.size()));
  
          for (auto &it : mRuleList)
          {
              ALOGV("  Checking Rule: \"%s\" (to see whether there's a match)",
                    it.mDescription.c_str());
              if (it.match(toCheck))
              {
                  ALOGV("  -> Rule matches.  Setting the answer to %s",
                        it.getAnswer() ? "true" : "false");
                  answer = it.getAnswer();
              }
              else
              {
                  ALOGV("  -> Rule doesn't match.");
              }
          }
  
          return answer;
      }
      static RuleList *ReadRulesFromJsonString(std::string jsonFileContents)
      {
          RuleList *rules = new RuleList;
  
          // Open the file and start parsing it:
          using namespace std;
          Json::Reader jReader;
          Json::Value jTopLevelObject;
          jReader.parse(jsonFileContents, jTopLevelObject);
          Json::Value jRules = jTopLevelObject[kJsonRules];
          for (unsigned int i = 0; i < jRules.size(); i++)
          {
              Json::Value jRule           = jRules[i];
              std::string ruleDescription = jRule[kJsonRule].asString();
              bool ruleAppChoice          = jRule[kJsonAppChoice].asBool();
              bool ruleAnswer             = jRule[kJsonNonChoice].asBool();
              // TODO (ianelliott@) (b/113346561) appropriately destruct lists and
              // other items that get created from json parsing
              Rule *newRule = new Rule(ruleDescription, ruleAppChoice, ruleAnswer);
  
              Json::Value jApps = jRule[kJsonApplications];
              for (unsigned int j = 0; j < jApps.size(); j++)
              {
                  Json::Value jApp    = jApps[j];
                  Application *newApp = Application::CreateApplicationFromJson(jApp);
                  // TODO (ianelliott@) (b/113346561) appropriately destruct lists and
                  // other items that get created from json parsing
                  newRule->addApp(*newApp);
              }
  
              Json::Value jDevs = jRule[kJsonDevices];
              for (unsigned int j = 0; j < jDevs.size(); j++)
              {
                  Json::Value jDev = jDevs[j];
                  Device *newDev   = Device::CreateDeviceFromJson(jDev);
  
                  Json::Value jGPUs = jDev[kJsonGPUs];
                  for (unsigned int k = 0; k < jGPUs.size(); k++)
                  {
                      Json::Value jGPU = jGPUs[k];
                      GPU *newGPU      = GPU::CreateGpuFromJson(jGPU);
                      if (newGPU)
                      {
                          newDev->addGPU(*newGPU);
                      }
                  }
                  newRule->addDev(*newDev);
              }
  
              // TODO: Need to manage memory
              rules->addRule(*newRule);
          }
  
          // Make sure there is at least one, default rule.  If not, add it here:
          int nRules = rules->mRuleList.size();
          if (nRules == 0)
          {
              Rule defaultRule("Default Rule", true, false);
              rules->addRule(defaultRule);
          }
          return rules;
      }
      void logRules()
      {
          ALOGV("Showing %d ANGLE-for-Android rules:", static_cast<int>(mRuleList.size()));
          for (auto &it : mRuleList)
          {
              it.logRule();
          }
      }
  
    public:
      std::list<Rule> mRuleList;
  };
  
  //}  // namespace angle_for_android
  
  extern "C" {
  
  // using namespace angle_for_android;
  
  ANGLE_EXPORT bool ANGLEUseForApplication(const char *appName,
                                           const char *deviceMfr,
                                           const char *deviceModel,
                                           ANGLEPreference developerOption,
                                           ANGLEPreference appPreference)
  {
      Scenario scenario(appName, deviceMfr, deviceModel);
      bool rtn        = false;
      scenario.logScenario();
  
      // #include the contents of the file into a string and then parse it:
      using namespace std;
      // Embed the rules file contents into a string:
      const char *s =
  #include "a4a_rules.json"
          ;
      std::string jsonFileContents = s;
      RuleList *rules              = RuleList::ReadRulesFromJsonString(jsonFileContents);
      rules->logRules();
  
      if (developerOption != ANGLE_NO_PREFERENCE)
      {
          rtn = (developerOption == ANGLE_PREFER_ANGLE);
      }
      else if ((appPreference != ANGLE_NO_PREFERENCE) && rules->getAppChoice(scenario))
      {
          rtn = (appPreference == ANGLE_PREFER_ANGLE);
      }
      else
      {
          rtn = rules->getAnswer(scenario);
      }
      ALOGV("Application \"%s\" should %s ANGLE", appName, rtn ? "use" : "NOT use");
      delete rules;
      return rtn;
  }
  
  ANGLE_EXPORT bool ANGLEGetUtilityAPI(unsigned int *versionToUse)
  {
      if (*versionToUse >= kFeatureVersion_LowestSupported)
      {
          if (*versionToUse <= kFeatureVersion_HighestSupported)
          {
              // This versionToUse is valid, and doesn't need to be changed.
              return true;
          }
          else
          {
              // The versionToUse is greater than the highest version supported; change it to the
              // highest version supported (caller will decide if it can use that version).
              *versionToUse = kFeatureVersion_HighestSupported;
              return true;
          }
      }
      else
      {
          // The versionToUse is less than the lowest version supported, which is an error.
          return false;
      }
  }
  
  ANGLE_EXPORT bool AndroidUseANGLEForApplication(int rules_fd,
                                                  long rules_offset,
                                                  long rules_length,
                                                  const char *appName,
                                                  const char *deviceMfr,
                                                  const char *deviceModel)
  {
      Scenario scenario(appName, deviceMfr, deviceModel);
      bool rtn = false;
      scenario.logScenario();
  
      // Read the contents of the file into a string and then parse it:
      if (rules_fd < 0)
      {
          ALOGW("Asked to read a non-open JSON file");
          return rtn;
      }
      off_t fileSize       = rules_length;
      off_t startOfContent = rules_offset;
      // This is temporary magic--while there's extra stuff at the start of the file
      // (so that it can be #include'd into the source code):
      startOfContent += 8;
      fileSize -= (8 + 7 + 2);
      lseek(rules_fd, startOfContent, SEEK_SET);
      char *buffer                 = new char[fileSize + 1];
      ssize_t numBytesRead         = read(rules_fd, buffer, fileSize);
      buffer[numBytesRead]         = '\0';
      std::string jsonFileContents = std::string(buffer);
      delete[] buffer;
      RuleList *rules = RuleList::ReadRulesFromJsonString(jsonFileContents);
      rules->logRules();
  
      rtn = rules->getAnswer(scenario);
      ALOGV("Application \"%s\" should %s ANGLE", appName, rtn ? "use" : "NOT use");
  
      delete rules;
      return rtn;
  }
  
  }  // extern "C"
  

Download