[SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

third_party/WebKit/Source/modules/webaudio/IIRFilterNode.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/webaudio/IIRFilterNode.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/webaudio/AudioBasicProcessorHandler.h"
@@ skipping 108 matching lines @@
 
 DEFINE_TRACE(IIRFilterNode) {
   AudioNode::Trace(visitor);
 }
 
 IIRProcessor* IIRFilterNode::IirProcessor() const {
   return static_cast<IIRProcessor*>(
       static_cast<AudioBasicProcessorHandler&>(Handler()).Processor());
 }
 
-void IIRFilterNode::getFrequencyResponse(const DOMFloat32Array* frequency_hz,
-                                         DOMFloat32Array* mag_response,
-                                         DOMFloat32Array* phase_response,
-                                         ExceptionState& exception_state) {
-  if (!frequency_hz) {
+void IIRFilterNode::getFrequencyResponse(
+    NotShared<const DOMFloat32Array> frequency_hz,
+    NotShared<DOMFloat32Array> mag_response,
+    NotShared<DOMFloat32Array> phase_response,
+    ExceptionState& exception_state) {
+  if (!frequency_hz.View()) {
     exception_state.ThrowDOMException(kNotSupportedError,
                                       "frequencyHz array cannot be null");
     return;
   }
 
-  if (!mag_response) {
+  if (!mag_response.View()) {
     exception_state.ThrowDOMException(kNotSupportedError,
                                       "magResponse array cannot be null");
     return;
   }
 
-  if (!phase_response) {
+  if (!phase_response.View()) {
     exception_state.ThrowDOMException(kNotSupportedError,
                                       "phaseResponse array cannot be null");
     return;
   }
 
-  unsigned frequency_hz_length = frequency_hz->length();
+  unsigned frequency_hz_length = frequency_hz.View()->length();
 
-  if (mag_response->length() < frequency_hz_length) {
+  if (mag_response.View()->length() < frequency_hz_length) {
     exception_state.ThrowDOMException(
         kNotSupportedError,
         ExceptionMessages::IndexExceedsMinimumBound(
-            "magResponse length", mag_response->length(), frequency_hz_length));
+            "magResponse length", mag_response.View()->length(),
+            frequency_hz_length));
     return;
   }
 
-  if (phase_response->length() < frequency_hz_length) {
+  if (phase_response.View()->length() < frequency_hz_length) {
     exception_state.ThrowDOMException(
-        kNotSupportedError, ExceptionMessages::IndexExceedsMinimumBound(
-                                "phaseResponse length",
-                                phase_response->length(), frequency_hz_length));
+        kNotSupportedError,
+        ExceptionMessages::IndexExceedsMinimumBound(
+            "phaseResponse length", phase_response.View()->length(),
+            frequency_hz_length));
     return;
   }
 
   IirProcessor()->GetFrequencyResponse(
-      frequency_hz_length, frequency_hz->Data(), mag_response->Data(),
-      phase_response->Data());
+      frequency_hz_length, frequency_hz.View()->Data(),
+      mag_response.View()->Data(), phase_response.View()->Data());
 }
 
 }  // namespace blink