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 131 matching lines @@
       scoped_ptr<cc::CopyOutputResult> result);
 
   // Helper function to update cursor state.
   // |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();
 
+  // Helper function to return the layer associated with the desktop window.
+  ui::Layer* desktop_layer();
+
   // 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_)
+  ui::Layer* layer = desktop_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();
+  ui::Compositor* compositor = layer->GetCompositor();
   if (!compositor)
     return false;
 
   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 compositor updates.
+  ui::Layer* layer = desktop_layer();
+  if (layer) {
+    ui::Compositor* compositor = layer->GetCompositor();
+    if (compositor)
+      compositor->RemoveObserver(this);

[piman, 2014/06/19 21:59:19]

If the layer can change, how do you know the compositor is the same as the one
in Start() ?

(well, even if it doesn't change, that may not even be true).

How about observing the window and check when it's added/removed from the tree,
and attach/detach from the compositor (that you get from the WindowTreeHost via
desktop_window_->GetHost()).

This is what we do in RenderWidgetHostViewAura.

[hshi1, 2014/06/19 22:19:33]

Done.

+  }
+
   // Stop observing window events.
   if (desktop_window_) {
     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_) {
+  ui::Layer* layer = desktop_layer();
+  if (oracle_proxy_ && 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_)
+  ui::Layer* layer = desktop_layer();
+  if (!layer)

[danakj, 2014/06/19 21:43:28]

Why are there so many checks for layer when Start() returns false if there's no
layer?

[hshi1, 2014/06/19 22:19:33]

Done.

     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());
+    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_layer())
     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_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_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();
   cursor_hot_point_ = gfx::Point();
   scaled_cursor_bitmap_.reset();
 }
 
+ui::Layer* DesktopVideoCaptureMachine::desktop_layer() {
+  if (!desktop_window_)
+    return NULL;
+  return desktop_window_->layer();
+}
+
 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()));
 }
@@ skipping 37 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