Fix DecompressionTask with power-of-two expanded thumbnails.

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 822 matching lines @@
     Remove(tab_id);
   }
   return;
 }
 
 void ThumbnailStore::DecompressionTask(
     const base::Callback<void(bool, SkBitmap)>&
         post_decompression_callback,
     skia::RefPtr<SkPixelRef> compressed_data,
     float scale,
-    const gfx::Size& encoded_size) {
-  SkBitmap raw_data;
+    const gfx::Size& content_size) {
+  SkBitmap raw_data_small;
   bool success = false;
 
   if (compressed_data.get()) {
-    size_t pixel_size = 4;  // Pixel size is 4 bytes for kARGB_8888_Config.
-    size_t stride = pixel_size * encoded_size.width();
+    gfx::Size buffer_size = gfx::Size(compressed_data->info().width(),
+                                      compressed_data->info().height());
 
-    raw_data.allocPixels(SkImageInfo::Make(encoded_size.width(),
-                                            encoded_size.height(),
-                                            kRGBA_8888_SkColorType,
-                                            kOpaque_SkAlphaType));
+    SkBitmap raw_data;
+    raw_data.allocPixels(SkImageInfo::Make(buffer_size.width(),
+                                           buffer_size.height(),
+                                           kRGBA_8888_SkColorType,
+                                           kOpaque_SkAlphaType));
     SkAutoLockPixels raw_data_lock(raw_data);
+    compressed_data->lockPixels();
     success = etc1_decode_image(
         reinterpret_cast<unsigned char*>(compressed_data->pixels()),
         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
-        encoded_size.width(),
-        encoded_size.height(),
-        pixel_size,
-        stride);
+        buffer_size.width(),
+        buffer_size.height(),
+        raw_data.bytesPerPixel(),
+        raw_data.rowBytes());
+    compressed_data->unlockPixels();
     raw_data.setImmutable();
+
+    if (!success) {
+      // Leave raw_data_small empty for consistency with other failure modes.
+    } else if (content_size == buffer_size) {
+      // Shallow copy the pixel reference.
+      raw_data_small = raw_data;
+    } else {
+      // The content size is smaller than the buffer size (likely because of
+      // a power-of-two rounding), so deep copy the bitmap.
+      raw_data_small.allocPixels(SkImageInfo::Make(content_size.width(),
+                                                   content_size.height(),
+                                                   kRGBA_8888_SkColorType,
+                                                   kOpaque_SkAlphaType));
+      SkAutoLockPixels raw_data_small_lock(raw_data_small);
+      SkCanvas small_canvas(raw_data_small);
+      small_canvas.drawBitmap(raw_data, 0, 0);
+      raw_data_small.setImmutable();
+    }
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
-      base::Bind(post_decompression_callback, success, raw_data));
+      base::Bind(post_decompression_callback, success, raw_data_small));
 }
 
 ThumbnailStore::ThumbnailMetaData::ThumbnailMetaData() {
 }
 
 ThumbnailStore::ThumbnailMetaData::ThumbnailMetaData(
     const base::Time& current_time,
     const GURL& url)
     : capture_time_(current_time), url_(url) {
 }
@@ skipping 16 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);
 }