Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/renderer/pepper/pepper_graphics_2d_host.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/pepper/pepper_graphics_2d_host.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 260 matching lines @@
   SkIRect src_irect = { x, y,
                         x + image_resource->width(),
                         y + image_resource->height() };
   SkRect dest_rect = { SkIntToScalar(0),
                        SkIntToScalar(0),
                        SkIntToScalar(image_resource->width()),
                        SkIntToScalar(image_resource->height()) };
 
   if (image_resource->format() != image_data_->format()) {
     // Convert the image data if the format does not match.
-    ConvertImageData(image_data_, src_irect, image_resource, dest_rect);
+    ConvertImageData(image_data_.get(), src_irect, image_resource, dest_rect);
   } else {
     SkCanvas* dest_canvas = image_resource->GetCanvas();
 
     // We want to replace the contents of the bitmap rather than blend.
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     dest_canvas->drawBitmapRect(*image_data_->GetMappedBitmap(),
                                 &src_irect, dest_rect, &paint);
   }
   return true;
@@ skipping 23 matching lines @@
   return true;
 }
 
 // The |backing_bitmap| must be clipped to the |plugin_rect| to avoid painting
 // outside the plugin area. This can happen if the plugin has been resized since
 // PaintImageData verified the image is within the plugin size.
 void PepperGraphics2DHost::Paint(WebKit::WebCanvas* canvas,
                                  const gfx::Rect& plugin_rect,
                                  const gfx::Rect& paint_rect) {
   TRACE_EVENT0("pepper", "PepperGraphics2DHost::Paint");
-  ImageDataAutoMapper auto_mapper(image_data_);
+  ImageDataAutoMapper auto_mapper(image_data_.get());
   const SkBitmap& backing_bitmap = *image_data_->GetMappedBitmap();
 
   gfx::Rect invalidate_rect = plugin_rect;
   invalidate_rect.Intersect(paint_rect);
   SkRect sk_invalidate_rect = gfx::RectToSkRect(invalidate_rect);
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->clipRect(sk_invalidate_rect);
   gfx::Size pixel_image_size(image_data_->width(), image_data_->height());
   gfx::Size image_size = gfx::ToFlooredSize(
       gfx::ScaleSize(pixel_image_size, scale_));
@@ skipping 220 matching lines @@
 
 int32_t PepperGraphics2DHost::Flush(PP_Resource* old_image_data) {
   bool done_replace_contents = false;
   bool no_update_visible = true;
   bool is_plugin_visible = true;
   for (size_t i = 0; i < queued_operations_.size(); i++) {
     QueuedOperation& operation = queued_operations_[i];
     gfx::Rect op_rect;
     switch (operation.type) {
       case QueuedOperation::PAINT:
-        ExecutePaintImageData(operation.paint_image,
-                              operation.paint_x, operation.paint_y,
+        ExecutePaintImageData(operation.paint_image.get(),
+                              operation.paint_x,
+                              operation.paint_y,
                               operation.paint_src_rect,
                               &op_rect);
         break;
       case QueuedOperation::SCROLL:
         ExecuteScroll(operation.scroll_clip_rect,
                       operation.scroll_dx, operation.scroll_dy,
                       &op_rect);
         break;
       case QueuedOperation::REPLACE:
         // Since the out parameter |old_image_data| takes ownership of the
         // reference, if there are more than one ReplaceContents calls queued
         // the first |old_image_data| will get overwritten and leaked. So we
         // only supply this for the first call.
-        ExecuteReplaceContents(operation.replace_image, &op_rect,
+        ExecuteReplaceContents(operation.replace_image.get(),
+                               &op_rect,
                                done_replace_contents ? NULL : old_image_data);
         done_replace_contents = true;
         break;
     }
 
     // For correctness with accelerated compositing, we must issue an invalidate
     // on the full op_rect even if it is partially or completely off-screen.
     // However, if we issue an invalidate for a clipped-out region, WebKit will
     // do nothing and we won't get any ViewWillInitiatePaint/ViewFlushedPaint
     // calls, leaving our callback stranded. So we still need to check whether
@@ skipping 61 matching lines @@
   // Location within the backing store to copy to.
   *invalidated_rect = src_rect;
   invalidated_rect->Offset(x, y);
   SkRect dest_rect = { SkIntToScalar(invalidated_rect->x()),
                        SkIntToScalar(invalidated_rect->y()),
                        SkIntToScalar(invalidated_rect->right()),
                        SkIntToScalar(invalidated_rect->bottom()) };
 
   if (image->format() != image_data_->format()) {
     // Convert the image data if the format does not match.
-    ConvertImageData(image, src_irect, image_data_, dest_rect);
+    ConvertImageData(image, src_irect, image_data_.get(), dest_rect);
   } else {
     // We're guaranteed to have a mapped canvas since we mapped it in Init().
     SkCanvas* backing_canvas = image_data_->GetCanvas();
 
     // We want to replace the contents of the bitmap rather than blend.
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     backing_canvas->drawBitmapRect(*image->GetMappedBitmap(),
                                    &src_irect, dest_rect, &paint);
   }
@@ skipping 12 matching lines @@
                                                  PP_Resource* old_image_data) {
   if (image->format() != image_data_->format()) {
     DCHECK(image->width() == image_data_->width() &&
            image->height() == image_data_->height());
     // Convert the image data if the format does not match.
     SkIRect src_irect = { 0, 0, image->width(), image->height() };
     SkRect dest_rect = { SkIntToScalar(0),
                          SkIntToScalar(0),
                          SkIntToScalar(image_data_->width()),
                          SkIntToScalar(image_data_->height()) };
-    ConvertImageData(image, src_irect, image_data_, dest_rect);
+    ConvertImageData(image, src_irect, image_data_.get(), dest_rect);
   } else {
     // The passed-in image may not be mapped in our process, and we need to
     // guarantee that the current backing store is always mapped.
     if (!image->Map())
       return;
 
     if (old_image_data)
       *old_image_data = image_data_->GetReference();
     image_data_ = image;
   }
@@ skipping 53 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ToFlooredPoint(gfx::ScalePoint(*delta, inverse_scale));
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content