Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

chrome/browser/thumbnails/content_based_thumbnailing_algorithm.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 "chrome/browser/thumbnails/content_based_thumbnailing_algorithm.h"
 
 #include "base/metrics/histogram.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/thumbnails/content_analysis.h"
 #include "chrome/browser/thumbnails/simple_thumbnail_crop.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/scrollbar_size.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
 
 const char kThumbnailHistogramName[] = "Thumbnail.RetargetMS";
 const char kFailureHistogramName[] = "Thumbnail.FailedRetargetMS";
 const float kScoreBoostFromSuccessfulRetargeting = 1.1f;
 
 void CallbackInvocationAdapter(
     const thumbnails::ThumbnailingAlgorithm::ConsumerCallback& callback,
     scoped_refptr<thumbnails::ThumbnailingContext> context,
     const SkBitmap& source_bitmap) {
-  callback.Run(*context, source_bitmap);
+  callback.Run(*context.get(), source_bitmap);
 }
 
 }  // namespace
 
 namespace thumbnails {
 
 using content::BrowserThread;
 
 ContentBasedThumbnailingAlgorithm::ContentBasedThumbnailingAlgorithm(
     const gfx::Size& target_size)
@@ skipping 14 matching lines @@
   *clipping_rect = GetClippingRect(
       source_size, target_thumbnail_size, target_size, &clipping_method);
   return clipping_method;
 }
 
 void ContentBasedThumbnailingAlgorithm::ProcessBitmap(
     scoped_refptr<ThumbnailingContext> context,
     const ConsumerCallback& callback,
     const SkBitmap& bitmap) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(context);
+  DCHECK(context.get());
   if (bitmap.isNull() || bitmap.empty())
     return;
 
   gfx::Size target_thumbnail_size =
       SimpleThumbnailCrop::ComputeTargetSizeAtMaximumScale(target_size_);
 
-  SkBitmap source_bitmap = PrepareSourceBitmap(
-      bitmap, target_thumbnail_size, context);
+  SkBitmap source_bitmap =
+      PrepareSourceBitmap(bitmap, target_thumbnail_size, context.get());
 
   // If the source is same (or smaller) than the target, just return it as
   // the final result. Otherwise, send the shrinking task to the blocking
   // thread pool.
   if (source_bitmap.width() <= target_thumbnail_size.width() ||
       source_bitmap.height() <= target_thumbnail_size.height()) {
     context->score.boring_score =
         SimpleThumbnailCrop::CalculateBoringScore(source_bitmap);
     context->score.good_clipping =
         (context->clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
          context->clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
          context->clip_result == CLIP_RESULT_NOT_CLIPPED ||
          context->clip_result == CLIP_RESULT_SOURCE_SAME_AS_TARGET);
 
-    callback.Run(*context, source_bitmap);
+    callback.Run(*context.get(), source_bitmap);
     return;
   }
 
   if (!BrowserThread::GetBlockingPool()->PostWorkerTaskWithShutdownBehavior(
           FROM_HERE,
           base::Bind(&CreateRetargetedThumbnail,
                      source_bitmap,
                      target_thumbnail_size,
                      context,
                      callback),
@@ skipping 131 matching lines @@
   } else {
     clipping_rect = gfx::Rect(source_size);
     target_size->SetSize(source_size.width() / 2, source_size.height() / 2);
     *clip_result = CLIP_RESULT_NOT_CLIPPED;
   }
 
   return clipping_rect;
 }
 
 }  // namespace thumbnails