Pepper Flash Mac: Fix crash when playing video on MB retina

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 650 matching lines @@
     // we don't accidentally clear other update rects.
     canvas->save();
     canvas->clipRect(gfx::RectToSkRect(rect));
     canvas->drawPaint(paint);
     canvas->restore();
   }
 
   // First see if this rect is a plugin that can paint itself faster.
   TransportDIB* optimized_dib = NULL;
   gfx::Rect optimized_copy_rect, optimized_copy_location;
+  float dib_scale_factor;
   webkit::ppapi::PluginInstance* optimized_instance =
       GetBitmapForOptimizedPluginPaint(rect, &optimized_dib,
                                        &optimized_copy_location,
-                                       &optimized_copy_rect);
+                                       &optimized_copy_rect,
+                                       &dib_scale_factor);
   if (optimized_instance) {
     // This plugin can be optimize-painted and we can just ask it to paint
     // itself. We don't actually need the TransportDIB in this case.
     //
     // This is an optimization for PPAPI plugins that know they're on top of
     // the page content. If this rect is inside such a plugin, we can save some
     // time and avoid re-rendering the page content which we know will be
     // covered by the plugin later (this time can be significant, especially
     // for a playing movie that is invalidating a lot).
     //
@@ skipping 239 matching lines @@
   // the page (like a traditional windowed plugin) to be able to animate (think
   // movie playing) without repeatedly re-painting the page underneath, or
   // copying the plugin backing store (since we can send the plugin's backing
   // store directly to the browser).
   //
   // This optimization only works when the entire invalid region is contained
   // within the plugin. There is a related optimization in PaintRect for the
   // case where there may be multiple invalid regions.
   TransportDIB* dib = NULL;
   gfx::Rect optimized_copy_rect, optimized_copy_location;
+  float dib_scale_factor = 1;
   DCHECK(!pending_update_params_.get());
   pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
   pending_update_params_->dx = update.scroll_delta.x();
   pending_update_params_->dy = update.scroll_delta.y();
   pending_update_params_->scroll_rect = update.scroll_rect;
   pending_update_params_->view_size = size_;
   pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
   pending_update_params_->flags = next_paint_flags_;
   pending_update_params_->scroll_offset = GetScrollOffset();
   pending_update_params_->needs_ack = true;
   pending_update_params_->scale_factor = device_scale_factor_;
   next_paint_flags_ = 0;
   need_update_rect_for_auto_resize_ = false;
 
   if (update.scroll_rect.IsEmpty() &&
       !is_accelerated_compositing_active_ &&
       GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
-                                       &optimized_copy_rect)) {
+                                       &optimized_copy_rect,
+                                       &dib_scale_factor)) {
     // Only update the part of the plugin that actually changed.
     optimized_copy_rect = optimized_copy_rect.Intersect(bounds);
     pending_update_params_->bitmap = dib->id();
     pending_update_params_->bitmap_rect = optimized_copy_location;
     pending_update_params_->copy_rects.push_back(optimized_copy_rect);
+    pending_update_params_->scale_factor = dib_scale_factor;
   } else if (!is_accelerated_compositing_active_) {
     // Compute a buffer for painting and cache it.
     gfx::Rect pixel_bounds = bounds.Scale(device_scale_factor_);
     scoped_ptr<skia::PlatformCanvas> canvas(
         RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
                                                    pixel_bounds));
     if (!canvas.get()) {
       NOTREACHED();
       return;
     }
@@ skipping 583 matching lines @@
 
 void RenderWidget::OnScreenInfoChanged(
     const WebKit::WebScreenInfo& screen_info) {
   screen_info_ = screen_info;
 }
 
 webkit::ppapi::PluginInstance* RenderWidget::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
-    gfx::Rect* clip) {
+    gfx::Rect* clip,
+    float* scale_factor) {
   // Bare RenderWidgets don't support optimized plugin painting.
   return NULL;
 }
 
 gfx::Point RenderWidget::GetScrollOffset() {
   // Bare RenderWidgets don't support scroll offset.
   return gfx::Point(0, 0);
 }
 
 void RenderWidget::SetHidden(bool hidden) {
@@ skipping 263 matching lines @@
   pending_smooth_scroll_gestures_.insert(std::make_pair(id, callback));
 }
 
 bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   return false;
 }
 
 bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
   return false;
 }