forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
cast_media_blocker.cc
110 lines (89 loc) · 3.17 KB
/
cast_media_blocker.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// 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 "chromecast/browser/cast_media_blocker.h"
#include "base/threading/thread_checker.h"
#include "content/public/browser/media_session.h"
#include "content/public/browser/web_contents.h"
namespace chromecast {
namespace shell {
CastMediaBlocker::CastMediaBlocker(content::MediaSession* media_session)
: content::MediaSessionObserver(media_session),
blocked_(false),
paused_by_user_(true),
suspended_(true),
controllable_(false) {}
CastMediaBlocker::~CastMediaBlocker() {}
void CastMediaBlocker::BlockMediaLoading(bool blocked) {
if (blocked_ == blocked)
return;
blocked_ = blocked;
UpdateMediaBlockedState();
LOG(INFO) << __FUNCTION__ << " blocked=" << blocked_
<< " suspended=" << suspended_ << " controllable=" << controllable_
<< " paused_by_user=" << paused_by_user_;
// If blocking media, suspend if possible.
if (blocked_) {
if (!suspended_ && controllable_) {
Suspend();
}
return;
}
// If unblocking media, resume if media was not paused by user.
if (!paused_by_user_ && suspended_ && controllable_) {
paused_by_user_ = true;
Resume();
}
}
void CastMediaBlocker::MediaSessionStateChanged(bool is_controllable,
bool is_suspended) {
LOG(INFO) << __FUNCTION__ << " blocked=" << blocked_
<< " is_suspended=" << is_suspended
<< " is_controllable=" << is_controllable
<< " paused_by_user=" << paused_by_user_;
// Process controllability first.
if (controllable_ != is_controllable) {
controllable_ = is_controllable;
// If not blocked, and we regain control and the media wasn't paused when
// blocked, resume media if suspended.
if (!blocked_ && !paused_by_user_ && is_suspended && controllable_) {
paused_by_user_ = true;
Resume();
}
// Suspend if blocked and the session becomes controllable.
if (blocked_ && !is_suspended && controllable_) {
// Only suspend if suspended_ doesn't change. Otherwise, this will be
// handled in the suspended changed block.
if (suspended_ == is_suspended)
Suspend();
}
}
// Process suspended state next.
if (suspended_ != is_suspended) {
suspended_ = is_suspended;
// If blocking, suspend media whenever possible.
if (blocked_ && !suspended_) {
// If media was resumed when blocked, the user tried to play music.
paused_by_user_ = false;
if (controllable_)
Suspend();
}
// If not blocking, cache the user's play intent.
if (!blocked_)
paused_by_user_ = suspended_;
}
}
void CastMediaBlocker::Suspend() {
if (!media_session())
return;
LOG(INFO) << "Suspending media session.";
media_session()->Suspend(content::MediaSession::SuspendType::SYSTEM);
}
void CastMediaBlocker::Resume() {
if (!media_session())
return;
LOG(INFO) << "Resuming media session.";
media_session()->Resume(content::MediaSession::SuspendType::SYSTEM);
}
} // namespace shell
} // namespace chromecast