Add support for multiple icon sizes for Mac platform apps

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 "base/bind.h"
 #include "base/file_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/image/image.h"
 #include "webkit/glue/image_decoder.h"
 
 using content::BrowserThread;
 
 ImageLoadingTracker::Observer::~Observer() {}
 
+ImageLoadingTracker::ImageInfo::ImageInfo(
+    const ExtensionResource resource, gfx::Size max_size)
+    : resource(resource), max_size(max_size) {
+}
+
+ImageLoadingTracker::ImageInfo::~ImageInfo() {
+}
+
+ImageLoadingTracker::PendingLoadInfo::PendingLoadInfo()
+  : extension(NULL),
+    pending_count(0) {
+}
+
+ImageLoadingTracker::PendingLoadInfo::~PendingLoadInfo() {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoadingTracker::ImageLoader

[Finnur, 2012/02/28 10:26:51]

nit: Maybe add a similar heading for ImageInfo above?

[sail, 2012/02/28 23:25:36]

Done.

 
 // A RefCounted class for loading images on the File thread and reporting back
 // on the UI thread.
 class ImageLoadingTracker::ImageLoader
     : public base::RefCountedThreadSafe<ImageLoader> {
  public:
   explicit ImageLoader(ImageLoadingTracker* tracker)
       : tracker_(tracker) {
     CHECK(BrowserThread::GetCurrentThreadIdentifier(&callback_thread_id_));
     DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 98 matching lines @@
   // The loader is created lazily and is NULL if the tracker is destroyed before
   // any valid image load tasks have been posted.
   if (loader_)
     loader_->StopTracking();
 }
 
 void ImageLoadingTracker::LoadImage(const Extension* extension,
                                     const ExtensionResource& resource,
                                     const gfx::Size& max_size,
                                     CacheParam cache) {
-  // If we don't have a path we don't need to do any further work, just respond
-  // back.
+  std::vector<ImageInfo> info_list;
+  info_list.push_back(ImageInfo(resource, max_size));
+  LoadImages(extension, info_list, cache);
+}
+
+void ImageLoadingTracker::LoadImages(const Extension* extension,
+                                     const std::vector<ImageInfo>& info_list,
+                                     CacheParam cache) {
+  PendingLoadInfo load_info;
+  load_info.extension = extension;
+  load_info.cache = cache;
+  load_info.extension_id = extension->id();
+  load_info.pending_count = info_list.size();
   int id = next_id_++;
-  if (resource.relative_path().empty()) {
-    OnImageLoaded(NULL, resource, max_size, id);
-    return;
+  load_map_[id] = load_info;
+
+  for (std::vector<ImageInfo>::const_iterator it = info_list.begin();
+       it != info_list.end(); ++it) {
+    // If we don't have a path we don't need to do any further work, just
+    // respond back.
+    if (it->resource.relative_path().empty()) {
+      OnImageLoaded(NULL, it->resource, it->max_size, id);
+      continue;
+    }
+
+    DCHECK(extension->path() == it->resource.extension_root());
+
+    // See if the extension has the image already.
+    if (extension->HasCachedImage(it->resource, it->max_size)) {
+      SkBitmap image = extension->GetCachedImage(it->resource, it->max_size);
+      OnImageLoaded(&image, it->resource, it->max_size, id);
+      continue;
+    }
+
+    // Instruct the ImageLoader to load this on the File thread. LoadImage does
+    // not block.
+    if (!loader_)
+      loader_ = new ImageLoader(this);
+    loader_->LoadImage(it->resource, it->max_size, id);
   }
-
-  DCHECK(extension->path() == resource.extension_root());
-
-  // See if the extension has the image already.
-  if (extension->HasCachedImage(resource, max_size)) {
-    SkBitmap image = extension->GetCachedImage(resource, max_size);
-    OnImageLoaded(&image, resource, max_size, id);
-    return;
-  }
-
-  if (cache == CACHE)
-    load_map_[id] = extension;
-
-  // Instruct the ImageLoader to load this on the File thread. LoadImage does
-  // not block.
-  if (!loader_)
-    loader_ = new ImageLoader(this);
-  loader_->LoadImage(resource, max_size, id);
 }
 
 void ImageLoadingTracker::OnImageLoaded(
     SkBitmap* image,
     const ExtensionResource& resource,
     const gfx::Size& original_size,
     int id) {
-  LoadMap::iterator i = load_map_.find(id);
-  if (i != load_map_.end()) {
-    i->second->SetCachedImage(resource, image ? *image : SkBitmap(),
-                              original_size);
-    load_map_.erase(i);
+  LoadMap::iterator it = load_map_.find(id);
+  DCHECK(it != load_map_.end());
+
+  PendingLoadInfo* info = &it->second;
+
+  // Save the pending results.
+  DCHECK(info->pending_count > 0);
+  info->pending_count--;
+  if (image)
+    info->bitmaps.push_back(*image);
+
+  // Add to the extension's image cache if requested.
+  DCHECK(info->cache != CACHE || info->extension);
+  if (info->cache == CACHE  &&
+      !info->extension->HasCachedImage(resource, original_size)) {
+    info->extension->SetCachedImage(resource, image ? *image : SkBitmap(),
+                                    original_size);
   }
 
-  observer_->OnImageLoaded(image, resource, id);
+  // If all pending images are done then report back.
+  if (info->pending_count == 0) {
+    if (info->bitmaps.size() > 0) {
+      std::vector<const SkBitmap*> bitmaps;
+      for (std::vector<SkBitmap>::const_iterator it = info->bitmaps.begin();
+           it != info->bitmaps.end(); ++it) {
+        // gfx::Image takes ownership of this bitmap.
+        bitmaps.push_back(new SkBitmap(*it));
+      }
+      gfx::Image gfx_image(bitmaps);
+      observer_->OnImageLoaded(gfx_image, info->extension_id, id);
+    } else {
+      observer_->OnImageLoaded(gfx::Image(), info->extension_id, id);
+    }
+    load_map_.erase(it);
+  }
 }
 
 void ImageLoadingTracker::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED);
 
   const Extension* extension =
       content::Details<UnloadedExtensionInfo>(details)->extension;
 
-  // Remove all entries in the load_map_ referencing the extension. This ensures
-  // we don't attempt to cache the image when the load completes.
-  for (LoadMap::iterator i = load_map_.begin(); i != load_map_.end();) {
-    if (i->second == extension)
-      load_map_.erase(i++);
-    else
-      ++i;
+  // Remove reference to this extension from all pending load entries. This
+  // ensures we don't attempt to cache the image 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;
+    }
   }
 }