Changeset 244223 in webkit


Ignore:
Timestamp:
Apr 12, 2019 11:04:56 AM (5 years ago)
Author:
eric.carlson@apple.com
Message:

Update AudioSession route sharing policy
​https://bugs.webkit.org/show_bug.cgi?id=196776
<rdar://problem/46501611>

Reviewed by Jer Noble.

Source/WebCore:

No new tests, updated an API test.

  • platform/audio/AudioSession.cpp:

(WebCore::convertEnumerationToString):

  • platform/audio/AudioSession.h:

(WTF::LogArgument<WebCore::RouteSharingPolicy>::toString):
(WTF::LogArgument<WebCore::AudioSession::CategoryType>::toString):

  • platform/audio/cocoa/MediaSessionManagerCocoa.mm:

(MediaSessionManagerCocoa::updateSessionState):

  • platform/audio/ios/AudioSessionIOS.mm:

(WebCore::AudioSession::setCategory):
(WebCore::AudioSession::routeSharingPolicy const):

  • platform/audio/mac/AudioSessionMac.cpp:

(WebCore::AudioSession::setCategory):

Source/WebKit:

  • UIProcess/ios/forms/WKAirPlayRoutePicker.mm:

(-[WKAirPlayRoutePicker showFromView:routeSharingPolicy:routingContextUID:hasVideo:]):

Source/WTF:

  • wtf/Platform.h: Define HAVE_ROUTE_SHARING_POLICY_LONG_FORM_VIDEO.

Tools:

  • TestWebKitAPI/Tests/WebKitLegacy/ios/AudioSessionCategoryIOS.mm:

(TestWebKitAPI::routeSharingPolicyLongFormVideo):
(TestWebKitAPI::routeSharingPolicyLongFormAudio):
(TestWebKitAPI::TEST):

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r244182 r244223  
     12019-04-12  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Update AudioSession route sharing policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196776
     5        <rdar://problem/46501611>
     6
     7        Reviewed by Jer Noble.
     8
     9        * wtf/Platform.h: Define HAVE_ROUTE_SHARING_POLICY_LONG_FORM_VIDEO.
     10
    1112019-04-10  Said Abou-Hallawa  <sabouhallawa@apple.com>
    212

  • trunk/Source/WTF/wtf/Platform.h

    r244000 r244223  
    15221522#define HAVE_ALLOWS_SENSITIVE_LOGGING 1
    15231523#endif
     1524
     1525#if (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 130000)
     1526#define HAVE_ROUTE_SHARING_POLICY_LONG_FORM_VIDEO 1
     1527#endif

  • trunk/Source/WebCore/ChangeLog

    r244218 r244223  
     12019-04-12  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Update AudioSession route sharing policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196776
     5        <rdar://problem/46501611>
     6
     7        Reviewed by Jer Noble.
     8
     9        No new tests, updated an API test.
     10
     11        * platform/audio/AudioSession.cpp:
     12        (WebCore::convertEnumerationToString):
     13        * platform/audio/AudioSession.h:
     14        (WTF::LogArgument<WebCore::RouteSharingPolicy>::toString):
     15        (WTF::LogArgument<WebCore::AudioSession::CategoryType>::toString):
     16        * platform/audio/cocoa/MediaSessionManagerCocoa.mm:
     17        (MediaSessionManagerCocoa::updateSessionState):
     18        * platform/audio/ios/AudioSessionIOS.mm:
     19        (WebCore::AudioSession::setCategory):
     20        (WebCore::AudioSession::routeSharingPolicy const):
     21        * platform/audio/mac/AudioSessionMac.cpp:
     22        (WebCore::AudioSession::setCategory):
     23
    1242019-04-12  Antoine Quint  <graouts@apple.com>
    225

  • trunk/Source/WebCore/platform/audio/AudioSession.cpp

    r239694 r244223  
    6161AudioSession::~AudioSession() = default;
    6262
    63 void AudioSession::setCategory(CategoryType)
     63void AudioSession::setCategory(CategoryType, RouteSharingPolicy)
    6464{
    6565    notImplemented();
    … …  
    130130#endif // !PLATFORM(COCOA)
    131131
     132String convertEnumerationToString(RouteSharingPolicy enumerationValue)
     133{
     134    static const NeverDestroyed<String> values[] = {
     135        MAKE_STATIC_STRING_IMPL("Default"),
     136        MAKE_STATIC_STRING_IMPL("LongFormAudio"),
     137        MAKE_STATIC_STRING_IMPL("Independent"),
     138        MAKE_STATIC_STRING_IMPL("LongFormVideo"),
     139    };
     140    static_assert(!static_cast<size_t>(RouteSharingPolicy::Default), "RouteSharingPolicy::Default is not 0 as expected");
     141    static_assert(static_cast<size_t>(RouteSharingPolicy::LongFormAudio) == 1, "RouteSharingPolicy::LongFormAudio is not 1 as expected");
     142    static_assert(static_cast<size_t>(RouteSharingPolicy::Independent) == 2, "RouteSharingPolicy::Independent is not 2 as expected");
     143    static_assert(static_cast<size_t>(RouteSharingPolicy::LongFormVideo) == 3, "RouteSharingPolicy::LongFormVideo is not 3 as expected");
     144    ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
     145    return values[static_cast<size_t>(enumerationValue)];
     146}
     147
     148String convertEnumerationToString(AudioSession::CategoryType enumerationValue)
     149{
     150    static const NeverDestroyed<String> values[] = {
     151        MAKE_STATIC_STRING_IMPL("None"),
     152        MAKE_STATIC_STRING_IMPL("AmbientSound"),
     153        MAKE_STATIC_STRING_IMPL("SoloAmbientSound"),
     154        MAKE_STATIC_STRING_IMPL("MediaPlayback"),
     155        MAKE_STATIC_STRING_IMPL("RecordAudio"),
     156        MAKE_STATIC_STRING_IMPL("PlayAndRecord"),
     157        MAKE_STATIC_STRING_IMPL("AudioProcessing"),
     158    };
     159    static_assert(!static_cast<size_t>(AudioSession::CategoryType::None), "AudioSession::CategoryType::None is not 0 as expected");
     160    static_assert(static_cast<size_t>(AudioSession::CategoryType::AmbientSound) == 1, "AudioSession::CategoryType::AmbientSound is not 1 as expected");
     161    static_assert(static_cast<size_t>(AudioSession::CategoryType::SoloAmbientSound) == 2, "AudioSession::CategoryType::SoloAmbientSound is not 2 as expected");
     162    static_assert(static_cast<size_t>(AudioSession::CategoryType::MediaPlayback) == 3, "AudioSession::CategoryType::MediaPlayback is not 3 as expected");
     163    static_assert(static_cast<size_t>(AudioSession::CategoryType::RecordAudio) == 4, "AudioSession::CategoryType::RecordAudio is not 4 as expected");
     164    static_assert(static_cast<size_t>(AudioSession::CategoryType::PlayAndRecord) == 5, "AudioSession::CategoryType::PlayAndRecord is not 5 as expected");
     165    static_assert(static_cast<size_t>(AudioSession::CategoryType::AudioProcessing) == 6, "AudioSession::CategoryType::AudioProcessing is not 6 as expected");
     166    ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
     167    return values[static_cast<size_t>(enumerationValue)];
     168}
    132169}
    133170

  • trunk/Source/WebCore/platform/audio/AudioSession.h

    r239694 r244223  
    3232#include <wtf/NeverDestroyed.h>
    3333#include <wtf/Noncopyable.h>
     34#include <wtf/text/WTFString.h>
    3435
    3536namespace WebCore {
    … …  
    3940enum class RouteSharingPolicy : uint8_t {
    4041    Default,
    41     LongForm,
     42    LongFormAudio,
    4243    Independent,
     44    LongFormVideo
    4345};
    4446
    … …  
    5759        AudioProcessing,
    5860    };
    59     WEBCORE_EXPORT void setCategory(CategoryType);
     61    WEBCORE_EXPORT void setCategory(CategoryType, RouteSharingPolicy);
    6062    WEBCORE_EXPORT CategoryType category() const;
    6163
    … …  
    102104};
    103105
    104 }
     106String convertEnumerationToString(RouteSharingPolicy);
     107String convertEnumerationToString(AudioSession::CategoryType);
     108
     109} // namespace WebCore
    105110
    106111namespace WTF {
    … …  
    109114    WebCore::RouteSharingPolicy,
    110115    WebCore::RouteSharingPolicy::Default,
    111     WebCore::RouteSharingPolicy::LongForm,
    112     WebCore::RouteSharingPolicy::Independent
     116    WebCore::RouteSharingPolicy::LongFormAudio,
     117    WebCore::RouteSharingPolicy::Independent,
     118    WebCore::RouteSharingPolicy::LongFormVideo
    113119    >;
    114120};
    115 }
     121
     122template<typename Type>
     123struct LogArgument;
     124
     125template <>
     126struct LogArgument<WebCore::RouteSharingPolicy> {
     127    static String toString(const WebCore::RouteSharingPolicy policy)
     128    {
     129        return convertEnumerationToString(policy);
     130    }
     131};
     132
     133template <>
     134struct LogArgument<WebCore::AudioSession::CategoryType> {
     135    static String toString(const WebCore::AudioSession::CategoryType category)
     136    {
     137        return convertEnumerationToString(category);
     138    }
     139};
     140
     141} // namespace WTF
    116142
    117143#endif // USE(AUDIO_SESSION)

  • trunk/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm

    r242909 r244223  
    6363void MediaSessionManagerCocoa::updateSessionState()
    6464{
     65    int videoCount = count(PlatformMediaSession::Video);
     66    int videoAudioCount = count(PlatformMediaSession::VideoAudio);
     67    int audioCount = count(PlatformMediaSession::Audio);
     68    int webAudioCount = count(PlatformMediaSession::WebAudio);
     69    int captureCount = count(PlatformMediaSession::MediaStreamCapturingAudio);
    6570    ALWAYS_LOG(LOGIDENTIFIER, "types: "
    66         "Video(", count(PlatformMediaSession::Video), "), "
    67         "Audio(", count(PlatformMediaSession::Audio), "), "
    68         "VideoAudio(", count(PlatformMediaSession::VideoAudio), "), "
    69         "WebAudio(", count(PlatformMediaSession::WebAudio), ")");
    70 
    71     if (has(PlatformMediaSession::WebAudio))
     71        "AudioCapture(", captureCount, "), "
     72        "Video(", videoCount, "), "
     73        "Audio(", audioCount, "), "
     74        "VideoAudio(", videoAudioCount, "), "
     75        "WebAudio(", webAudioCount, ")");
     76
     77    if (webAudioCount)
    7278        AudioSession::sharedSession().setPreferredBufferSize(kWebAudioBufferSize);
    7379    // In case of audio capture, we want to grab 20 ms chunks to limit the latency so that it is not noticeable by users
    7480    // while having a large enough buffer so that the audio rendering remains stable, hence a computation based on sample rate.
    75     else if (has(PlatformMediaSession::MediaStreamCapturingAudio))
     81    else if (captureCount)
    7682        AudioSession::sharedSession().setPreferredBufferSize(AudioSession::sharedSession().sampleRate() / 50);
    77     else if ((has(PlatformMediaSession::VideoAudio) || has(PlatformMediaSession::Audio)) && DeprecatedGlobalSettings::lowPowerVideoAudioBufferSizeEnabled()) {
     83    else if ((videoAudioCount || audioCount) && DeprecatedGlobalSettings::lowPowerVideoAudioBufferSizeEnabled()) {
    7884        // FIXME: <http://webkit.org/b/116725> Figure out why enabling the code below
    7985        // causes media LayoutTests to fail on 10.8.
    … …  
    9197        return;
    9298
    93     bool hasWebAudioType = false;
    9499    bool hasAudibleAudioOrVideoMediaType = false;
    95     bool hasAudioCapture = anyOfSessions([&hasWebAudioType, &hasAudibleAudioOrVideoMediaType] (PlatformMediaSession& session, size_t) mutable {
     100    forEachSession([&hasAudibleAudioOrVideoMediaType] (PlatformMediaSession& session, size_t) mutable {
    96101        auto type = session.mediaType();
    97         if (type == PlatformMediaSession::WebAudio)
    98             hasWebAudioType = true;
    99102        if ((type == PlatformMediaSession::VideoAudio || type == PlatformMediaSession::Audio) && session.canProduceAudio() && session.hasPlayedSinceLastInterruption())
    100103            hasAudibleAudioOrVideoMediaType = true;
    101104        if (session.isPlayingToWirelessPlaybackTarget())
    102105            hasAudibleAudioOrVideoMediaType = true;
    103         return (type == PlatformMediaSession::MediaStreamCapturingAudio);
    104106    });
    105107
    106     if (hasAudioCapture)
    107         AudioSession::sharedSession().setCategory(AudioSession::PlayAndRecord);
    108     else if (hasAudibleAudioOrVideoMediaType)
    109         AudioSession::sharedSession().setCategory(AudioSession::MediaPlayback);
    110     else if (hasWebAudioType)
    111         AudioSession::sharedSession().setCategory(AudioSession::AmbientSound);
    112     else
    113         AudioSession::sharedSession().setCategory(AudioSession::None);
     108    RouteSharingPolicy policy = RouteSharingPolicy::Default;
     109    AudioSession::CategoryType category = AudioSession::None;
     110    if (captureCount)
     111        category = AudioSession::PlayAndRecord;
     112    else if (hasAudibleAudioOrVideoMediaType) {
     113        category = AudioSession::MediaPlayback;
     114        if (videoCount || videoAudioCount)
     115            policy = RouteSharingPolicy::LongFormVideo;
     116        else
     117            policy = RouteSharingPolicy::LongFormAudio;
     118    } else if (webAudioCount)
     119        category = AudioSession::AmbientSound;
     120
     121    ALWAYS_LOG(LOGIDENTIFIER, "setting category = ", category, ", policy = ", policy);
     122    AudioSession::sharedSession().setCategory(category, policy);
    114123}
    115124

  • trunk/Source/WebCore/platform/audio/ios/AudioSessionIOS.mm

    r243552 r244223  
    101101}
    102102
    103 void AudioSession::setCategory(CategoryType newCategory)
    104 {
     103void AudioSession::setCategory(CategoryType newCategory, RouteSharingPolicy policy)
     104{
     105#if !HAVE(ROUTE_SHARING_POLICY_LONG_FORM_VIDEO)
     106    if (policy == RouteSharingPolicy::LongFormVideo)
     107        policy = RouteSharingPolicy::LongFormAudio;
     108#endif
     109
    105110    LOG(Media, "AudioSession::setCategory() - category = %s", categoryName(newCategory));
    106111
    … …  
    113118    NSString *categoryMode = AVAudioSessionModeDefault;
    114119    AVAudioSessionCategoryOptions options = 0;
    115     AVAudioSessionRouteSharingPolicy policy = AVAudioSessionRouteSharingPolicyDefault;
    116120
    117121    switch (newCategory) {
    … …  
    124128    case MediaPlayback:
    125129        categoryString = AVAudioSessionCategoryPlayback;
    126 ALLOW_DEPRECATED_DECLARATIONS_BEGIN
    127         policy = AVAudioSessionRouteSharingPolicyLongForm;
    128         break;
    129 ALLOW_DEPRECATED_DECLARATIONS_END
     130        break;
    130131    case RecordAudio:
    131132        categoryString = AVAudioSessionCategoryRecord;
    … …  
    145146
    146147    NSError *error = nil;
    147     [[AVAudioSession sharedInstance] setCategory:categoryString mode:categoryMode routeSharingPolicy:policy options:options error:&error];
     148    [[AVAudioSession sharedInstance] setCategory:categoryString mode:categoryMode routeSharingPolicy:static_cast<AVAudioSessionRouteSharingPolicy>(policy) options:options error:&error];
    148149#if !PLATFORM(IOS_FAMILY_SIMULATOR) && !PLATFORM(IOSMAC)
    149150    ASSERT(!error);
    … …  
    172173{
    173174    static_assert(static_cast<size_t>(RouteSharingPolicy::Default) == static_cast<size_t>(AVAudioSessionRouteSharingPolicyDefault), "RouteSharingPolicy::Default is not AVAudioSessionRouteSharingPolicyDefault as expected");
    174 ALLOW_DEPRECATED_DECLARATIONS_BEGIN
    175     static_assert(static_cast<size_t>(RouteSharingPolicy::LongForm) == static_cast<size_t>(AVAudioSessionRouteSharingPolicyLongForm), "RouteSharingPolicy::LongForm is not AVAudioSessionRouteSharingPolicyLongForm as expected");
    176 ALLOW_DEPRECATED_DECLARATIONS_END
     175#if HAVE(ROUTE_SHARING_POLICY_LONG_FORM_VIDEO)
     176    static_assert(static_cast<size_t>(RouteSharingPolicy::LongFormAudio) == static_cast<size_t>(AVAudioSessionRouteSharingPolicyLongFormAudio), "RouteSharingPolicy::LongFormAudio is not AVAudioSessionRouteSharingPolicyLongFormAudio as expected");
     177    static_assert(static_cast<size_t>(RouteSharingPolicy::LongFormVideo) == static_cast<size_t>(AVAudioSessionRouteSharingPolicyLongFormVideo), "RouteSharingPolicy::LongFormVideo is not AVAudioSessionRouteSharingPolicyLongFormVideo as expected");
     178#else
     179    static_assert(static_cast<size_t>(RouteSharingPolicy::LongFormAudio) == static_cast<size_t>(AVAudioSessionRouteSharingPolicyLongForm), "RouteSharingPolicy::LongFormAudio is not AVAudioSessionRouteSharingPolicyLongForm as expected");
     180#endif
    177181    static_assert(static_cast<size_t>(RouteSharingPolicy::Independent) == static_cast<size_t>(AVAudioSessionRouteSharingPolicyIndependent), "RouteSharingPolicy::Independent is not AVAudioSessionRouteSharingPolicyIndependent as expected");
    178182
    179183    AVAudioSessionRouteSharingPolicy policy = [[AVAudioSession sharedInstance] routeSharingPolicy];
    180     ASSERT(static_cast<RouteSharingPolicy>(policy) <= RouteSharingPolicy::Independent);
     184    ASSERT(static_cast<RouteSharingPolicy>(policy) <= RouteSharingPolicy::LongFormVideo);
    181185    return static_cast<RouteSharingPolicy>(policy);
    182186}
    … …  
    197201
    198202    m_private->m_categoryOverride = category;
    199     setCategory(category);
     203    setCategory(category, RouteSharingPolicy::Default);
    200204}
    201205

  • trunk/Source/WebCore/platform/audio/mac/AudioSessionMac.cpp

    r241183 r244223  
    7474}
    7575
    76 void AudioSession::setCategory(CategoryType category)
     76void AudioSession::setCategory(CategoryType category, RouteSharingPolicy)
    7777{
    7878    m_private->category = category;

  • trunk/Source/WebKit/ChangeLog

    r244221 r244223  
     12019-04-12  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Update AudioSession route sharing policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196776
     5        <rdar://problem/46501611>
     6
     7        Reviewed by Jer Noble.
     8
     9        * UIProcess/ios/forms/WKAirPlayRoutePicker.mm:
     10        (-[WKAirPlayRoutePicker showFromView:routeSharingPolicy:routingContextUID:hasVideo:]):
     11
    1122019-04-12  Wenson Hsieh  <wenson_hsieh@apple.com>
    213

  • trunk/Source/WebKit/UIProcess/ios/forms/WKAirPlayRoutePicker.mm

    r240461 r244223  
    179179enum {
    180180    WKAirPlayRoutePickerRouteSharingPolicyDefault = 0,
    181     WKAirPlayRoutePickerRouteSharingPolicyLongForm = 1,
     181    WKAirPlayRoutePickerRouteSharingPolicyLongFormAudio = 1,
    182182    WKAirPlayRoutePickerRouteSharingPolicyIndependent = 2,
     183    WKAirPlayRoutePickerRouteSharingPolicyLongFormVideo = 3,
    183184};
    184185typedef NSInteger WKAirPlayRoutePickerRouteSharingPolicy;
    … …  
    202203{
    203204    static_assert(static_cast<size_t>(WebCore::RouteSharingPolicy::Default) == static_cast<size_t>(WKAirPlayRoutePickerRouteSharingPolicyDefault), "RouteSharingPolicy::Default is not WKAirPlayRoutePickerRouteSharingPolicyDefault as expected");
    204     static_assert(static_cast<size_t>(WebCore::RouteSharingPolicy::LongForm) == static_cast<size_t>(WKAirPlayRoutePickerRouteSharingPolicyLongForm), "RouteSharingPolicy::LongForm is not WKAirPlayRoutePickerRouteSharingPolicyLongForm as expected");
     205    static_assert(static_cast<size_t>(WebCore::RouteSharingPolicy::LongFormAudio) == static_cast<size_t>(WKAirPlayRoutePickerRouteSharingPolicyLongFormAudio), "RouteSharingPolicy::LongFormAudio is not WKAirPlayRoutePickerRouteSharingPolicyLongFormAudio as expected");
    205206    static_assert(static_cast<size_t>(WebCore::RouteSharingPolicy::Independent) == static_cast<size_t>(WKAirPlayRoutePickerRouteSharingPolicyIndependent), "RouteSharingPolicy::Independent is not WKAirPlayRoutePickerRouteSharingPolicyIndependent as expected");
    206 
     207    static_assert(static_cast<size_t>(WebCore::RouteSharingPolicy::LongFormVideo) == static_cast<size_t>(WKAirPlayRoutePickerRouteSharingPolicyLongFormVideo), "RouteSharingPolicy::LongFormVideo is not WKAirPlayRoutePickerRouteSharingPolicyLongFormVideo as expected");
    207208    if (_actionSheet)
    208209        return;

  • trunk/Source/WebKitLegacy/mac/Plugins/WebPluginController.mm

    r237266 r244223  
    115115        return;
    116116
    117     AudioSession::sharedSession().setCategory(AudioSession::MediaPlayback);
     117    AudioSession::sharedSession().setCategory(AudioSession::MediaPlayback, RouteSharingPolicy::Default);
    118118}
    119119#endif

  • trunk/Tools/ChangeLog

    r244220 r244223  
     12019-04-12  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Update AudioSession route sharing policy
     4        https://bugs.webkit.org/show_bug.cgi?id=196776
     5        <rdar://problem/46501611>
     6
     7        Reviewed by Jer Noble.
     8
     9        * TestWebKitAPI/Tests/WebKitLegacy/ios/AudioSessionCategoryIOS.mm:
     10        (TestWebKitAPI::routeSharingPolicyLongFormVideo):
     11        (TestWebKitAPI::routeSharingPolicyLongFormAudio):
     12        (TestWebKitAPI::TEST):
     13
    1142019-04-12  Wenson Hsieh  <wenson_hsieh@apple.com>
    215

  • trunk/Tools/TestWebKitAPI/Tests/WebKitLegacy/ios/AudioSessionCategoryIOS.mm

    r237266 r244223  
    7272}
    7373
     74static AVAudioSessionRouteSharingPolicy routeSharingPolicyLongFormVideo()
     75{
     76#if HAVE(ROUTE_SHARING_POLICY_LONG_FORM_VIDEO)
     77    return AVAudioSessionRouteSharingPolicyLongFormVideo;
     78#else
     79    return AVAudioSessionRouteSharingPolicyLongForm;
     80#endif
     81}
     82
     83static AVAudioSessionRouteSharingPolicy routeSharingPolicyLongFormAudio()
     84{
     85#if HAVE(ROUTE_SHARING_POLICY_LONG_FORM_VIDEO)
     86    return AVAudioSessionRouteSharingPolicyLongFormAudio;
     87#else
     88    return AVAudioSessionRouteSharingPolicyLongForm;
     89#endif
     90}
     91
    7492TEST(WebKitLegacy, AudioSessionCategoryIOS)
    7593{
    … …  
    85103    uiWebView.get().delegate = uiDelegate.get();
    86104
     105    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], AVAudioSessionRouteSharingPolicyDefault);
     106
    87107    [uiWebView loadRequest:[NSURLRequest requestWithURL:[[NSBundle mainBundle] URLForResource:@"video-with-audio" withExtension:@"html" subdirectory:@"TestWebKitAPI.resources"]]];
    88108
    … …  
    91111    waitUntilAudioSessionCategoryIsEqualTo(getAVAudioSessionCategoryPlayback());
    92112    EXPECT_WK_STREQ(getAVAudioSessionCategoryPlayback(), [[getAVAudioSessionClass() sharedInstance] category]);
     113    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], routeSharingPolicyLongFormVideo());
    93114
    94115    didBeginPlaying = false;
    … …  
    100121    waitUntilAudioSessionCategoryIsEqualTo(getAVAudioSessionCategoryAmbient());
    101122    EXPECT_WK_STREQ(getAVAudioSessionCategoryAmbient(), [[getAVAudioSessionClass() sharedInstance] category]);
     123    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], AVAudioSessionRouteSharingPolicyDefault);
    102124
    103125    didBeginPlaying = false;
    … …  
    109131    waitUntilAudioSessionCategoryIsEqualTo(getAVAudioSessionCategoryAmbient());
    110132    EXPECT_WK_STREQ(getAVAudioSessionCategoryAmbient(), [[getAVAudioSessionClass() sharedInstance] category]);
     133    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], AVAudioSessionRouteSharingPolicyDefault);
    111134
    112135    didBeginPlaying = false;
    … …  
    118141    waitUntilAudioSessionCategoryIsEqualTo(getAVAudioSessionCategoryAmbient());
    119142    EXPECT_WK_STREQ(getAVAudioSessionCategoryAmbient(), [[getAVAudioSessionClass() sharedInstance] category]);
     143    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], AVAudioSessionRouteSharingPolicyDefault);
    120144
    121145    didBeginPlaying = false;
    … …  
    127151    waitUntilAudioSessionCategoryIsEqualTo(getAVAudioSessionCategoryPlayback());
    128152    EXPECT_WK_STREQ(getAVAudioSessionCategoryPlayback(), [[getAVAudioSessionClass() sharedInstance] category]);
     153    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], routeSharingPolicyLongFormVideo());
     154
     155    didBeginPlaying = false;
     156
     157    [uiWebView loadRequest:[NSURLRequest requestWithURL:[[NSBundle mainBundle] URLForResource:@"audio-only" withExtension:@"html" subdirectory:@"TestWebKitAPI.resources"]]];
     158
     159    Util::run(&didBeginPlaying);
     160
     161    waitUntilAudioSessionCategoryIsEqualTo(getAVAudioSessionCategoryPlayback());
     162    EXPECT_WK_STREQ(getAVAudioSessionCategoryPlayback(), [[getAVAudioSessionClass() sharedInstance] category]);
     163    EXPECT_EQ([[getAVAudioSessionClass() sharedInstance] routeSharingPolicy], routeSharingPolicyLongFormAudio());
    129164}
    130165
Note: See TracChangeset for help on using the changeset viewer.