use NewUninitialized, cheaper than NewWithMalloc

chrome/browser/android/thumbnail/thumbnail_store.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/browser/android/thumbnail/thumbnail_store.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/big_endian.h"
@@ skipping 551 matching lines @@
     size_t pixel_size = 4;  // Pixel size is 4 bytes for kARGB_8888_Config.
     size_t stride = pixel_size * raw_data_size.width();
 
     size_t encoded_bytes =
         etc1_get_encoded_data_size(encoded_size.width(), encoded_size.height());
     SkImageInfo info = SkImageInfo::Make(encoded_size.width(),
                                          encoded_size.height(),
                                          kUnknown_SkColorType,
                                          kUnpremul_SkAlphaType);
     skia::RefPtr<SkData> etc1_pixel_data = skia::AdoptRef(
-        SkData::NewFromMalloc(new uint8_t[encoded_bytes], encoded_bytes));
+        SkData::NewUninitialized(encoded_bytes));
     skia::RefPtr<SkMallocPixelRef> etc1_pixel_ref = skia::AdoptRef(
         SkMallocPixelRef::NewWithData(info, 0, NULL, etc1_pixel_data.get()));

[f(malita), 2014/09/12 11:49:59]

Is this safe? Looks like SkMallocPixelRef is ref-ing etc1_pixel_data before we
write data, but per SkData::NewUninitialized() docs

"The caller should call writable_data()  to write into the buffer, but this must
be done before another ref() is made"

[f(malita), 2014/09/12 11:54:34]

I see it's just writable_data() asserting it gets called before ref-ing, so if
we're not using that at all it should be OK.

non-owner lgtm

[reed1, 2014/09/12 18:00:08]

Yes, the existing code is tricky that way, but since they're not calling
data->data() we won't get an assert.

 
     etc1_pixel_ref->lockPixels();
     bool success = etc1_encode_image(
         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
         raw_data_size.width(),
         raw_data_size.height(),
         pixel_size,
         stride,
         reinterpret_cast<unsigned char*>(etc1_pixel_ref->pixels()),
         encoded_size.width(),
@@ skipping 90 matching lines @@
   int max_dimension = std::max(display_info.GetDisplayWidth(),
                                display_info.GetDisplayHeight());
 
   if (content_width > max_dimension
       || content_height > max_dimension
       || static_cast<size_t>(raw_width) > NextPowerOfTwo(max_dimension)
       || static_cast<size_t>(raw_height) > NextPowerOfTwo(max_dimension)) {
     return false;
   }
 
-  skia::RefPtr<SkData> etc1_pixel_data;
   int data_size = etc1_get_encoded_data_size(raw_width, raw_height);
-  scoped_ptr<uint8_t[]> raw_data =
-      scoped_ptr<uint8_t[]>(new uint8_t[data_size]);
+  skia::RefPtr<SkData> etc1_pixel_data =
+      skia::AdoptRef(SkData::NewUninitialized(data_size));
 
   int pixel_bytes_read = file.ReadAtCurrentPos(
-      reinterpret_cast<char*>(raw_data.get()),
+      reinterpret_cast<char*>(etc1_pixel_data->writable_data()),
       data_size);
 
   if (pixel_bytes_read != data_size)
     return false;
 
   SkImageInfo info = SkImageInfo::Make(raw_width,
                                        raw_height,
                                        kUnknown_SkColorType,
                                        kUnpremul_SkAlphaType);
 
-  etc1_pixel_data = skia::AdoptRef(
-      SkData::NewFromMalloc(raw_data.release(), data_size));
-
   *out_pixels = skia::AdoptRef(
       SkMallocPixelRef::NewWithData(info,
                                     0,
                                     NULL,
                                     etc1_pixel_data.get()));
 
   int extra_data_version = 0;
   if (!ReadBigEndianFromFile(file, &extra_data_version))
     return false;
 
@@ skipping 126 matching lines @@
   dst_bitmap.eraseColor(0);
   SkAutoLockPixels dst_bitmap_lock(dst_bitmap);
 
   SkCanvas canvas(dst_bitmap);
   canvas.scale(new_scale, new_scale);
   canvas.drawBitmap(bitmap, 0, 0, NULL);
   dst_bitmap.setImmutable();
 
   return std::make_pair(dst_bitmap, new_scale * scale);
 }