Bug 1940869 - Use STL types in dom/canvas/CacheInvalidator.h. r=gfx-reviewers,lsalzman

Differential Revision: https://phabricator.services.mozilla.com/D233785

Author: kdashg

dom/canvas/CacheInvalidator.h

@@ -7,9 +7,12 @@
 #ifndef MOZILLA_CACHE_INVALIDATOR_H_
 #define MOZILLA_CACHE_INVALIDATOR_H_
 
-#include "mozilla/Maybe.h"
-#include "mozilla/UniquePtr.h"
 #include "DmdStdContainers.h"
+#include "mozilla/Assertions.h"
+
+#include <cstddef>  // nullptr_t
+#include <memory>
+#include <optional>
 #include <vector>
 
 // -
@@ -73,27 +76,33 @@ class AbstractCache {
 
 template <typename T>
 class CacheMaybe : public AbstractCache {
-  Maybe<T> mVal;
+  std::optional<T> mVal;
 
  public:
+  CacheMaybe& operator=(std::optional<T>&& rhs) {
+    mVal.swap(rhs);
+    rhs.reset();
+    return *this;
+  }
+
   template <typename U>
-  CacheMaybe& operator=(Maybe<U>&& rhs) {
-    mVal.reset();
-    if (rhs) {
-      mVal.emplace(std::move(rhs.ref()));
-    }
+  CacheMaybe& operator=(U&& rhs) {
+    mVal.emplace(std::move(rhs));
     return *this;
   }
 
-  CacheMaybe& operator=(Nothing) { return *this = Maybe<T>(); }
+  CacheMaybe& operator=(std::nullptr_t) {
+    mVal.reset();
+    return *this;
+  }
 
   void OnInvalidate() override {
-    *this = Nothing();
+    *this = {};
     ResetInvalidators({});
   }
 
   explicit operator bool() const { return bool(mVal); }
-  T* get() const { return mVal.ptrOr(nullptr); }
+  T* get() const { return mVal ? &*mVal : nullptr; }
   T* operator->() const { return get(); }
 };
 
@@ -127,7 +136,7 @@ class CacheWeakMap final {
     }
   };
 
-  using MapT = webgl::dmd_unordered_map<const KeyT*, UniquePtr<Entry>,
+  using MapT = webgl::dmd_unordered_map<const KeyT*, std::unique_ptr<Entry>,
                                         DerefHash, DerefEqual>;
   MapT mMap;
 
@@ -136,14 +145,14 @@ class CacheWeakMap final {
     return mMap.SizeOfExcludingThis(mso);
   }
 
-  UniquePtr<Entry> MakeEntry(const KeyT& key, ValueT&& value) {
-    return UniquePtr<Entry>(new Entry(*this, key, std::move(value)));
+  std::unique_ptr<Entry> MakeEntry(const KeyT& key, ValueT&& value) {
+    return std::unique_ptr<Entry>(new Entry(*this, key, std::move(value)));
   }
-  UniquePtr<Entry> MakeEntry(const KeyT& key, const ValueT& value) {
+  std::unique_ptr<Entry> MakeEntry(const KeyT& key, const ValueT& value) {
     return MakeEntry(key, ValueT(value));
   }
 
-  const ValueT* Insert(UniquePtr<Entry>&& entry) {
+  const ValueT* Insert(std::unique_ptr<Entry>&& entry) {
     auto insertable = typename MapT::value_type{&entry->mKey, std::move(entry)};
 
     const auto res = mMap.insert(std::move(insertable));

dom/canvas/WebGLFramebuffer.cpp

@@ -522,7 +522,7 @@ WebGLFramebuffer::WebGLFramebuffer(WebGLContext* webgl,
   info.zLayerCount = 1;
   info.isMultiview = false;
 
-  mCompletenessInfo = Some(std::move(info));
+  mCompletenessInfo = std::move(info);
 }
 
 WebGLFramebuffer::~WebGLFramebuffer() {
@@ -1062,7 +1062,7 @@ FBStatus WebGLFramebuffer::CheckFramebufferStatus() const {
       info.isMultiview = cur->IsMultiview();
     }
     MOZ_ASSERT(info.width && info.height);
-    mCompletenessInfo = Some(std::move(info));
+    mCompletenessInfo = std::move(info);
     info.fb = nullptr;  // Don't trigger the invalidation warning.
     return LOCAL_GL_FRAMEBUFFER_COMPLETE;
   } while (false);