Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(534)

Side by Side Diff: media/cast/cast_environment.cc

Issue 184813009: Cast Streaming API end-to-end browser_test. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "media/cast/cast_environment.h" 5 #include "media/cast/cast_environment.h"
6 6
7 #include "base/bind.h" 7 #include "base/bind.h"
8 #include "base/location.h" 8 #include "base/location.h"
9 #include "base/logging.h" 9 #include "base/logging.h"
10 #include "base/threading/thread.h"
11 #include "base/time/default_tick_clock.h"
10 12
11 using base::SingleThreadTaskRunner; 13 using base::SingleThreadTaskRunner;
12 14
13 namespace { 15 namespace {
14 16
15 void DeleteLoggingOnMainThread(scoped_ptr<media::cast::LoggingImpl> logging) { 17 void DeleteLoggingOnMainThread(scoped_ptr<media::cast::LoggingImpl> logging) {
16 logging.reset(); 18 logging.reset();
17 } 19 }
18 20
19 } // namespace 21 } // namespace
20 22
21 namespace media { 23 namespace media {
22 namespace cast { 24 namespace cast {
23 25
26 CastEnvironment::CastEnvironment()
27 : clock_(new base::DefaultTickClock()),
28 logging_(new LoggingImpl(CastLoggingConfig())) {}
29
30 CastEnvironment::CastEnvironment(const CastLoggingConfig& logging_config)
31 : clock_(new base::DefaultTickClock()),
32 logging_(new LoggingImpl(logging_config)) {}
33
24 CastEnvironment::CastEnvironment( 34 CastEnvironment::CastEnvironment(
25 scoped_ptr<base::TickClock> clock, 35 scoped_ptr<base::TickClock> clock,
26 scoped_refptr<SingleThreadTaskRunner> main_thread_proxy, 36 scoped_refptr<SingleThreadTaskRunner> main_thread_proxy,
27 scoped_refptr<SingleThreadTaskRunner> audio_encode_thread_proxy, 37 scoped_refptr<SingleThreadTaskRunner> audio_encode_thread_proxy,
28 scoped_refptr<SingleThreadTaskRunner> audio_decode_thread_proxy, 38 scoped_refptr<SingleThreadTaskRunner> audio_decode_thread_proxy,
29 scoped_refptr<SingleThreadTaskRunner> video_encode_thread_proxy, 39 scoped_refptr<SingleThreadTaskRunner> video_encode_thread_proxy,
30 scoped_refptr<SingleThreadTaskRunner> video_decode_thread_proxy, 40 scoped_refptr<SingleThreadTaskRunner> video_decode_thread_proxy,
31 scoped_refptr<SingleThreadTaskRunner> transport_thread_proxy, 41 scoped_refptr<SingleThreadTaskRunner> transport_thread_proxy,
32 const CastLoggingConfig& config) 42 const CastLoggingConfig& logging_config)
33 : clock_(clock.Pass()), 43 : clock_(clock.Pass()),
34 main_thread_proxy_(main_thread_proxy), 44 main_thread_proxy_(main_thread_proxy),
35 audio_encode_thread_proxy_(audio_encode_thread_proxy), 45 audio_encode_thread_proxy_(audio_encode_thread_proxy),
36 audio_decode_thread_proxy_(audio_decode_thread_proxy), 46 audio_decode_thread_proxy_(audio_decode_thread_proxy),
37 video_encode_thread_proxy_(video_encode_thread_proxy), 47 video_encode_thread_proxy_(video_encode_thread_proxy),
38 video_decode_thread_proxy_(video_decode_thread_proxy), 48 video_decode_thread_proxy_(video_decode_thread_proxy),
39 transport_thread_proxy_(transport_thread_proxy), 49 transport_thread_proxy_(transport_thread_proxy),
40 logging_(new LoggingImpl(main_thread_proxy, config)) { 50 logging_(new LoggingImpl(logging_config)) {
41 DCHECK(main_thread_proxy); 51 DCHECK(main_thread_proxy);
42 } 52 }
43 53
44 CastEnvironment::~CastEnvironment() { 54 CastEnvironment::~CastEnvironment() {
45 // Logging must be deleted on the main thread. 55 // Logging must be deleted on the main thread.
46 if (main_thread_proxy_->RunsTasksOnCurrentThread()) { 56 if (main_thread_proxy_ && !main_thread_proxy_->RunsTasksOnCurrentThread()) {
47 logging_.reset();
48 } else {
49 main_thread_proxy_->PostTask( 57 main_thread_proxy_->PostTask(
50 FROM_HERE, 58 FROM_HERE,
51 base::Bind(&DeleteLoggingOnMainThread, base::Passed(&logging_))); 59 base::Bind(&DeleteLoggingOnMainThread, base::Passed(&logging_)));
52 } 60 }
53 } 61 }
54 62
55 bool CastEnvironment::PostTask(ThreadId identifier, 63 bool CastEnvironment::PostTask(ThreadId identifier,
56 const tracked_objects::Location& from_here, 64 const tracked_objects::Location& from_here,
57 const base::Closure& task) { 65 const base::Closure& task) {
58 scoped_refptr<SingleThreadTaskRunner> task_runner = 66 scoped_refptr<SingleThreadTaskRunner> task_runner =
59 GetMessageSingleThreadTaskRunnerForThread(identifier); 67 GetMessageSingleThreadTaskRunnerForThread(identifier);
60 68
61 return task_runner->PostTask(from_here, task); 69 return task_runner->PostTask(from_here, task);
62 } 70 }
63 71
64 bool CastEnvironment::PostDelayedTask( 72 bool CastEnvironment::PostDelayedTask(
65 ThreadId identifier, 73 ThreadId identifier,
66 const tracked_objects::Location& from_here, 74 const tracked_objects::Location& from_here,
67 const base::Closure& task, 75 const base::Closure& task,
68 base::TimeDelta delay) { 76 base::TimeDelta delay) {
69 scoped_refptr<SingleThreadTaskRunner> task_runner = 77 scoped_refptr<SingleThreadTaskRunner> task_runner =
70 GetMessageSingleThreadTaskRunnerForThread(identifier); 78 GetMessageSingleThreadTaskRunnerForThread(identifier);
71 79
72 return task_runner->PostDelayedTask(from_here, task, delay); 80 return task_runner->PostDelayedTask(from_here, task, delay);
73 } 81 }
74 82
75 scoped_refptr<SingleThreadTaskRunner> 83 scoped_refptr<SingleThreadTaskRunner>
76 CastEnvironment::GetMessageSingleThreadTaskRunnerForThread( 84 CastEnvironment::GetMessageSingleThreadTaskRunnerForThread(
77 ThreadId identifier) { 85 ThreadId identifier) {
86 // A convenience macro to efficiently check and create a missing task runner
hubbe 2014/03/04 22:42:26 I don't think this is a good idea. I think it woul
miu 2014/03/06 06:09:15 Done.
87 // on-demand.
88 #define AUTO_CREATE_TASK_RUNNER(name, options) \
89 if (!name##_thread_proxy_) { \
90 base::AutoLock auto_lock(create_lock_); \
91 if (!name##_thread_proxy_) { \
92 name##_thread_.reset(new base::Thread("CastEnvironment/" #name)); \
93 name##_thread_->StartWithOptions(options); \
94 name##_thread_proxy_ = name##_thread_->message_loop_proxy(); \
95 } \
96 }
97
78 switch (identifier) { 98 switch (identifier) {
79 case CastEnvironment::MAIN: 99 case CastEnvironment::MAIN:
100 AUTO_CREATE_TASK_RUNNER(
101 main, base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
80 return main_thread_proxy_; 102 return main_thread_proxy_;
81 case CastEnvironment::AUDIO_ENCODER: 103 case CastEnvironment::AUDIO_ENCODER:
104 AUTO_CREATE_TASK_RUNNER(audio_encode, base::Thread::Options());
82 return audio_encode_thread_proxy_; 105 return audio_encode_thread_proxy_;
83 case CastEnvironment::AUDIO_DECODER: 106 case CastEnvironment::AUDIO_DECODER:
107 AUTO_CREATE_TASK_RUNNER(audio_decode, base::Thread::Options());
84 return audio_decode_thread_proxy_; 108 return audio_decode_thread_proxy_;
85 case CastEnvironment::VIDEO_ENCODER: 109 case CastEnvironment::VIDEO_ENCODER:
110 AUTO_CREATE_TASK_RUNNER(video_encode, base::Thread::Options());
86 return video_encode_thread_proxy_; 111 return video_encode_thread_proxy_;
87 case CastEnvironment::VIDEO_DECODER: 112 case CastEnvironment::VIDEO_DECODER:
113 AUTO_CREATE_TASK_RUNNER(video_decode, base::Thread::Options());
88 return video_decode_thread_proxy_; 114 return video_decode_thread_proxy_;
89 case CastEnvironment::TRANSPORT: 115 case CastEnvironment::TRANSPORT:
116 AUTO_CREATE_TASK_RUNNER(transport, base::Thread::Options());
90 return transport_thread_proxy_; 117 return transport_thread_proxy_;
91 default: 118 default:
92 NOTREACHED() << "Invalid Thread identifier"; 119 NOTREACHED() << "Invalid Thread identifier";
93 return NULL; 120 return NULL;
94 } 121 }
122
123 #undef AUTO_CREATE_TASK_RUNNER
95 } 124 }
96 125
97 bool CastEnvironment::CurrentlyOn(ThreadId identifier) { 126 bool CastEnvironment::CurrentlyOn(ThreadId identifier) {
98 switch (identifier) { 127 switch (identifier) {
99 case CastEnvironment::MAIN: 128 case CastEnvironment::MAIN:
100 return main_thread_proxy_->RunsTasksOnCurrentThread(); 129 return main_thread_proxy_ &&
130 main_thread_proxy_->RunsTasksOnCurrentThread();
101 case CastEnvironment::AUDIO_ENCODER: 131 case CastEnvironment::AUDIO_ENCODER:
102 return audio_encode_thread_proxy_->RunsTasksOnCurrentThread(); 132 return audio_encode_thread_proxy_ &&
133 audio_encode_thread_proxy_->RunsTasksOnCurrentThread();
103 case CastEnvironment::AUDIO_DECODER: 134 case CastEnvironment::AUDIO_DECODER:
104 return audio_decode_thread_proxy_->RunsTasksOnCurrentThread(); 135 return audio_decode_thread_proxy_ &&
136 audio_decode_thread_proxy_->RunsTasksOnCurrentThread();
105 case CastEnvironment::VIDEO_ENCODER: 137 case CastEnvironment::VIDEO_ENCODER:
106 return video_encode_thread_proxy_->RunsTasksOnCurrentThread(); 138 return video_encode_thread_proxy_ &&
139 video_encode_thread_proxy_->RunsTasksOnCurrentThread();
107 case CastEnvironment::VIDEO_DECODER: 140 case CastEnvironment::VIDEO_DECODER:
108 return video_decode_thread_proxy_->RunsTasksOnCurrentThread(); 141 return video_decode_thread_proxy_ &&
142 video_decode_thread_proxy_->RunsTasksOnCurrentThread();
109 case CastEnvironment::TRANSPORT: 143 case CastEnvironment::TRANSPORT:
110 return transport_thread_proxy_->RunsTasksOnCurrentThread(); 144 return transport_thread_proxy_ &&
145 transport_thread_proxy_->RunsTasksOnCurrentThread();
111 default: 146 default:
112 NOTREACHED() << "Invalid thread identifier"; 147 NOTREACHED() << "Invalid thread identifier";
113 return false; 148 return false;
114 } 149 }
115 } 150 }
116 151
117 base::TickClock* CastEnvironment::Clock() const { return clock_.get(); }
118
119 LoggingImpl* CastEnvironment::Logging() {
120 DCHECK(CurrentlyOn(CastEnvironment::MAIN))
121 << "Must be called from main thread";
122 return logging_.get();
123 }
124
125 } // namespace cast 152 } // namespace cast
126 } // namespace media 153 } // namespace media
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698