Web Audio: when media playback requires a user gesture, apply rule to cross origin iframes.

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

 /*
  * Copyright (C) 2010, 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:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 15 matching lines @@
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContextTask.h"
-#include "core/frame/Deprecation.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLMediaElement.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/webaudio/AnalyserNode.h"
 #include "modules/webaudio/AudioBuffer.h"
 #include "modules/webaudio/AudioBufferCallback.h"
 #include "modules/webaudio/AudioBufferSourceNode.h"
 #include "modules/webaudio/AudioContext.h"
 #include "modules/webaudio/AudioListener.h"
 #include "modules/webaudio/AudioNodeInput.h"
@@ skipping 22 matching lines @@
 #include "modules/webaudio/WaveShaperNode.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/audio/IIRFilter.h"
 #include "public/platform/Platform.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
-namespace {
-
-enum UserGestureRecord {
-    UserGestureRequiredAndAvailable = 0,
-    UserGestureRequiredAndNotAvailable,
-    UserGestureNotRequiredAndAvailable,
-    UserGestureNotRequiredAndNotAvailable,
-    UserGestureRecordMax
-};
-
-} // anonymous namespace
-
 BaseAudioContext* BaseAudioContext::create(Document& document, ExceptionState& exceptionState)
 {
     return AudioContext::create(document, exceptionState);
 }
 
 // FIXME(dominicc): Devolve these constructors to AudioContext
 // and OfflineAudioContext respectively.
 
 // Constructor for rendering to the audio hardware.
 BaseAudioContext::BaseAudioContext(Document* document)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(document)
     , m_destinationNode(nullptr)
     , m_isCleared(false)
     , m_isResolvingResumePromises(false)
     , m_userGestureRequired(false)
     , m_connectionCount(0)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_contextState(Suspended)
     , m_closedContextSampleRate(-1)
     , m_periodicWaveSine(nullptr)
     , m_periodicWaveSquare(nullptr)
     , m_periodicWaveSawtooth(nullptr)
     , m_periodicWaveTriangle(nullptr)
 {
-    // TODO(mlamouri): we might want to use other ways of checking for this but
-    // in order to record metrics, re-using the HTMLMediaElement setting is
-    // probably the simplest solution.
-    if (document->settings() && document->settings()->mediaPlaybackRequiresUserGesture())
+    // If mediaPlaybackRequiresUserGesture is enabled, cross origin iframes will
+    // require user gesture for the AudioContext to produce sound.
+    if (document->settings() && document->settings()->mediaPlaybackRequiresUserGesture()
+        && document->frame()) && document->frame()->isCrossOriginSubframe()) {
         m_userGestureRequired = true;
+    }
 
     m_destinationNode = DefaultAudioDestinationNode::create(this);
 
     initialize();
 }
 
 // Constructor for offline (non-realtime) rendering.
 BaseAudioContext::BaseAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(document)
     , m_destinationNode(nullptr)
     , m_isCleared(false)
     , m_isResolvingResumePromises(false)
     , m_userGestureRequired(false)
     , m_connectionCount(0)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_contextState(Suspended)
     , m_closedContextSampleRate(-1)
     , m_periodicWaveSine(nullptr)
     , m_periodicWaveSquare(nullptr)
     , m_periodicWaveSawtooth(nullptr)
     , m_periodicWaveTriangle(nullptr)
 {
-    // TODO(mlamouri): we might want to use other ways of checking for this but
-    // in order to record metrics, re-using the HTMLMediaElement setting is
-    // probably the simplest solution.
-    if (document->settings() && document->settings()->mediaPlaybackRequiresUserGesture())
+    // If mediaPlaybackRequiresUserGesture is enabled, cross origin iframes will
+    // require user gesture for the AudioContext to produce sound.
+    if (document->settings() && document->settings()->mediaPlaybackRequiresUserGesture()
+        && document->frame() && document->frame()->isCrossOriginSubframe()) {
         m_userGestureRequired = true;
+    }

[hongchan, 2016/09/07 16:59:00]

Blocking audio rendering should be limited to the realtime audio context because
OfflineAudioContext does not render the audio stream into the actual hardware,
so there is no reason to block it. I am not sure if this is discussed in the
working group discussion.

[mlamouri (slow - plz ping), 2016/09/08 13:12:42]

The goal here is to be compatible with Safari iOS and as far as I can tell, they
don't make any difference between regular and offline audio contexts. I'm not
sure why and that's why I prefer to be on the safe side and relax later. Though,
if you prefer to not do this, I can make this change.

 }
 
 BaseAudioContext::~BaseAudioContext()
 {
     deferredTaskHandler().contextWillBeDestroyed();
     // AudioNodes keep a reference to their context, so there should be no way to be in the destructor if there are still AudioNodes around.
     DCHECK(!isDestinationInitialized());
     DCHECK(!m_activeSourceNodes.size());
     DCHECK(!m_finishedSourceHandlers.size());
     DCHECK(!m_isResolvingResumePromises);
@@ skipping 377 matching lines @@
         // Initialize the table if necessary
         if (!m_periodicWaveTriangle)
             m_periodicWaveTriangle = PeriodicWave::createTriangle(sampleRate());
         return m_periodicWaveTriangle;
     default:
         NOTREACHED();
         return nullptr;
     }
 }
 
-void BaseAudioContext::recordUserGestureState()
+void BaseAudioContext::startRenderingIfNeeded()
 {
-    DEFINE_STATIC_LOCAL(EnumerationHistogram, userGestureHistogram, ("WebAudio.UserGesture", UserGestureRecordMax));
-
-    if (!m_userGestureRequired) {
-        if (UserGestureIndicator::processingUserGesture())
-            userGestureHistogram.count(UserGestureNotRequiredAndAvailable);
-        else
-            userGestureHistogram.count(UserGestureNotRequiredAndNotAvailable);
+    if (!m_userGestureRequired)
         return;
-    }
-
-    DCHECK(m_userGestureRequired);
-    if (!UserGestureIndicator::processingUserGesture()) {
-        userGestureHistogram.count(UserGestureRequiredAndNotAvailable);
-
-        Document* document = toDocument(getExecutionContext());
-        if (document)
-            Deprecation::countDeprecationCrossOriginIframe(*document, UseCounter::WebAudioAutoplayCrossOriginIframe);
-
-        return;
-    }
-    userGestureHistogram.count(UserGestureRequiredAndAvailable);
-    m_userGestureRequired = false;
+    startRendering();
 }
 
 String BaseAudioContext::state() const
 {
     // These strings had better match the strings for AudioContextState in AudioContext.idl.
     switch (m_contextState) {
     case Suspended:
         return "suspended";
     case Running:
         return "running";
@@ skipping 114 matching lines @@
             continue;
         if (node->handler().getNodeType() == AudioHandler::NodeTypeAudioBufferSource) {
             AudioBufferSourceNode* sourceNode = static_cast<AudioBufferSourceNode*>(node);
             sourceNode->audioBufferSourceHandler().handleStoppableSourceNode();
         }
     }
 }
 
 void BaseAudioContext::handlePreRenderTasks()
 {
+    LOG(INFO) << "handlePreRenderTasks";

[Raymond Toy, 2016/09/07 16:13:19]

handlePreRenderTask gets called about every 3 ms or less (depends on sample
rate).  Do you really want logged every time?

[mlamouri (slow - plz ping), 2016/09/08 13:12:42]

sorry, that's a leftover from some investigations.

     DCHECK(isAudioThread());
 
     // At the beginning of every render quantum, try to update the internal rendering graph state (from main thread changes).
     // It's OK if the tryLock() fails, we'll just take slightly longer to pick up the changes.
     if (tryLock()) {
         deferredTaskHandler().handleDeferredTasks();
 
         resolvePromisesForResume();
 
         // Check to see if source nodes can be stopped because the end time has passed.
@@ skipping 92 matching lines @@
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 void BaseAudioContext::startRendering()
 {
     // This is called for both online and offline contexts.
     DCHECK(isMainThread());
     DCHECK(m_destinationNode);
 
-    recordUserGestureState();
+    if (m_userGestureRequired) {
+        if (!UserGestureIndicator::processingUserGesture()) {
+            UseCounter::count(getExecutionContext(), UseCounter::WebAudioAutoplayCrossOriginIframe);

[hongchan, 2016/09/07 16:59:00]

Can you add a comment on what this does?

This looks like it will always increment the "WebAudioAutoplayCrossOriginIframe"
count. Is this what you want? How do you know this method is called from a
cross-origin iframe? Perhaps I am missing something.

[mlamouri (slow - plz ping), 2016/09/08 13:12:42]

m_userGestureRequired only applies for cross origin iframes but again, I didn't
mean to leave this here either. Sent my CL a bit too early it seems.

+            return;
+        }
+        m_userGestureRequired = false;
+    }
 
     if (m_contextState == Suspended) {
         destination()->audioDestinationHandler().startRendering();
         setContextState(Running);
     }
 }
 
 DEFINE_TRACE(BaseAudioContext)
 {
     visitor->trace(m_destinationNode);
@@ skipping 12 matching lines @@
 
 SecurityOrigin* BaseAudioContext::getSecurityOrigin() const
 {
     if (getExecutionContext())
         return getExecutionContext()->getSecurityOrigin();
 
     return nullptr;
 }
 
 } // namespace blink