binding: Replaces DictionaryHelper::get(ScriptValue) with get(Nullable<T>).

third_party/WebKit/Source/core/animation/EffectInput.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/EffectInput.h"
 
 #include "bindings/core/v8/Dictionary.h"
+#include "bindings/core/v8/DictionaryHelperForBindings.h"
 #include "bindings/core/v8/DictionarySequenceOrDictionary.h"
 #include "core/animation/AnimationInputHelpers.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "wtf/ASCIICType.h"
 #include "wtf/HashSet.h"
 #include "wtf/NonCopyingSort.h"
 
 namespace blink {
 
 namespace {
 
 bool compareKeyframes(const RefPtr<StringKeyframe>& a,
                       const RefPtr<StringKeyframe>& b) {
   return a->offset() < b->offset();
 }
 
-// Gets offset value from keyframeDictionary and returns false if this value was
-// invalid.
-bool getAndCheckOffset(const Dictionary& keyframeDictionary,
-                       double& offset,
-                       double lastOffset,
-                       ExceptionState& exceptionState) {
-  DictionaryHelper::get(keyframeDictionary, "offset", offset);
-
+// Validates the value of |offset| and throws an exception if out of range.
+bool checkOffset(double offset,
+                 double lastOffset,
+                 ExceptionState& exceptionState) {
   // Keyframes with offsets outside the range [0.0, 1.0] are an error.
   if (std::isnan(offset)) {
     exceptionState.throwTypeError("Non numeric offset provided");
     return false;
   }
 
   if (offset < 0 || offset > 1) {
     exceptionState.throwTypeError("Offsets provided outside the range [0, 1]");
     return false;
   }
@@ skipping 119 matching lines @@
 EffectModel* EffectInput::convertArrayForm(
     Element& element,
     const Vector<Dictionary>& keyframeDictionaries,
     ExceptionState& exceptionState) {
   StringKeyframeVector keyframes;
   double lastOffset = 0;
 
   for (const Dictionary& keyframeDictionary : keyframeDictionaries) {
     RefPtr<StringKeyframe> keyframe = StringKeyframe::create();
 
-    ScriptValue scriptValue;
-    bool frameHasOffset =
-        DictionaryHelper::get(keyframeDictionary, "offset", scriptValue) &&
-        !scriptValue.isNull();
+    Nullable<double> offset;
+    if (DictionaryHelper::get(keyframeDictionary, "offset", offset) &&
+        !offset.isNull()) {
+      if (!checkOffset(offset.get(), lastOffset, exceptionState))
+        return nullptr;
 
-    double offset = 0.0;
-    if (frameHasOffset) {
-      if (!getAndCheckOffset(keyframeDictionary, offset, lastOffset,
-                             exceptionState))
-        return nullptr;
-      lastOffset = offset;
-      keyframe->setOffset(offset);
+      lastOffset = offset.get();
+      keyframe->setOffset(offset.get());
     }
 
     String compositeString;
     DictionaryHelper::get(keyframeDictionary, "composite", compositeString);
     if (compositeString == "add")
       keyframe->setComposite(EffectModel::CompositeAdd);
     // TODO(alancutter): Support "accumulate" keyframe composition.
 
     String timingFunctionString;
     if (DictionaryHelper::get(keyframeDictionary, "easing",
@@ skipping 87 matching lines @@
   String timingFunctionString;
   RefPtr<TimingFunction> timingFunction = nullptr;
   if (DictionaryHelper::get(keyframeDictionary, "easing",
                             timingFunctionString)) {
     timingFunction = AnimationInputHelpers::parseTimingFunction(
         timingFunctionString, &element.document(), exceptionState);
     if (!timingFunction)
       return nullptr;
   }
 
-  ScriptValue scriptValue;
-  bool frameHasOffset =
-      DictionaryHelper::get(keyframeDictionary, "offset", scriptValue) &&
-      !scriptValue.isNull();
-  double offset = 0.0;
-  if (frameHasOffset &&
-      !getAndCheckOffset(keyframeDictionary, offset, 0.0, exceptionState))
-    return nullptr;
+  Nullable<double> offset;
+  if (DictionaryHelper::get(keyframeDictionary, "offset", offset) &&
+      !offset.isNull()) {
+    if (!checkOffset(offset.get(), 0.0, exceptionState))
+      return nullptr;
+  }
 
   String compositeString;
   DictionaryHelper::get(keyframeDictionary, "composite", compositeString);
 
   Vector<String> keyframeProperties;
   keyframeDictionary.getPropertyNames(keyframeProperties);
   for (const auto& property : keyframeProperties) {
     if (property == "offset" || property == "composite" ||
         property == "easing") {
       continue;
     }
 
     Vector<String> values;
     if (!getPropertyIndexedKeyframeValues(keyframeDictionary, property,
                                           executionContext, exceptionState,
                                           values))
       return nullptr;
 
     size_t numKeyframes = values.size();
     for (size_t i = 0; i < numKeyframes; ++i) {
       RefPtr<StringKeyframe> keyframe = StringKeyframe::create();
 
-      if (frameHasOffset)
-        keyframe->setOffset(offset);
+      if (!offset.isNull())
+        keyframe->setOffset(offset.get());
       else if (numKeyframes == 1)
         keyframe->setOffset(1.0);
       else
         keyframe->setOffset(i / (numKeyframes - 1.0));
 
       if (timingFunction)
         keyframe->setEasing(timingFunction);
 
       if (compositeString == "add")
         keyframe->setComposite(EffectModel::CompositeAdd);
       // TODO(alancutter): Support "accumulate" keyframe composition.
 
       setKeyframeValue(element, *keyframe.get(), property, values[i]);
       keyframes.append(keyframe);
     }
   }
 
   std::sort(keyframes.begin(), keyframes.end(), compareKeyframes);
 
   DCHECK(!exceptionState.hadException());
 
   return createEffectModelFromKeyframes(element, keyframes, exceptionState);
 }
 
 }  // namespace blink