dawn_native: Add Instance and Adapters

New objects are introduced to control what happens before device
creation in dawn_native:
 - Instance: a connection from the application to dawn_native that is
used for dependency injection and to discover adapters.
 - Adapters: represents the possibility of device creation for a specific
(GPU, backend) pair.
 - BackendConnection: an internal object that standardizes the interface
between the frontend and backends.

The BackendConnection interface is implemented for the Null backend and
stubbed out in other backends. This allows this change to port the
ValidationTests to use the new Instance and Adapters concept and deal
with other backends later.

BUG=dawn:29

Change-Id: I19719a9342b4af091accc0c02fb6b9697eadde7b
Reviewed-on: https://dawn-review.googlesource.com/c/3500
Reviewed-by: Stephen White <senorblanco@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>

src/include/dawn_native/DawnNative.h

@@ -19,14 +19,75 @@
 #include <dawn_native/dawn_native_export.h>
 
 #include <string>
+#include <vector>
 
 namespace dawn_native {
+
     struct PCIInfo {
         uint32_t deviceId = 0;
         uint32_t vendorId = 0;
         std::string name;
     };
 
+    enum class BackendType {
+        D3D12,
+        Metal,
+        Null,
+        OpenGL,
+        Vulkan,
+    };
+
+    class InstanceBase;
+    class AdapterBase;
+
+    // An adapter is an object that represent on possibility of creating devices in the system.
+    // Most of the time it will represent a combination of a physical GPU and an API. Not that the
+    // same GPU can be represented by multiple adapters but on different APIs.
+    //
+    // The underlying Dawn adapter is owned by the Dawn instance so this class is not RAII but just
+    // a reference to an underlying adapter.
+    class DAWN_NATIVE_EXPORT Adapter {
+      public:
+        Adapter();
+        Adapter(AdapterBase* impl);
+        ~Adapter();
+
+        BackendType GetBackendType() const;
+        const PCIInfo& GetPCIInfo() const;
+
+        // Create a device on this adapter, note that the interface will change to include at least
+        // a device descriptor and a pointer to backend specific options.
+        // On an error, nullptr is returned.
+        dawnDevice CreateDevice();
+
+      private:
+        AdapterBase* mImpl = nullptr;
+    };
+
+    // Represents a connection to dawn_native and is used for dependency injection, discovering
+    // system adapters and injecting custom adapters (like a Swiftshader Vulkan adapter).
+    //
+    // This is an RAII class for Dawn instances and also controls the lifetime of all adapters
+    // for this instance.
+    class DAWN_NATIVE_EXPORT Instance {
+      public:
+        Instance();
+        ~Instance();
+
+        Instance(const Instance& other) = delete;
+        Instance& operator=(const Instance& other) = delete;
+
+        // Gather all adapters in the system that can be accessed with no special options. These
+        // adapters will later be returned by GetAdapters.
+        void DiscoverDefaultAdapters();
+
+        // Returns all the adapters that the instance knows about.
+        std::vector<Adapter> GetAdapters() const;
+
+      private:
+        InstanceBase* mImpl = nullptr;
+    };
+
     // Backend-agnostic API for dawn_native
     DAWN_NATIVE_EXPORT dawnProcTable GetProcs();