DesktopVideoCaptureMachine: do not cache window layer pointer.

content/browser/media/capture/desktop_capture_device_aura.cc

 // Copyright 2013 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 "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"
@@ skipping 90 matching lines @@
   // VideoCaptureFrameSource overrides.
   virtual bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
                      const media::VideoCaptureParams& params) OVERRIDE;
   virtual void Stop(const base::Closure& callback) OVERRIDE;
 
   // Implements aura::WindowObserver.
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE;
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+  virtual void OnWindowAddedToRootWindow(aura::Window* window) OVERRIDE;
+  virtual void OnWindowRemovingFromRootWindow(aura::Window* window,
+                                              aura::Window* new_root) OVERRIDE;
 
   // Implements ui::CompositorObserver.
   virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE {}
   virtual void OnCompositingStarted(ui::Compositor* compositor,
                                     base::TimeTicks start_time) OVERRIDE {}
   virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingAborted(ui::Compositor* compositor) OVERRIDE {}
   virtual void OnCompositingLockStateChanged(
       ui::Compositor* compositor) OVERRIDE {}
 
@@ skipping 24 matching lines @@
   // |region_in_frame| defines the desktop bound 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 layer associated with the desktop.
-  ui::Layer* desktop_layer_;
-
   // 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::Point cursor_hot_point_;
   SkBitmap scaled_cursor_bitmap_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopVideoCaptureMachine);
 };
 
 DesktopVideoCaptureMachine::DesktopVideoCaptureMachine(
     const DesktopMediaID& source)
     : desktop_window_(NULL),
-      desktop_layer_(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 desktop layer is already destroyed then return failure.
-  desktop_layer_ = desktop_window_->layer();
-  if (!desktop_layer_)
+  // 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.
-  ui::Compositor* compositor = desktop_layer_->GetCompositor();
-  if (!compositor)
-    return false;
-
-  compositor->AddObserver(this);
+  if (desktop_window_->GetHost())
+    desktop_window_->GetHost()->compositor()->AddObserver(this);
 
   // Starts timer.
   timer_.Start(FROM_HERE, oracle_proxy_->capture_period(),
                base::Bind(&DesktopVideoCaptureMachine::Capture, AsWeakPtr(),
                           false));
 
   started_ = true;
   return true;
 }
 
 void DesktopVideoCaptureMachine::Stop(const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Stop observing window events.
+  // Stop observing compositor and window events.
   if (desktop_window_) {
+    if (desktop_window_->GetHost())
+      desktop_window_->GetHost()->compositor()->RemoveObserver(this);
     desktop_window_->RemoveObserver(this);
     desktop_window_ = NULL;
   }
 
-  // Stop observing compositor updates.
-  if (desktop_layer_) {
-    ui::Compositor* compositor = desktop_layer_->GetCompositor();
-    if (compositor)
-      compositor->RemoveObserver(this);
-    desktop_layer_ = NULL;
-  }
-
   // Stop timer.
   timer_.Stop();
 
   started_ = false;
 
   callback.Run();
 }
 
 void DesktopVideoCaptureMachine::UpdateCaptureSize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (oracle_proxy_ && desktop_layer_) {
+  if (oracle_proxy_ && desktop_window_) {
+    ui::Layer* layer = desktop_window_->layer();
     oracle_proxy_->UpdateCaptureSize(ui::ConvertSizeToPixel(
-        desktop_layer_, desktop_layer_->bounds().size()));
+        layer, layer->bounds().size()));
   }
   ClearCursorState();
 }
 
 void DesktopVideoCaptureMachine::Capture(bool dirty) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Do not capture if the desktop layer is already destroyed.
-  if (!desktop_layer_)
+  // Do not capture if the desktop window is already destroyed.

[danakj, 2014/06/19 22:22:05]

Can this happen now that we watch for OnWindowRemovingFromRootWindow? (not sure
if it can, but wondering)

[piman, 2014/06/19 23:11:48]

I think currently it does because OnCompositingEnded posts a task and so there
could still be such a task in flight when OnWindowRemovingFromRootWindow is
called.

However I don't think OnCompositingEnded needs to post a task (UI->UI), if that
is fixed then I think it'd be unnecessary.

[danakj, 2014/06/19 23:22:37]

Ah, then LGTM but it sounds like it'd be nice to fix :)

+  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, 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 =
         ui::ConvertRectToPixel(desktop_window_->layer(),
                                gfx::Rect(desktop_window_->bounds().width(),
                                          desktop_window_->bounds().height()));
     request->set_area(window_rect);
-    desktop_layer_->RequestCopyOfOutput(request.Pass());
+    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,
@@ skipping 43 matching lines @@
     }
   }
 }
 
 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_layer_)
+  if (result->IsEmpty() || result->size().IsEmpty() || !desktop_window_)
     return false;
 
   if (capture_params_.requested_format.pixel_format ==
       media::PIXEL_FORMAT_TEXTURE) {
     DCHECK(!video_frame);
     cc::TextureMailbox texture_mailbox;
     scoped_ptr<cc::SingleReleaseCallback> release_callback;
     result->TakeTexture(&texture_mailbox, &release_callback);
     DCHECK(texture_mailbox.IsTexture());
     if (!texture_mailbox.IsTexture())
@@ skipping 66 matching lines @@
                  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_layer_->bounds();
+  const gfx::Rect desktop_bounds = desktop_window_->layer()->bounds();
   gfx::NativeCursor cursor =
       desktop_window_->GetHost()->last_cursor();
   if (last_cursor_ != cursor) {
     SkBitmap cursor_bitmap;
     if (ui::GetCursorBitmap(cursor, &cursor_bitmap, &cursor_hot_point_)) {
       scaled_cursor_bitmap_ = skia::ImageOperations::Resize(
           cursor_bitmap,
           skia::ImageOperations::RESIZE_BEST,
           cursor_bitmap.width() * region_in_frame.width() /
               desktop_bounds.width(),
           cursor_bitmap.height() * region_in_frame.height() /
               desktop_bounds.height());
       last_cursor_ = cursor;
     } 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_layer_, cursor_hot_point_);
+      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() {
@@ skipping 14 matching lines @@
 }
 
 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) {
+  if (window == desktop_window_)

[piman, 2014/06/19 23:11:49]

nit: you can DCHECK, since that's the only window you're observing.

[hshi1, 2014/06/19 23:53:07]

Done.

+    window->GetHost()->compositor()->AddObserver(this);
+}
+
+void DesktopVideoCaptureMachine::OnWindowRemovingFromRootWindow(
+    aura::Window* window,
+    aura::Window* new_root) {
+  if (window == desktop_window_)

[piman, 2014/06/19 23:11:49]

same here.

[hshi1, 2014/06/19 23:53:07]

Done.

+      window->GetHost()->compositor()->RemoveObserver(this);
+}
+
 void DesktopVideoCaptureMachine::OnCompositingEnded(
     ui::Compositor* compositor) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &DesktopVideoCaptureMachine::Capture, AsWeakPtr(), true));
 }
 
 }  // namespace
 
 DesktopCaptureDeviceAura::DesktopCaptureDeviceAura(
     const DesktopMediaID& source)
@@ skipping 18 matching lines @@
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   core_->AllocateAndStart(params, client.Pass());
 }
 
 void DesktopCaptureDeviceAura::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content