chromeos: Fix pixelated icons in app list and launcher (part 3)

chrome/browser/extensions/image_loading_tracker.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/extensions/image_loading_tracker.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 122 matching lines @@
         base::Bind(&ImageLoader::LoadOnFileThread, this, image_info, id));
   }
 
   void LoadOnFileThread(const ImageRepresentation& image_info, int id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
     // Read the file from disk.
     std::string file_contents;
     FilePath path = image_info.resource.GetFilePath();
     if (path.empty() || !file_util::ReadFileToString(path, &file_contents)) {
-      ReportBack(NULL, image_info, gfx::Size(), id, false);
+      ReportBack(NULL, image_info, gfx::Size(), id);
       return;
     }
 
     // Decode the bitmap using WebKit's image decoder.
     const unsigned char* data =
         reinterpret_cast<const unsigned char*>(file_contents.data());
     webkit_glue::ImageDecoder decoder;
     scoped_ptr<SkBitmap> decoded(new SkBitmap());
     // Note: This class only decodes bitmaps from extension resources. Chrome
     // doesn't (for security reasons) directly load extension resources provided
     // by the extension author, but instead decodes them in a separate
     // locked-down utility process. Only if the decoding succeeds is the image
     // saved from memory to disk and subsequently used in the Chrome UI.
     // Chrome is therefore decoding bitmaps here that were generated by Chrome.
     *decoded = decoder.Decode(data, file_contents.length());
     if (decoded->empty()) {
-      ReportBack(NULL, image_info, gfx::Size(), id, false);
+      ReportBack(NULL, image_info, gfx::Size(), id);
       return;  // Unable to decode.
     }
 
     gfx::Size original_size(decoded->width(), decoded->height());
-    if (ShouldResizeImageRepresentation(image_info.resize_method,
-                                        original_size,
-                                        image_info.desired_size)) {
-      *decoded = skia::ImageOperations::Resize(
-          *decoded, skia::ImageOperations::RESIZE_LANCZOS3,
-          image_info.desired_size.width(), image_info.desired_size.height());
-    }
+    *decoded = ResizeIfNeeded(*decoded, image_info);
 
-    ReportBack(decoded.release(), image_info, original_size, id,
-               true /* delete bitmap */);
+    ReportBack(decoded.release(), image_info, original_size, id);
   }
 
   // Instructs the loader to load a resource on the File thread.
   void LoadResource(const ImageRepresentation& image_info,
                     int id,
                     int resource_id) {
     DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&ImageLoader::LoadResourceOnFileThread, this, image_info,
                    id, resource_id));
   }
 
   void LoadResourceOnFileThread(const ImageRepresentation& image_info,
                                 int id,
                                 int resource_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    const SkBitmap* bitmap = ResourceBundle::GetSharedInstance().GetImageNamed(
+    scoped_ptr<SkBitmap> bitmap(new SkBitmap);

[tbarzic, 2012/08/25 01:46:39]

now I wonder why I didn't do this in the first place :)

+    *bitmap = *ResourceBundle::GetSharedInstance().GetImageNamed(
         resource_id).ToSkBitmap();
-    ReportBack(bitmap, image_info, image_info.desired_size, id,
-               false /* don't delete bitmap */);
+
+    *bitmap = ResizeIfNeeded(*bitmap, image_info);
+    ReportBack(bitmap.release(), image_info, image_info.desired_size, id);
   }
 
   void ReportBack(const SkBitmap* bitmap, const ImageRepresentation& image_info,
-                  const gfx::Size& original_size, int id, bool delete_bitmap) {
+                  const gfx::Size& original_size, int id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
     BrowserThread::PostTask(
         callback_thread_id_, FROM_HERE,
         base::Bind(&ImageLoader::ReportOnCallingThread, this,
-                   bitmap, image_info, original_size, id, delete_bitmap));
+                   bitmap, image_info, original_size, id));
   }
 
   void ReportOnCallingThread(const SkBitmap* bitmap,
                              const ImageRepresentation& image_info,
                              const gfx::Size& original_size,
-                             int id,
-                             bool delete_bitmap) {
+                             int id) {
     DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
 
     if (tracker_)
       tracker_->OnBitmapLoaded(bitmap, image_info, original_size, id, true);
 
-    if (bitmap && delete_bitmap)
+    if (bitmap)
       delete bitmap;
   }
 
  private:
   friend class base::RefCountedThreadSafe<ImageLoader>;
   ~ImageLoader() {}
 
+  SkBitmap ResizeIfNeeded(const SkBitmap& bitmap,
+                          const ImageRepresentation& image_info) {
+    gfx::Size original_size(bitmap.width(), bitmap.height());
+    if (ShouldResizeImageRepresentation(image_info.resize_method,
+                                        original_size,
+                                        image_info.desired_size)) {
+      return skia::ImageOperations::Resize(
+          bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
+          image_info.desired_size.width(), image_info.desired_size.height());
+    }
+
+    return bitmap;
+  }
+
   // The tracker we are loading the bitmap for. If NULL, it means the tracker is
   // no longer interested in the reply.
   ImageLoadingTracker* tracker_;
 
   // The thread that we need to call back on to report that we are done.
   BrowserThread::ID callback_thread_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageLoader);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoadingTracker
 
+// static
+bool ImageLoadingTracker::IsSpecialBundledExtensionId(
+    const std::string& extension_id) {
+  int resource_id = -1;
+  return FindSpecialExtensionResourceId(extension_id, &resource_id);
+}
+
 ImageLoadingTracker::ImageLoadingTracker(Observer* observer)
     : observer_(observer),
       next_id_(0) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::NotificationService::AllSources());
 }
 
 ImageLoadingTracker::~ImageLoadingTracker() {
   // The loader is created lazily and is NULL if the tracker is destroyed before
   // any valid image load tasks have been posted.
@@ skipping 145 matching lines @@
   // Remove reference to this extension from all pending load entries. This
   // ensures we don't attempt to cache the bitmap when the load completes.
   for (LoadMap::iterator i = load_map_.begin(); i != load_map_.end(); ++i) {
     PendingLoadInfo* info = &i->second;
     if (info->extension == extension) {
       info->extension = NULL;
       info->cache = DONT_CACHE;
     }
   }
 }