UseCounter: Introduce UseCounter::Observer for layout tests

third_party/WebKit/Source/core/testing/Internals.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 139 matching lines @@
 #include "wtf/Optional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/dtoa.h"
 #include "wtf/text/StringBuffer.h"
 #include <deque>
 #include <memory>
 #include <v8.h>
 
 namespace blink {
 
+namespace {
+
+class UseCounterObserverImpl final : public UseCounter::Observer {
+  WTF_MAKE_NONCOPYABLE(UseCounterObserverImpl);
+
+ public:
+  UseCounterObserverImpl(ScriptPromiseResolver* resolver,
+                         UseCounter::Feature feature)
+      : m_resolver(resolver), m_feature(feature) {}
+
+  bool onCountFeature(UseCounter::Feature feature) final {
+    if (m_feature != feature)
+      return false;
+    m_resolver->resolve(feature);
+    return true;
+  }
+
+  DEFINE_INLINE_VIRTUAL_TRACE() {
+    UseCounter::Observer::trace(visitor);
+    visitor->trace(m_resolver);
+  }
+
+ private:
+  Member<ScriptPromiseResolver> m_resolver;
+  UseCounter::Feature m_feature;
+};
+
+}  // namespace
+
 static WTF::Optional<DocumentMarker::MarkerType> markerTypeFrom(
     const String& markerType) {
   if (equalIgnoringCase(markerType, "Spelling"))
     return DocumentMarker::Spelling;
   if (equalIgnoringCase(markerType, "Grammar"))
     return DocumentMarker::Grammar;
   if (equalIgnoringCase(markerType, "TextMatch"))
     return DocumentMarker::TextMatch;
   return WTF::nullopt;
 }
@@ skipping 2809 matching lines @@
     return false;
   return UseCounter::isCounted(*document,
                                static_cast<UseCounter::Feature>(feature));
 }
 
 bool Internals::isCSSPropertyUseCounted(Document* document,
                                         const String& propertyName) {
   return UseCounter::isCounted(*document, propertyName);
 }
 
+ScriptPromise Internals::observeUseCounter(ScriptState* scriptState,
+                                           Document* document,
+                                           uint32_t feature) {
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+  ScriptPromise promise = resolver->promise();
+  if (feature >= UseCounter::NumberOfFeatures) {
+    resolver->reject();
+    return promise;
+  }
+
+  UseCounter::Feature useCounterFeature =
+      static_cast<UseCounter::Feature>(feature);
+  if (UseCounter::isCounted(*document, useCounterFeature)) {
+    resolver->resolve();
+    return promise;
+  }
+
+  Frame* frame = document->frame();
+  if (!frame || !frame->host()) {
+    resolver->reject();
+    return promise;
+  }
+
+  frame->host()->useCounter().addObserver(
+      new UseCounterObserverImpl(resolver, useCounterFeature));
+  return promise;
+}
+
 String Internals::unscopableAttribute() {
   return "unscopableAttribute";
 }
 
 String Internals::unscopableMethod() {
   return "unscopableMethod";
 }
 
 ClientRectList* Internals::focusRingRects(Element* element) {
   Vector<LayoutRect> rects;
@@ skipping 63 matching lines @@
 
 void Internals::crash() {
   CHECK(false) << "Intentional crash";
 }
 
 void Internals::setIsLowEndDevice(bool isLowEndDevice) {
   MemoryCoordinator::setIsLowEndDeviceForTesting(isLowEndDevice);
 }
 
 }  // namespace blink