High DPI support for themes: Raw images for NTP attribution and background

chrome/browser/themes/browser_theme_pack.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 "chrome/browser/themes/browser_theme_pack.h"
 
 #include <limits>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 14 matching lines @@
 #include "net/base/net_errors.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 
 // Version number of the current theme pack. We just throw out and rebuild
 // theme packs that aren't int-equal to this. Increment this number if you
 // change default theme assets.
@@ skipping 530 matching lines @@
   // ImageSkiaReps for all supported scale factors.
   for (ImageCache::iterator it = pack->images_on_ui_thread_.begin();
        it != pack->images_on_ui_thread_.end(); ++it) {
     const gfx::ImageSkia source_image_skia = it->second.AsImageSkia();
     ThemeImageSource* source = new ThemeImageSource(source_image_skia);
     // image_skia takes ownership of source.
     gfx::ImageSkia image_skia(source, source_image_skia.size());
     it->second = gfx::Image(image_skia);
   }
 
+  // Generate raw images (for new-tab-page attribution and background) for
+  // any missing scale from an available scale image.

[pkotwicz, 2013/06/10 15:20:11]

We should iterate through kPreloadIDs here.

[sschmitz, 2013/06/10 17:24:14]

Done.

+  pack->GenerateRawImageForAllSupportedScales(PRS_THEME_NTP_BACKGROUND);
+  pack->GenerateRawImageForAllSupportedScales(PRS_THEME_NTP_ATTRIBUTION);
+
   // The BrowserThemePack is now in a consistent state.
   return pack;
 }
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
     const base::FilePath& path, const std::string& expected_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Allow IO on UI thread due to deep-seated theme design issues.
   // (see http://crbug.com/80206)
@@ skipping 841 matching lines @@
     float scale = static_cast<float>(percent) / 100.0f;
     for (size_t i = 0; i < scale_factors_.size(); ++i) {
       if (fabs(ui::GetScaleFactorScale(scale_factors_[i]) - scale) < 0.001) {
         *scale_factor = scale_factors_[i];
         return true;
       }
     }
   }
   return false;
 }
+
+void BrowserThemePack::GenerateRawImageForAllSupportedScales(int prs_id) {
+  // For any raw theme image for a supported scale that is not in the

[pkotwicz, 2013/06/10 15:20:11]

How about:
Compute (by scaling) bitmaps for |prs_id| for any scale factors for which the
theme author did not provide a bitmap. We compute the bitmaps using the highest
scale factor that theme author provided.

Heads up:
If the theme author provided images for 1x and 1.8x, the current code will not
use the 1.8x image as the source image on CrOS because 1.8x is not supported on
CrOS (though it is supported on Windows).
And yes, we can handle this case in a followup CL.

[sschmitz, 2013/06/10 17:24:14]

Done.

+  // theme extension we compute (by scaling) an image based on an
+  // available image. We use the available image with the highest
+  // scale to compute the missing images.
+
+  // See if any image is missing. If not, we're done.
+  bool image_missing = false;
+  for (size_t i = 0; i < scale_factors_.size(); ++i) {
+    int raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
+    if (image_memory_.find(raw_id) == image_memory_.end()) {
+      image_missing = true;
+      break;
+    }
+  }
+  if (!image_missing)
+    return;
+
+  // Find available scale factor with highest scale.
+  ui::ScaleFactor available = ui::SCALE_FACTOR_NONE;
+  for (size_t i = 0; i < scale_factors_.size(); ++i) {
+    int raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
+    if ((available == ui::SCALE_FACTOR_NONE ||
+         (ui::GetScaleFactorScale(scale_factors_[i]) >
+          ui::GetScaleFactorScale(available))) &&
+        image_memory_.find(raw_id) != image_memory_.end()) {
+      available = scale_factors_[i];
+    }
+  }
+  // If no image is available, we're done.
+  if (available == ui::SCALE_FACTOR_NONE)
+    return;
+
+  // Get bitmap of the available image.

[pkotwicz, 2013/06/10 15:20:11]

Nit: How about:
Get the bitmap for the available scale factor.

[sschmitz, 2013/06/10 17:24:14]

Done.

+  int available_raw_id = GetRawIDByPersistentID(prs_id, available);
+  RawImages::const_iterator it = image_memory_.find(available_raw_id);
+  DCHECK(it != image_memory_.end());
+  DCHECK(it->second->size() > 0);

[pkotwicz, 2013/06/10 15:20:11]

The above DCHECK is not necessary. gfx::PNGCodec::Decode deals with that case

[sschmitz, 2013/06/10 17:24:14]

Actually, we don't need either one.
Done.

+  SkBitmap available_bitmap;
+  if (!gfx::PNGCodec::Decode(it->second->front(),
+                             it->second->size(),
+                             &available_bitmap)) {
+    NOTREACHED() << "Unable to decode theme image for prs_id="
+                 << prs_id << " for scale_factor=" << available;
+    return;
+  }
+
+  // Fill in all missing scales by scaling the available image.

[pkotwicz, 2013/06/10 15:20:11]

Nit scales -> scale factors
    available image -> available bitmap

I try not to mix image & bitmap in comments because image usually implies a
gfx::Image/gfx::ImageSkia and bitmap usually implies SkBitmap.

[sschmitz, 2013/06/10 17:24:14]

Done.

+  for (size_t i = 0; i < scale_factors_.size(); ++i) {
+    int scaled_raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
+    if (image_memory_.find(scaled_raw_id) != image_memory_.end())
+      continue;
+    gfx::Size scaled_size = gfx::ToCeiledSize(
+        gfx::ScaleSize(gfx::Size(available_bitmap.width(),
+                                 available_bitmap.height()),
+                       ui::GetScaleFactorScale(scale_factors_[i]) /
+                       ui::GetScaleFactorScale(available)));
+    SkBitmap scaled_bitmap;
+    scaled_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                            scaled_size.width(),
+                            scaled_size.height());
+    if (!scaled_bitmap.allocPixels())
+      SK_CRASH();
+    scaled_bitmap.eraseARGB(0, 0, 0, 0);
+    SkCanvas canvas(scaled_bitmap);
+    SkRect scaled_bounds = RectToSkRect(gfx::Rect(scaled_size));
+    canvas.drawBitmapRect(available_bitmap, NULL, scaled_bounds);
+    std::vector<unsigned char> bitmap_data;
+    if (!gfx::PNGCodec::EncodeBGRASkBitmap(scaled_bitmap,
+                                           false,
+                                           &bitmap_data)) {
+      NOTREACHED() << "Unable to encode theme image for prs_id="
+                   << prs_id << " for scale_factor=" << scale_factors_[i];
+      break;
+    }
+    image_memory_[scaled_raw_id] =
+        base::RefCountedBytes::TakeVector(&bitmap_data);
+  }
+}