Index: content/browser/media/capture/desktop_capture_device_aura.cc |
diff --git a/content/browser/media/capture/desktop_capture_device_aura.cc b/content/browser/media/capture/desktop_capture_device_aura.cc |
index de1a1093b38f828e7522573a7d7612a85c086d2b..c9ad8e0e8dd1c5a328efe48129b8a1cfa9554418 100644 |
--- a/content/browser/media/capture/desktop_capture_device_aura.cc |
+++ b/content/browser/media/capture/desktop_capture_device_aura.cc |
@@ -5,547 +5,35 @@ |
#include "content/browser/media/capture/desktop_capture_device_aura.h" |
#include "base/logging.h" |
-#include "base/metrics/histogram.h" |
#include "base/timer/timer.h" |
-#include "cc/output/copy_output_request.h" |
-#include "cc/output/copy_output_result.h" |
-#include "content/browser/compositor/image_transport_factory.h" |
+#include "content/browser/media/capture/aura_window_capture_machine.h" |
#include "content/browser/media/capture/content_video_capture_device_core.h" |
-#include "content/browser/media/capture/desktop_capture_device_uma_types.h" |
-#include "content/common/gpu/client/gl_helper.h" |
#include "content/public/browser/browser_thread.h" |
-#include "content/public/browser/power_save_blocker.h" |
-#include "media/base/video_capture_types.h" |
-#include "media/base/video_util.h" |
-#include "skia/ext/image_operations.h" |
-#include "third_party/skia/include/core/SkBitmap.h" |
-#include "ui/aura/client/screen_position_client.h" |
-#include "ui/aura/env.h" |
#include "ui/aura/window.h" |
-#include "ui/aura/window_observer.h" |
-#include "ui/aura/window_tree_host.h" |
-#include "ui/base/cursor/cursors_aura.h" |
-#include "ui/compositor/compositor.h" |
-#include "ui/compositor/dip_util.h" |
-#include "ui/compositor/layer.h" |
-#include "ui/gfx/screen.h" |
namespace content { |
namespace { |
-int clip_byte(int x) { |
- return std::max(0, std::min(x, 255)); |
-} |
- |
-int alpha_blend(int alpha, int src, int dst) { |
- return (src * alpha + dst * (255 - alpha)) / 255; |
-} |
- |
-// Helper function to composite a cursor bitmap on a YUV420 video frame. |
-void RenderCursorOnVideoFrame( |
- const scoped_refptr<media::VideoFrame>& target, |
- const SkBitmap& cursor_bitmap, |
- const gfx::Point& cursor_position) { |
- DCHECK(target.get()); |
- DCHECK(!cursor_bitmap.isNull()); |
- |
- gfx::Rect rect = gfx::IntersectRects( |
- gfx::Rect(cursor_bitmap.width(), cursor_bitmap.height()) + |
- gfx::Vector2d(cursor_position.x(), cursor_position.y()), |
- target->visible_rect()); |
- |
- cursor_bitmap.lockPixels(); |
- for (int y = rect.y(); y < rect.bottom(); ++y) { |
- int cursor_y = y - cursor_position.y(); |
- uint8* yplane = target->data(media::VideoFrame::kYPlane) + |
- y * target->row_bytes(media::VideoFrame::kYPlane); |
- uint8* uplane = target->data(media::VideoFrame::kUPlane) + |
- (y / 2) * target->row_bytes(media::VideoFrame::kUPlane); |
- uint8* vplane = target->data(media::VideoFrame::kVPlane) + |
- (y / 2) * target->row_bytes(media::VideoFrame::kVPlane); |
- for (int x = rect.x(); x < rect.right(); ++x) { |
- int cursor_x = x - cursor_position.x(); |
- SkColor color = cursor_bitmap.getColor(cursor_x, cursor_y); |
- int alpha = SkColorGetA(color); |
- int color_r = SkColorGetR(color); |
- int color_g = SkColorGetG(color); |
- int color_b = SkColorGetB(color); |
- int color_y = clip_byte(((color_r * 66 + color_g * 129 + color_b * 25 + |
- 128) >> 8) + 16); |
- yplane[x] = alpha_blend(alpha, color_y, yplane[x]); |
- |
- // Only sample U and V at even coordinates. |
- if ((x % 2 == 0) && (y % 2 == 0)) { |
- int color_u = clip_byte(((color_r * -38 + color_g * -74 + |
- color_b * 112 + 128) >> 8) + 128); |
- int color_v = clip_byte(((color_r * 112 + color_g * -94 + |
- color_b * -18 + 128) >> 8) + 128); |
- uplane[x / 2] = alpha_blend(alpha, color_u, uplane[x / 2]); |
- vplane[x / 2] = alpha_blend(alpha, color_v, vplane[x / 2]); |
- } |
- } |
- } |
- cursor_bitmap.unlockPixels(); |
-} |
- |
-class DesktopVideoCaptureMachine |
- : public VideoCaptureMachine, |
- public aura::WindowObserver, |
- public ui::CompositorObserver, |
- public base::SupportsWeakPtr<DesktopVideoCaptureMachine> { |
- public: |
- DesktopVideoCaptureMachine(const DesktopMediaID& source); |
- ~DesktopVideoCaptureMachine() override; |
- |
- // VideoCaptureFrameSource overrides. |
- bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy, |
- const media::VideoCaptureParams& params) override; |
- void Stop(const base::Closure& callback) override; |
- |
- // Implements aura::WindowObserver. |
- void OnWindowBoundsChanged(aura::Window* window, |
- const gfx::Rect& old_bounds, |
- const gfx::Rect& new_bounds) override; |
- void OnWindowDestroyed(aura::Window* window) override; |
- void OnWindowAddedToRootWindow(aura::Window* window) override; |
- void OnWindowRemovingFromRootWindow(aura::Window* window, |
- aura::Window* new_root) override; |
- |
- // Implements ui::CompositorObserver. |
- void OnCompositingDidCommit(ui::Compositor* compositor) override {} |
- void OnCompositingStarted(ui::Compositor* compositor, |
- base::TimeTicks start_time) override {} |
- void OnCompositingEnded(ui::Compositor* compositor) override; |
- void OnCompositingAborted(ui::Compositor* compositor) override {} |
- void OnCompositingLockStateChanged(ui::Compositor* compositor) override {} |
- void OnCompositingShuttingDown(ui::Compositor* compositor) override {} |
- |
- private: |
- // Captures a frame. |
- // |dirty| is false for timer polls and true for compositor updates. |
- void Capture(bool dirty); |
- |
- // Update capture size. Must be called on the UI thread. |
- void UpdateCaptureSize(); |
- |
- // Response callback for cc::Layer::RequestCopyOfOutput(). |
- void DidCopyOutput( |
- scoped_refptr<media::VideoFrame> video_frame, |
- base::TimeTicks start_time, |
- const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, |
- scoped_ptr<cc::CopyOutputResult> result); |
- |
- // A helper which does the real work for DidCopyOutput. Returns true if |
- // succeeded. |
- bool ProcessCopyOutputResponse( |
- scoped_refptr<media::VideoFrame> video_frame, |
- base::TimeTicks start_time, |
- const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, |
- scoped_ptr<cc::CopyOutputResult> result); |
- |
- // Helper function to update cursor state. |
- // |region_in_frame| defines where the desktop is rendered in the captured |
- // frame. |
- // Returns the current cursor position in captured frame. |
- gfx::Point UpdateCursorState(const gfx::Rect& region_in_frame); |
- |
- // Clears cursor state. |
- void ClearCursorState(); |
- |
- // The window associated with the desktop. |
- aura::Window* desktop_window_; |
- |
- // The timer that kicks off period captures. |
- base::Timer timer_; |
- |
- // The id of the window being captured. |
- DesktopMediaID window_id_; |
- |
- // Makes all the decisions about which frames to copy, and how. |
- scoped_refptr<ThreadSafeCaptureOracle> oracle_proxy_; |
- |
- // The capture parameters for this capture. |
- media::VideoCaptureParams capture_params_; |
- |
- // YUV readback pipeline. |
- scoped_ptr<content::ReadbackYUVInterface> yuv_readback_pipeline_; |
- |
- // Cursor state. |
- ui::Cursor last_cursor_; |
- gfx::Size desktop_size_when_cursor_last_updated_; |
- gfx::Point cursor_hot_point_; |
- SkBitmap scaled_cursor_bitmap_; |
- |
- // TODO(jiayl): Remove power_save_blocker_ when there is an API to keep the |
- // screen from sleeping for the drive-by web. |
- scoped_ptr<PowerSaveBlocker> power_save_blocker_; |
- |
- DISALLOW_COPY_AND_ASSIGN(DesktopVideoCaptureMachine); |
-}; |
- |
-DesktopVideoCaptureMachine::DesktopVideoCaptureMachine( |
- const DesktopMediaID& source) |
- : desktop_window_(NULL), |
- timer_(true, true), |
- window_id_(source) {} |
- |
-DesktopVideoCaptureMachine::~DesktopVideoCaptureMachine() {} |
- |
-bool DesktopVideoCaptureMachine::Start( |
- const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy, |
- const media::VideoCaptureParams& params) { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- |
- desktop_window_ = content::DesktopMediaID::GetAuraWindowById(window_id_); |
- if (!desktop_window_) |
- return false; |
- |
- // If the associated layer is already destroyed then return failure. |
- ui::Layer* layer = desktop_window_->layer(); |
- if (!layer) |
- return false; |
- |
- DCHECK(oracle_proxy.get()); |
- oracle_proxy_ = oracle_proxy; |
- capture_params_ = params; |
- |
- // Update capture size. |
- UpdateCaptureSize(); |
- |
- // Start observing window events. |
- desktop_window_->AddObserver(this); |
- |
- // Start observing compositor updates. |
- if (desktop_window_->GetHost()) |
- desktop_window_->GetHost()->compositor()->AddObserver(this); |
- |
- power_save_blocker_.reset( |
- PowerSaveBlocker::Create( |
- PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep, |
- PowerSaveBlocker::kReasonOther, |
- "DesktopCaptureDevice is running").release()); |
- |
- // Starts timer. |
- timer_.Start(FROM_HERE, oracle_proxy_->min_capture_period(), |
- base::Bind(&DesktopVideoCaptureMachine::Capture, AsWeakPtr(), |
- false)); |
- |
- return true; |
-} |
- |
-void DesktopVideoCaptureMachine::Stop(const base::Closure& callback) { |
+void SetCaptureSource(AuraWindowCaptureMachine* machine, |
+ const DesktopMediaID& source) { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- power_save_blocker_.reset(); |
- |
- // Stop observing compositor and window events. |
- if (desktop_window_) { |
- aura::WindowTreeHost* window_host = desktop_window_->GetHost(); |
- // In the host destructor the compositor is destroyed before the window. |
- if (window_host && window_host->compositor()) |
- window_host->compositor()->RemoveObserver(this); |
- desktop_window_->RemoveObserver(this); |
- desktop_window_ = NULL; |
- } |
- // Stop timer. |
- timer_.Stop(); |
- |
- callback.Run(); |
-} |
- |
-void DesktopVideoCaptureMachine::UpdateCaptureSize() { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- if (oracle_proxy_.get() && desktop_window_) { |
- ui::Layer* layer = desktop_window_->layer(); |
- oracle_proxy_->UpdateCaptureSize(ui::ConvertSizeToPixel( |
- layer, layer->bounds().size())); |
- } |
- ClearCursorState(); |
-} |
- |
-void DesktopVideoCaptureMachine::Capture(bool dirty) { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- |
- // Do not capture if the desktop window is already destroyed. |
- if (!desktop_window_) |
- return; |
- |
- scoped_refptr<media::VideoFrame> frame; |
- ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb; |
- |
- const base::TimeTicks start_time = base::TimeTicks::Now(); |
- const VideoCaptureOracle::Event event = |
- dirty ? VideoCaptureOracle::kCompositorUpdate |
- : VideoCaptureOracle::kTimerPoll; |
- if (oracle_proxy_->ObserveEventAndDecideCapture( |
- event, gfx::Rect(), start_time, &frame, &capture_frame_cb)) { |
- scoped_ptr<cc::CopyOutputRequest> request = |
- cc::CopyOutputRequest::CreateRequest( |
- base::Bind(&DesktopVideoCaptureMachine::DidCopyOutput, |
- AsWeakPtr(), frame, start_time, capture_frame_cb)); |
- gfx::Rect window_rect = gfx::Rect(desktop_window_->bounds().width(), |
- desktop_window_->bounds().height()); |
- request->set_area(window_rect); |
- desktop_window_->layer()->RequestCopyOfOutput(request.Pass()); |
- } |
-} |
- |
-void CopyOutputFinishedForVideo( |
- base::TimeTicks start_time, |
- const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, |
- const scoped_refptr<media::VideoFrame>& target, |
- const SkBitmap& cursor_bitmap, |
- const gfx::Point& cursor_position, |
- scoped_ptr<cc::SingleReleaseCallback> release_callback, |
- bool result) { |
- if (!cursor_bitmap.isNull()) |
- RenderCursorOnVideoFrame(target, cursor_bitmap, cursor_position); |
- release_callback->Run(0, false); |
- capture_frame_cb.Run(target, start_time, result); |
-} |
- |
-void RunSingleReleaseCallback(scoped_ptr<cc::SingleReleaseCallback> cb, |
- uint32 sync_point) { |
- cb->Run(sync_point, false); |
-} |
- |
-void DesktopVideoCaptureMachine::DidCopyOutput( |
- scoped_refptr<media::VideoFrame> video_frame, |
- base::TimeTicks start_time, |
- const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, |
- scoped_ptr<cc::CopyOutputResult> result) { |
- static bool first_call = true; |
- |
- bool succeeded = ProcessCopyOutputResponse( |
- video_frame, start_time, capture_frame_cb, result.Pass()); |
- |
- base::TimeDelta capture_time = base::TimeTicks::Now() - start_time; |
- |
- // The two UMA_ blocks must be put in its own scope since it creates a static |
- // variable which expected constant histogram name. |
- if (window_id_.type == DesktopMediaID::TYPE_SCREEN) { |
- UMA_HISTOGRAM_TIMES(kUmaScreenCaptureTime, capture_time); |
- } else { |
- UMA_HISTOGRAM_TIMES(kUmaWindowCaptureTime, capture_time); |
- } |
- |
- if (first_call) { |
- first_call = false; |
- if (window_id_.type == DesktopMediaID::TYPE_SCREEN) { |
- IncrementDesktopCaptureCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED |
- : FIRST_SCREEN_CAPTURE_FAILED); |
- } else { |
- IncrementDesktopCaptureCounter(succeeded |
- ? FIRST_WINDOW_CAPTURE_SUCCEEDED |
- : FIRST_WINDOW_CAPTURE_FAILED); |
- } |
- } |
-} |
- |
-bool DesktopVideoCaptureMachine::ProcessCopyOutputResponse( |
- scoped_refptr<media::VideoFrame> video_frame, |
- base::TimeTicks start_time, |
- const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb, |
- scoped_ptr<cc::CopyOutputResult> result) { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- |
- if (result->IsEmpty() || result->size().IsEmpty() || !desktop_window_) |
- return false; |
- |
- if (capture_params_.requested_format.pixel_format == |
- media::PIXEL_FORMAT_TEXTURE) { |
- DCHECK(!video_frame.get()); |
- cc::TextureMailbox texture_mailbox; |
- scoped_ptr<cc::SingleReleaseCallback> release_callback; |
- result->TakeTexture(&texture_mailbox, &release_callback); |
- DCHECK(texture_mailbox.IsTexture()); |
- if (!texture_mailbox.IsTexture()) |
- return false; |
- video_frame = media::VideoFrame::WrapNativeTexture( |
- make_scoped_ptr(new gpu::MailboxHolder(texture_mailbox.mailbox(), |
- texture_mailbox.target(), |
- texture_mailbox.sync_point())), |
- base::Bind(&RunSingleReleaseCallback, base::Passed(&release_callback)), |
- result->size(), gfx::Rect(result->size()), result->size(), |
- base::TimeDelta(), false); |
- capture_frame_cb.Run(video_frame, start_time, true); |
- return true; |
- } else { |
- DCHECK(video_frame.get()); |
- } |
- |
- // Compute the dest size we want after the letterboxing resize. Make the |
- // coordinates and sizes even because we letterbox in YUV space |
- // (see CopyRGBToVideoFrame). They need to be even for the UV samples to |
- // line up correctly. |
- // The video frame's visible_rect() and the result's size() are both physical |
- // pixels. |
- gfx::Rect region_in_frame = media::ComputeLetterboxRegion( |
- video_frame->visible_rect(), result->size()); |
- region_in_frame = gfx::Rect(region_in_frame.x() & ~1, |
- region_in_frame.y() & ~1, |
- region_in_frame.width() & ~1, |
- region_in_frame.height() & ~1); |
- if (region_in_frame.IsEmpty()) |
- return false; |
- |
- ImageTransportFactory* factory = ImageTransportFactory::GetInstance(); |
- GLHelper* gl_helper = factory->GetGLHelper(); |
- if (!gl_helper) |
- return false; |
- |
- cc::TextureMailbox texture_mailbox; |
- scoped_ptr<cc::SingleReleaseCallback> release_callback; |
- result->TakeTexture(&texture_mailbox, &release_callback); |
- DCHECK(texture_mailbox.IsTexture()); |
- if (!texture_mailbox.IsTexture()) |
- return false; |
- |
- gfx::Rect result_rect(result->size()); |
- if (!yuv_readback_pipeline_ || |
- yuv_readback_pipeline_->scaler()->SrcSize() != result_rect.size() || |
- yuv_readback_pipeline_->scaler()->SrcSubrect() != result_rect || |
- yuv_readback_pipeline_->scaler()->DstSize() != region_in_frame.size()) { |
- yuv_readback_pipeline_.reset( |
- gl_helper->CreateReadbackPipelineYUV(GLHelper::SCALER_QUALITY_FAST, |
- result_rect.size(), |
- result_rect, |
- region_in_frame.size(), |
- true, |
- true)); |
- } |
- |
- gfx::Point cursor_position_in_frame = UpdateCursorState(region_in_frame); |
- yuv_readback_pipeline_->ReadbackYUV( |
- texture_mailbox.mailbox(), |
- texture_mailbox.sync_point(), |
- video_frame.get(), |
- region_in_frame.origin(), |
- base::Bind(&CopyOutputFinishedForVideo, |
- start_time, |
- capture_frame_cb, |
- video_frame, |
- scaled_cursor_bitmap_, |
- cursor_position_in_frame, |
- base::Passed(&release_callback))); |
- return true; |
-} |
- |
-gfx::Point DesktopVideoCaptureMachine::UpdateCursorState( |
- const gfx::Rect& region_in_frame) { |
- const gfx::Rect desktop_bounds = desktop_window_->layer()->bounds(); |
- if (desktop_bounds.IsEmpty()) { |
- // Return early to prevent divide-by-zero in calculations below. |
- ClearCursorState(); |
- return gfx::Point(); |
- } |
- |
- gfx::NativeCursor cursor = |
- desktop_window_->GetHost()->last_cursor(); |
- if (last_cursor_ != cursor || |
- desktop_size_when_cursor_last_updated_ != desktop_bounds.size()) { |
- SkBitmap cursor_bitmap; |
- if (ui::GetCursorBitmap(cursor, &cursor_bitmap, &cursor_hot_point_)) { |
- const int scaled_width = cursor_bitmap.width() * |
- region_in_frame.width() / desktop_bounds.width(); |
- const int scaled_height = cursor_bitmap.height() * |
- region_in_frame.height() / desktop_bounds.height(); |
- if (scaled_width <= 0 || scaled_height <= 0) { |
- ClearCursorState(); |
- return gfx::Point(); |
- } |
- scaled_cursor_bitmap_ = skia::ImageOperations::Resize( |
- cursor_bitmap, |
- skia::ImageOperations::RESIZE_BEST, |
- scaled_width, |
- scaled_height); |
- last_cursor_ = cursor; |
- desktop_size_when_cursor_last_updated_ = desktop_bounds.size(); |
- } else { |
- // Clear cursor state if ui::GetCursorBitmap failed so that we do not |
- // render cursor on the captured frame. |
- ClearCursorState(); |
- } |
- } |
- |
- gfx::Point cursor_position = aura::Env::GetInstance()->last_mouse_location(); |
- aura::client::GetScreenPositionClient(desktop_window_->GetRootWindow())-> |
- ConvertPointFromScreen(desktop_window_, &cursor_position); |
- const gfx::Point hot_point_in_dip = ui::ConvertPointToDIP( |
- desktop_window_->layer(), cursor_hot_point_); |
- cursor_position.Offset(-desktop_bounds.x() - hot_point_in_dip.x(), |
- -desktop_bounds.y() - hot_point_in_dip.y()); |
- return gfx::Point( |
- region_in_frame.x() + cursor_position.x() * region_in_frame.width() / |
- desktop_bounds.width(), |
- region_in_frame.y() + cursor_position.y() * region_in_frame.height() / |
- desktop_bounds.height()); |
-} |
- |
-void DesktopVideoCaptureMachine::ClearCursorState() { |
- last_cursor_ = ui::Cursor(); |
- desktop_size_when_cursor_last_updated_ = gfx::Size(); |
- cursor_hot_point_ = gfx::Point(); |
- scaled_cursor_bitmap_.reset(); |
-} |
- |
-void DesktopVideoCaptureMachine::OnWindowBoundsChanged( |
- aura::Window* window, |
- const gfx::Rect& old_bounds, |
- const gfx::Rect& new_bounds) { |
- DCHECK(desktop_window_ && window == desktop_window_); |
- |
- // Post task to update capture size on UI thread. |
- BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind( |
- &DesktopVideoCaptureMachine::UpdateCaptureSize, AsWeakPtr())); |
-} |
- |
-void DesktopVideoCaptureMachine::OnWindowDestroyed(aura::Window* window) { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- |
- Stop(base::Bind(&base::DoNothing)); |
- |
- oracle_proxy_->ReportError("OnWindowDestroyed()"); |
-} |
- |
-void DesktopVideoCaptureMachine::OnWindowAddedToRootWindow( |
- aura::Window* window) { |
- DCHECK(window == desktop_window_); |
- window->GetHost()->compositor()->AddObserver(this); |
-} |
- |
-void DesktopVideoCaptureMachine::OnWindowRemovingFromRootWindow( |
- aura::Window* window, |
- aura::Window* new_root) { |
- DCHECK(window == desktop_window_); |
- window->GetHost()->compositor()->RemoveObserver(this); |
-} |
- |
-void DesktopVideoCaptureMachine::OnCompositingEnded( |
- ui::Compositor* compositor) { |
- BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind( |
- &DesktopVideoCaptureMachine::Capture, AsWeakPtr(), true)); |
+ aura::Window* window = DesktopMediaID::GetAuraWindowById(source); |
+ machine->SetWindow(window); |
} |
} // namespace |
-DesktopCaptureDeviceAura::DesktopCaptureDeviceAura( |
- const DesktopMediaID& source) |
- : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>( |
- new DesktopVideoCaptureMachine(source)))) {} |
- |
-DesktopCaptureDeviceAura::~DesktopCaptureDeviceAura() { |
- DVLOG(2) << "DesktopCaptureDeviceAura@" << this << " destroying."; |
-} |
- |
// static |
media::VideoCaptureDevice* DesktopCaptureDeviceAura::Create( |
const DesktopMediaID& source) { |
- IncrementDesktopCaptureCounter(source.type == DesktopMediaID::TYPE_SCREEN |
- ? SCREEN_CAPTURER_CREATED |
- : WINDOW_CAPTURER_CREATED); |
- return new DesktopCaptureDeviceAura(source); |
+ DesktopCaptureDeviceAura* device = new DesktopCaptureDeviceAura(); |
+ |
+ BrowserThread::PostTask( |
Sergey Ulanov
2015/03/04 18:48:58
Move this to DesktopCaptureDeviceAura() constructo
robert.bradford
2015/03/04 21:05:10
Done although I had to make the scoped_ptr for cor
|
+ BrowserThread::UI, FROM_HERE, |
+ base::Bind(&SetCaptureSource, device->machine_, source)); |
+ return device; |
} |
void DesktopCaptureDeviceAura::AllocateAndStart( |