OLD | NEW |
---|---|
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 "content/browser/media/capture/desktop_capture_device_aura.h" | 5 #include "content/browser/media/capture/desktop_capture_device_aura.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/metrics/histogram.h" | |
9 #include "base/timer/timer.h" | 8 #include "base/timer/timer.h" |
10 #include "cc/output/copy_output_request.h" | 9 #include "content/browser/media/capture/aura_window_capture_machine.h" |
11 #include "cc/output/copy_output_result.h" | |
12 #include "content/browser/compositor/image_transport_factory.h" | |
13 #include "content/browser/media/capture/content_video_capture_device_core.h" | 10 #include "content/browser/media/capture/content_video_capture_device_core.h" |
14 #include "content/browser/media/capture/desktop_capture_device_uma_types.h" | |
15 #include "content/common/gpu/client/gl_helper.h" | |
16 #include "content/public/browser/browser_thread.h" | 11 #include "content/public/browser/browser_thread.h" |
17 #include "content/public/browser/power_save_blocker.h" | |
18 #include "media/base/video_capture_types.h" | |
19 #include "media/base/video_util.h" | |
20 #include "skia/ext/image_operations.h" | |
21 #include "third_party/skia/include/core/SkBitmap.h" | |
22 #include "ui/aura/client/screen_position_client.h" | |
23 #include "ui/aura/env.h" | |
24 #include "ui/aura/window.h" | 12 #include "ui/aura/window.h" |
25 #include "ui/aura/window_observer.h" | |
26 #include "ui/aura/window_tree_host.h" | |
27 #include "ui/base/cursor/cursors_aura.h" | |
28 #include "ui/compositor/compositor.h" | |
29 #include "ui/compositor/dip_util.h" | |
30 #include "ui/compositor/layer.h" | |
31 #include "ui/gfx/screen.h" | |
32 | 13 |
33 namespace content { | 14 namespace content { |
34 | 15 |
35 namespace { | 16 DesktopCaptureDeviceAura::DesktopCaptureDeviceAura() |
36 | 17 : machine_(new AuraWindowCaptureMachine()), |
37 int clip_byte(int x) { | 18 core_(new ContentVideoCaptureDeviceCore( |
38 return std::max(0, std::min(x, 255)); | 19 scoped_ptr<VideoCaptureMachine>(machine_))) { |
39 } | 20 } |
40 | 21 |
41 int alpha_blend(int alpha, int src, int dst) { | |
42 return (src * alpha + dst * (255 - alpha)) / 255; | |
43 } | |
44 | |
45 // Helper function to composite a cursor bitmap on a YUV420 video frame. | |
46 void RenderCursorOnVideoFrame( | |
47 const scoped_refptr<media::VideoFrame>& target, | |
48 const SkBitmap& cursor_bitmap, | |
49 const gfx::Point& cursor_position) { | |
50 DCHECK(target.get()); | |
51 DCHECK(!cursor_bitmap.isNull()); | |
52 | |
53 gfx::Rect rect = gfx::IntersectRects( | |
54 gfx::Rect(cursor_bitmap.width(), cursor_bitmap.height()) + | |
55 gfx::Vector2d(cursor_position.x(), cursor_position.y()), | |
56 target->visible_rect()); | |
57 | |
58 cursor_bitmap.lockPixels(); | |
59 for (int y = rect.y(); y < rect.bottom(); ++y) { | |
60 int cursor_y = y - cursor_position.y(); | |
61 uint8* yplane = target->data(media::VideoFrame::kYPlane) + | |
62 y * target->row_bytes(media::VideoFrame::kYPlane); | |
63 uint8* uplane = target->data(media::VideoFrame::kUPlane) + | |
64 (y / 2) * target->row_bytes(media::VideoFrame::kUPlane); | |
65 uint8* vplane = target->data(media::VideoFrame::kVPlane) + | |
66 (y / 2) * target->row_bytes(media::VideoFrame::kVPlane); | |
67 for (int x = rect.x(); x < rect.right(); ++x) { | |
68 int cursor_x = x - cursor_position.x(); | |
69 SkColor color = cursor_bitmap.getColor(cursor_x, cursor_y); | |
70 int alpha = SkColorGetA(color); | |
71 int color_r = SkColorGetR(color); | |
72 int color_g = SkColorGetG(color); | |
73 int color_b = SkColorGetB(color); | |
74 int color_y = clip_byte(((color_r * 66 + color_g * 129 + color_b * 25 + | |
75 128) >> 8) + 16); | |
76 yplane[x] = alpha_blend(alpha, color_y, yplane[x]); | |
77 | |
78 // Only sample U and V at even coordinates. | |
79 if ((x % 2 == 0) && (y % 2 == 0)) { | |
80 int color_u = clip_byte(((color_r * -38 + color_g * -74 + | |
81 color_b * 112 + 128) >> 8) + 128); | |
82 int color_v = clip_byte(((color_r * 112 + color_g * -94 + | |
83 color_b * -18 + 128) >> 8) + 128); | |
84 uplane[x / 2] = alpha_blend(alpha, color_u, uplane[x / 2]); | |
85 vplane[x / 2] = alpha_blend(alpha, color_v, vplane[x / 2]); | |
86 } | |
87 } | |
88 } | |
89 cursor_bitmap.unlockPixels(); | |
90 } | |
91 | |
92 class DesktopVideoCaptureMachine | |
93 : public VideoCaptureMachine, | |
94 public aura::WindowObserver, | |
95 public ui::CompositorObserver, | |
96 public base::SupportsWeakPtr<DesktopVideoCaptureMachine> { | |
97 public: | |
98 DesktopVideoCaptureMachine(const DesktopMediaID& source); | |
99 ~DesktopVideoCaptureMachine() override; | |
100 | |
101 // VideoCaptureFrameSource overrides. | |
102 bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy, | |
103 const media::VideoCaptureParams& params) override; | |
104 void Stop(const base::Closure& callback) override; | |
105 | |
106 // Implements aura::WindowObserver. | |
107 void OnWindowBoundsChanged(aura::Window* window, | |
108 const gfx::Rect& old_bounds, | |
109 const gfx::Rect& new_bounds) override; | |
110 void OnWindowDestroyed(aura::Window* window) override; | |
111 void OnWindowAddedToRootWindow(aura::Window* window) override; | |
112 void OnWindowRemovingFromRootWindow(aura::Window* window, | |
113 aura::Window* new_root) override; | |
114 | |
115 // Implements ui::CompositorObserver. | |
116 void OnCompositingDidCommit(ui::Compositor* compositor) override {} | |
117 void OnCompositingStarted(ui::Compositor* compositor, | |
118 base::TimeTicks start_time) override {} | |
119 void OnCompositingEnded(ui::Compositor* compositor) override; | |
120 void OnCompositingAborted(ui::Compositor* compositor) override {} | |
121 void OnCompositingLockStateChanged(ui::Compositor* compositor) override {} | |
122 void OnCompositingShuttingDown(ui::Compositor* compositor) override {} | |
123 | |
124 private: | |
125 // Captures a frame. | |
126 // |dirty| is false for timer polls and true for compositor updates. | |
127 void Capture(bool dirty); | |
128 | |
129 // Update capture size. Must be called on the UI thread. | |
130 void UpdateCaptureSize(); | |
131 | |
132 // Response callback for cc::Layer::RequestCopyOfOutput(). | |
133 void DidCopyOutput( | |
134 scoped_refptr<media::VideoFrame> video_frame, | |
135 base::TimeTicks start_time, | |
136 const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, | |
137 scoped_ptr<cc::CopyOutputResult> result); | |
138 | |
139 // A helper which does the real work for DidCopyOutput. Returns true if | |
140 // succeeded. | |
141 bool ProcessCopyOutputResponse( | |
142 scoped_refptr<media::VideoFrame> video_frame, | |
143 base::TimeTicks start_time, | |
144 const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, | |
145 scoped_ptr<cc::CopyOutputResult> result); | |
146 | |
147 // Helper function to update cursor state. | |
148 // |region_in_frame| defines the desktop bound in the captured frame. | |
149 // Returns the current cursor position in captured frame. | |
150 gfx::Point UpdateCursorState(const gfx::Rect& region_in_frame); | |
151 | |
152 // Clears cursor state. | |
153 void ClearCursorState(); | |
154 | |
155 // The window associated with the desktop. | |
156 aura::Window* desktop_window_; | |
157 | |
158 // The timer that kicks off period captures. | |
159 base::Timer timer_; | |
160 | |
161 // The id of the window being captured. | |
162 DesktopMediaID window_id_; | |
163 | |
164 // Makes all the decisions about which frames to copy, and how. | |
165 scoped_refptr<ThreadSafeCaptureOracle> oracle_proxy_; | |
166 | |
167 // The capture parameters for this capture. | |
168 media::VideoCaptureParams capture_params_; | |
169 | |
170 // YUV readback pipeline. | |
171 scoped_ptr<content::ReadbackYUVInterface> yuv_readback_pipeline_; | |
172 | |
173 // Cursor state. | |
174 ui::Cursor last_cursor_; | |
175 gfx::Point cursor_hot_point_; | |
176 SkBitmap scaled_cursor_bitmap_; | |
177 | |
178 // TODO(jiayl): Remove power_save_blocker_ when there is an API to keep the | |
179 // screen from sleeping for the drive-by web. | |
180 scoped_ptr<PowerSaveBlocker> power_save_blocker_; | |
181 | |
182 DISALLOW_COPY_AND_ASSIGN(DesktopVideoCaptureMachine); | |
183 }; | |
184 | |
185 DesktopVideoCaptureMachine::DesktopVideoCaptureMachine( | |
186 const DesktopMediaID& source) | |
187 : desktop_window_(NULL), | |
188 timer_(true, true), | |
189 window_id_(source) {} | |
190 | |
191 DesktopVideoCaptureMachine::~DesktopVideoCaptureMachine() {} | |
192 | |
193 bool DesktopVideoCaptureMachine::Start( | |
194 const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy, | |
195 const media::VideoCaptureParams& params) { | |
196 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
197 | |
198 desktop_window_ = content::DesktopMediaID::GetAuraWindowById(window_id_); | |
199 if (!desktop_window_) | |
200 return false; | |
201 | |
202 // If the associated layer is already destroyed then return failure. | |
203 ui::Layer* layer = desktop_window_->layer(); | |
204 if (!layer) | |
205 return false; | |
206 | |
207 DCHECK(oracle_proxy.get()); | |
208 oracle_proxy_ = oracle_proxy; | |
209 capture_params_ = params; | |
210 | |
211 // Update capture size. | |
212 UpdateCaptureSize(); | |
213 | |
214 // Start observing window events. | |
215 desktop_window_->AddObserver(this); | |
216 | |
217 // Start observing compositor updates. | |
218 if (desktop_window_->GetHost()) | |
219 desktop_window_->GetHost()->compositor()->AddObserver(this); | |
220 | |
221 power_save_blocker_.reset( | |
222 PowerSaveBlocker::Create( | |
223 PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep, | |
224 PowerSaveBlocker::kReasonOther, | |
225 "DesktopCaptureDevice is running").release()); | |
226 | |
227 // Starts timer. | |
228 timer_.Start(FROM_HERE, oracle_proxy_->min_capture_period(), | |
229 base::Bind(&DesktopVideoCaptureMachine::Capture, AsWeakPtr(), | |
230 false)); | |
231 | |
232 return true; | |
233 } | |
234 | |
235 void DesktopVideoCaptureMachine::Stop(const base::Closure& callback) { | |
236 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
237 power_save_blocker_.reset(); | |
238 | |
239 // Stop observing compositor and window events. | |
240 if (desktop_window_) { | |
241 aura::WindowTreeHost* window_host = desktop_window_->GetHost(); | |
242 // In the host destructor the compositor is destroyed before the window. | |
243 if (window_host && window_host->compositor()) | |
244 window_host->compositor()->RemoveObserver(this); | |
245 desktop_window_->RemoveObserver(this); | |
246 desktop_window_ = NULL; | |
247 } | |
248 | |
249 // Stop timer. | |
250 timer_.Stop(); | |
251 | |
252 callback.Run(); | |
253 } | |
254 | |
255 void DesktopVideoCaptureMachine::UpdateCaptureSize() { | |
256 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
257 if (oracle_proxy_.get() && desktop_window_) { | |
258 ui::Layer* layer = desktop_window_->layer(); | |
259 oracle_proxy_->UpdateCaptureSize(ui::ConvertSizeToPixel( | |
260 layer, layer->bounds().size())); | |
261 } | |
262 ClearCursorState(); | |
263 } | |
264 | |
265 void DesktopVideoCaptureMachine::Capture(bool dirty) { | |
266 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
267 | |
268 // Do not capture if the desktop window is already destroyed. | |
269 if (!desktop_window_) | |
270 return; | |
271 | |
272 scoped_refptr<media::VideoFrame> frame; | |
273 ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb; | |
274 | |
275 const base::TimeTicks start_time = base::TimeTicks::Now(); | |
276 const VideoCaptureOracle::Event event = | |
277 dirty ? VideoCaptureOracle::kCompositorUpdate | |
278 : VideoCaptureOracle::kTimerPoll; | |
279 if (oracle_proxy_->ObserveEventAndDecideCapture( | |
280 event, gfx::Rect(), start_time, &frame, &capture_frame_cb)) { | |
281 scoped_ptr<cc::CopyOutputRequest> request = | |
282 cc::CopyOutputRequest::CreateRequest( | |
283 base::Bind(&DesktopVideoCaptureMachine::DidCopyOutput, | |
284 AsWeakPtr(), frame, start_time, capture_frame_cb)); | |
285 gfx::Rect window_rect = gfx::Rect(desktop_window_->bounds().width(), | |
286 desktop_window_->bounds().height()); | |
287 request->set_area(window_rect); | |
288 desktop_window_->layer()->RequestCopyOfOutput(request.Pass()); | |
289 } | |
290 } | |
291 | |
292 void CopyOutputFinishedForVideo( | |
293 base::TimeTicks start_time, | |
294 const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, | |
295 const scoped_refptr<media::VideoFrame>& target, | |
296 const SkBitmap& cursor_bitmap, | |
297 const gfx::Point& cursor_position, | |
298 scoped_ptr<cc::SingleReleaseCallback> release_callback, | |
299 bool result) { | |
300 if (!cursor_bitmap.isNull()) | |
301 RenderCursorOnVideoFrame(target, cursor_bitmap, cursor_position); | |
302 release_callback->Run(0, false); | |
303 capture_frame_cb.Run(target, start_time, result); | |
304 } | |
305 | |
306 void RunSingleReleaseCallback(scoped_ptr<cc::SingleReleaseCallback> cb, | |
307 uint32 sync_point) { | |
308 cb->Run(sync_point, false); | |
309 } | |
310 | |
311 void DesktopVideoCaptureMachine::DidCopyOutput( | |
312 scoped_refptr<media::VideoFrame> video_frame, | |
313 base::TimeTicks start_time, | |
314 const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, | |
315 scoped_ptr<cc::CopyOutputResult> result) { | |
316 static bool first_call = true; | |
317 | |
318 bool succeeded = ProcessCopyOutputResponse( | |
319 video_frame, start_time, capture_frame_cb, result.Pass()); | |
320 | |
321 base::TimeDelta capture_time = base::TimeTicks::Now() - start_time; | |
322 | |
323 // The two UMA_ blocks must be put in its own scope since it creates a static | |
324 // variable which expected constant histogram name. | |
325 if (window_id_.type == DesktopMediaID::TYPE_SCREEN) { | |
326 UMA_HISTOGRAM_TIMES(kUmaScreenCaptureTime, capture_time); | |
327 } else { | |
328 UMA_HISTOGRAM_TIMES(kUmaWindowCaptureTime, capture_time); | |
329 } | |
330 | |
331 if (first_call) { | |
332 first_call = false; | |
333 if (window_id_.type == DesktopMediaID::TYPE_SCREEN) { | |
334 IncrementDesktopCaptureCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED | |
335 : FIRST_SCREEN_CAPTURE_FAILED); | |
336 } else { | |
337 IncrementDesktopCaptureCounter(succeeded | |
338 ? FIRST_WINDOW_CAPTURE_SUCCEEDED | |
339 : FIRST_WINDOW_CAPTURE_FAILED); | |
340 } | |
341 } | |
342 } | |
343 | |
344 bool DesktopVideoCaptureMachine::ProcessCopyOutputResponse( | |
345 scoped_refptr<media::VideoFrame> video_frame, | |
346 base::TimeTicks start_time, | |
347 const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, | |
348 scoped_ptr<cc::CopyOutputResult> result) { | |
349 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
350 if (result->IsEmpty() || result->size().IsEmpty() || !desktop_window_) | |
351 return false; | |
352 | |
353 if (capture_params_.requested_format.pixel_format == | |
354 media::PIXEL_FORMAT_TEXTURE) { | |
355 DCHECK(!video_frame.get()); | |
356 cc::TextureMailbox texture_mailbox; | |
357 scoped_ptr<cc::SingleReleaseCallback> release_callback; | |
358 result->TakeTexture(&texture_mailbox, &release_callback); | |
359 DCHECK(texture_mailbox.IsTexture()); | |
360 if (!texture_mailbox.IsTexture()) | |
361 return false; | |
362 video_frame = media::VideoFrame::WrapNativeTexture( | |
363 make_scoped_ptr(new gpu::MailboxHolder(texture_mailbox.mailbox(), | |
364 texture_mailbox.target(), | |
365 texture_mailbox.sync_point())), | |
366 base::Bind(&RunSingleReleaseCallback, base::Passed(&release_callback)), | |
367 result->size(), gfx::Rect(result->size()), result->size(), | |
368 base::TimeDelta(), false); | |
369 capture_frame_cb.Run(video_frame, start_time, true); | |
370 return true; | |
371 } | |
372 | |
373 // Compute the dest size we want after the letterboxing resize. Make the | |
374 // coordinates and sizes even because we letterbox in YUV space | |
375 // (see CopyRGBToVideoFrame). They need to be even for the UV samples to | |
376 // line up correctly. | |
377 // The video frame's visible_rect() and the result's size() are both physical | |
378 // pixels. | |
379 gfx::Rect region_in_frame = media::ComputeLetterboxRegion( | |
380 video_frame->visible_rect(), result->size()); | |
381 region_in_frame = gfx::Rect(region_in_frame.x() & ~1, | |
382 region_in_frame.y() & ~1, | |
383 region_in_frame.width() & ~1, | |
384 region_in_frame.height() & ~1); | |
385 if (region_in_frame.IsEmpty()) | |
386 return false; | |
387 | |
388 ImageTransportFactory* factory = ImageTransportFactory::GetInstance(); | |
389 GLHelper* gl_helper = factory->GetGLHelper(); | |
390 if (!gl_helper) | |
391 return false; | |
392 | |
393 cc::TextureMailbox texture_mailbox; | |
394 scoped_ptr<cc::SingleReleaseCallback> release_callback; | |
395 result->TakeTexture(&texture_mailbox, &release_callback); | |
396 DCHECK(texture_mailbox.IsTexture()); | |
397 if (!texture_mailbox.IsTexture()) | |
398 return false; | |
399 | |
400 gfx::Rect result_rect(result->size()); | |
401 if (!yuv_readback_pipeline_ || | |
402 yuv_readback_pipeline_->scaler()->SrcSize() != result_rect.size() || | |
403 yuv_readback_pipeline_->scaler()->SrcSubrect() != result_rect || | |
404 yuv_readback_pipeline_->scaler()->DstSize() != region_in_frame.size()) { | |
405 yuv_readback_pipeline_.reset( | |
406 gl_helper->CreateReadbackPipelineYUV(GLHelper::SCALER_QUALITY_FAST, | |
407 result_rect.size(), | |
408 result_rect, | |
409 region_in_frame.size(), | |
410 true, | |
411 true)); | |
412 } | |
413 | |
414 gfx::Point cursor_position_in_frame = UpdateCursorState(region_in_frame); | |
415 yuv_readback_pipeline_->ReadbackYUV( | |
416 texture_mailbox.mailbox(), | |
417 texture_mailbox.sync_point(), | |
418 video_frame.get(), | |
419 region_in_frame.origin(), | |
420 base::Bind(&CopyOutputFinishedForVideo, | |
421 start_time, | |
422 capture_frame_cb, | |
423 video_frame, | |
424 scaled_cursor_bitmap_, | |
425 cursor_position_in_frame, | |
426 base::Passed(&release_callback))); | |
427 return true; | |
428 } | |
429 | |
430 gfx::Point DesktopVideoCaptureMachine::UpdateCursorState( | |
431 const gfx::Rect& region_in_frame) { | |
432 const gfx::Rect desktop_bounds = desktop_window_->layer()->bounds(); | |
433 gfx::NativeCursor cursor = | |
434 desktop_window_->GetHost()->last_cursor(); | |
435 if (last_cursor_ != cursor) { | |
436 SkBitmap cursor_bitmap; | |
437 if (ui::GetCursorBitmap(cursor, &cursor_bitmap, &cursor_hot_point_)) { | |
438 scaled_cursor_bitmap_ = skia::ImageOperations::Resize( | |
439 cursor_bitmap, | |
440 skia::ImageOperations::RESIZE_BEST, | |
441 cursor_bitmap.width() * region_in_frame.width() / | |
442 desktop_bounds.width(), | |
443 cursor_bitmap.height() * region_in_frame.height() / | |
444 desktop_bounds.height()); | |
445 last_cursor_ = cursor; | |
446 } else { | |
447 // Clear cursor state if ui::GetCursorBitmap failed so that we do not | |
448 // render cursor on the captured frame. | |
449 ClearCursorState(); | |
450 } | |
451 } | |
452 | |
453 gfx::Point cursor_position = aura::Env::GetInstance()->last_mouse_location(); | |
454 aura::client::GetScreenPositionClient(desktop_window_->GetRootWindow())-> | |
455 ConvertPointFromScreen(desktop_window_, &cursor_position); | |
456 const gfx::Point hot_point_in_dip = ui::ConvertPointToDIP( | |
457 desktop_window_->layer(), cursor_hot_point_); | |
458 cursor_position.Offset(-desktop_bounds.x() - hot_point_in_dip.x(), | |
459 -desktop_bounds.y() - hot_point_in_dip.y()); | |
460 return gfx::Point( | |
461 region_in_frame.x() + cursor_position.x() * region_in_frame.width() / | |
462 desktop_bounds.width(), | |
463 region_in_frame.y() + cursor_position.y() * region_in_frame.height() / | |
464 desktop_bounds.height()); | |
465 } | |
466 | |
467 void DesktopVideoCaptureMachine::ClearCursorState() { | |
468 last_cursor_ = ui::Cursor(); | |
469 cursor_hot_point_ = gfx::Point(); | |
470 scaled_cursor_bitmap_.reset(); | |
471 } | |
472 | |
473 void DesktopVideoCaptureMachine::OnWindowBoundsChanged( | |
474 aura::Window* window, | |
475 const gfx::Rect& old_bounds, | |
476 const gfx::Rect& new_bounds) { | |
477 DCHECK(desktop_window_ && window == desktop_window_); | |
478 | |
479 // Post task to update capture size on UI thread. | |
480 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind( | |
481 &DesktopVideoCaptureMachine::UpdateCaptureSize, AsWeakPtr())); | |
482 } | |
483 | |
484 void DesktopVideoCaptureMachine::OnWindowDestroyed(aura::Window* window) { | |
485 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
486 | |
487 Stop(base::Bind(&base::DoNothing)); | |
488 | |
489 oracle_proxy_->ReportError("OnWindowDestroyed()"); | |
490 } | |
491 | |
492 void DesktopVideoCaptureMachine::OnWindowAddedToRootWindow( | |
493 aura::Window* window) { | |
494 DCHECK(window == desktop_window_); | |
495 window->GetHost()->compositor()->AddObserver(this); | |
496 } | |
497 | |
498 void DesktopVideoCaptureMachine::OnWindowRemovingFromRootWindow( | |
499 aura::Window* window, | |
500 aura::Window* new_root) { | |
501 DCHECK(window == desktop_window_); | |
502 window->GetHost()->compositor()->RemoveObserver(this); | |
503 } | |
504 | |
505 void DesktopVideoCaptureMachine::OnCompositingEnded( | |
506 ui::Compositor* compositor) { | |
507 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind( | |
508 &DesktopVideoCaptureMachine::Capture, AsWeakPtr(), true)); | |
509 } | |
510 | |
511 } // namespace | |
512 | |
513 DesktopCaptureDeviceAura::DesktopCaptureDeviceAura( | |
514 const DesktopMediaID& source) | |
515 : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>( | |
516 new DesktopVideoCaptureMachine(source)))) {} | |
517 | |
518 DesktopCaptureDeviceAura::~DesktopCaptureDeviceAura() { | 22 DesktopCaptureDeviceAura::~DesktopCaptureDeviceAura() { |
519 DVLOG(2) << "DesktopCaptureDeviceAura@" << this << " destroying."; | 23 DVLOG(2) << "DesktopCaptureDeviceAura@" << this << " destroying."; |
520 } | 24 } |
521 | 25 |
522 // static | 26 // static |
523 media::VideoCaptureDevice* DesktopCaptureDeviceAura::Create( | 27 media::VideoCaptureDevice* DesktopCaptureDeviceAura::Create( |
524 const DesktopMediaID& source) { | 28 const DesktopMediaID& source) { |
525 IncrementDesktopCaptureCounter(source.type == DesktopMediaID::TYPE_SCREEN | 29 DesktopCaptureDeviceAura* device = new DesktopCaptureDeviceAura(); |
526 ? SCREEN_CAPTURER_CREATED | 30 |
527 : WINDOW_CAPTURER_CREATED); | 31 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
528 return new DesktopCaptureDeviceAura(source); | 32 base::Bind(&DesktopCaptureDeviceAura::SetWindow, |
33 device->AsWeakPtr(), source)); | |
Sergey Ulanov
2015/03/04 01:54:03
weak pointers are not thread-safe and shouldn't be
| |
34 return device; | |
529 } | 35 } |
530 | 36 |
531 void DesktopCaptureDeviceAura::AllocateAndStart( | 37 void DesktopCaptureDeviceAura::AllocateAndStart( |
532 const media::VideoCaptureParams& params, | 38 const media::VideoCaptureParams& params, |
533 scoped_ptr<Client> client) { | 39 scoped_ptr<Client> client) { |
534 DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString(); | 40 DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString(); |
535 core_->AllocateAndStart(params, client.Pass()); | 41 core_->AllocateAndStart(params, client.Pass()); |
536 } | 42 } |
537 | 43 |
538 void DesktopCaptureDeviceAura::StopAndDeAllocate() { | 44 void DesktopCaptureDeviceAura::StopAndDeAllocate() { |
539 core_->StopAndDeAllocate(); | 45 core_->StopAndDeAllocate(); |
540 } | 46 } |
541 | 47 |
48 void DesktopCaptureDeviceAura::SetWindow(const DesktopMediaID& source) { | |
Sergey Ulanov
2015/03/04 01:54:03
This doesn't need to be a class member. You can ha
robert.bradford
2015/03/04 18:33:05
Ah, this was the insight that I was missing and I
| |
49 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
50 aura::Window* window = DesktopMediaID::GetAuraWindowById(source); | |
51 machine_->SetWindow(window); | |
52 } | |
53 | |
542 } // namespace content | 54 } // namespace content |
OLD | NEW |