Media gallery fixups for scoped_refptr<T> operator T* removal.

chrome/utility/media_galleries/image_metadata_extractor.cc

 // Copyright 2014 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/utility/media_galleries/image_metadata_extractor.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
@@ skipping 10 matching lines @@
 #include <libexif/exif-data.h>
 #include <libexif/exif-loader.h>
 }  // extern "C"
 
 namespace metadata {
 
 namespace {
 
 const size_t kMaxBufferSize = 50 * 1024 * 1024;  // Arbitrary maximum of 50MB.
 
+typedef base::Callback<void(const scoped_refptr<net::DrainableIOBuffer>&)>
+    GotImageCallback;
+
 void FinishGetImageBytes(
-    net::DrainableIOBuffer* buffer,
+    const scoped_refptr<net::DrainableIOBuffer>& buffer,
     media::DataSource* source,
-    const base::Callback<void(net::DrainableIOBuffer*)>& callback,
+    const GotImageCallback& callback,
     int bytes_read) {
   if (bytes_read == media::DataSource::kReadError) {
     callback.Run(NULL);
     return;
   }
 
   buffer->DidConsume(bytes_read);
   // Didn't get the whole file. Continue reading to get the rest.
   if (buffer->BytesRemaining() > 0) {
-    source->Read(0, buffer->BytesRemaining(),
-                 reinterpret_cast<uint8*>(buffer->data()),
-                 base::Bind(&FinishGetImageBytes, make_scoped_refptr(buffer),
-                            base::Unretained(source), callback));
+    source->Read(
+        0,
+        buffer->BytesRemaining(),
+        reinterpret_cast<uint8*>(buffer->data()),
+        base::Bind(
+            &FinishGetImageBytes, buffer, base::Unretained(source), callback));
     return;
   }
 
   buffer->SetOffset(0);
-  callback.Run(make_scoped_refptr(buffer));
+  callback.Run(buffer);
 }
 
 void GetImageBytes(
     media::DataSource* source,
-    const base::Callback<void(net::DrainableIOBuffer*)>& callback) {
+    const GotImageCallback& callback) {
   int64 size64 = 0;
   if (!source->GetSize(&size64) ||
       base::saturated_cast<size_t>(size64) > kMaxBufferSize) {
     return callback.Run(NULL);
   }
   int size = base::checked_cast<int>(size64);
 
   scoped_refptr<net::DrainableIOBuffer> buffer(
       new net::DrainableIOBuffer(new net::IOBuffer(size), size));
   source->Read(0, buffer->BytesRemaining(),
@@ skipping 308 matching lines @@
   DCHECK(extracted_);
   return focal_length_mm_;
 }
 
 int ImageMetadataExtractor::iso_equivalent() const {
   DCHECK(extracted_);
   return iso_equivalent_;
 }
 
 void ImageMetadataExtractor::FinishExtraction(
-    const DoneCallback& callback, net::DrainableIOBuffer* buffer) {
-  if (!buffer) {
+    const DoneCallback& callback,
+    const scoped_refptr<net::DrainableIOBuffer>& buffer) {
+  if (!buffer.get()) {
     callback.Run(false);
     return;
   }
 
   ExifData* data = g_exif_lib.Get().ParseExifFromBuffer(
       reinterpret_cast<unsigned char*>(buffer->data()),
       buffer->BytesRemaining());
 
   if (!data) {
     callback.Run(false);
@@ skipping 49 matching lines @@
                               &iso_equivalent_);
 
   g_exif_lib.Get().ExifDataFree(data);
 
   extracted_ = true;
 
   callback.Run(true);
 }
 
 }  // namespace metadata