Crash fix for desktop capture size calculations, and some minor things.

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 127 matching lines @@
 
   // 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 the desktop bound in the captured frame.
+  // |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);
 };
 
@@ skipping 155 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_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());
@@ skipping 42 matching lines @@
                  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) {
+  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,
-          cursor_bitmap.width() * region_in_frame.width() /
-              desktop_bounds.width(),
-          cursor_bitmap.height() * region_in_frame.height() /
-              desktop_bounds.height());
+          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_);
 
@@ skipping 54 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