cros: Preload external extension icons.

chrome/browser/extensions/crx_installer.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/crx_installer.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
+#include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::BrowserThread;
 using content::UserMetricsAction;
 
 namespace extensions {
 
 namespace {
@@ skipping 325 matching lines @@
     return;
   }
 
   if (client_) {
     Extension::DecodeIcon(extension_.get(),
                           extension_misc::EXTENSION_ICON_LARGE,
                           ExtensionIconSet::MATCH_BIGGER,
                           &install_icon_);
   }
 
+  PreloadIcons();
+
   if (!BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&CrxInstaller::CheckRequirements, this)))
     NOTREACHED();
 }
 
 void CrxInstaller::CheckRequirements() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AddRef();  // Balanced in OnRequirementsChecked().
   requirements_checker_->Check(extension_,
@@ skipping 218 matching lines @@
     record_oauth2_grant_ = client_->record_oauth2_grant();
 
   // We update the extension's granted permissions if the user already approved
   // the install (client_ is non NULL), or we are allowed to install this
   // silently.
   if (client_ || allow_silent_install_) {
     PermissionsUpdater perms_updater(profile());
     perms_updater.GrantActivePermissions(extension_, record_oauth2_grant_);
   }
 
+  CachePreloadedIcons();
+
   // Tell the frontend about the installation and hand off ownership of
   // extension_ to it.
   frontend_weak_->OnExtensionInstalled(extension_,
                                        is_gallery_install(),
                                        page_ordinal_,
                                        has_requirement_errors_);
 
   NotifyCrxInstallComplete(extension_.get());
 
   extension_ = NULL;
 
   // We're done. We don't post any more tasks to ourselves so we are deleted
   // soon.
 }
 
 void CrxInstaller::NotifyCrxInstallComplete(const Extension* extension) {
   // Some users (such as the download shelf) need to know when a
   // CRXInstaller is done.  Listening for the EXTENSION_* events
   // is problematic because they don't know anything about the
   // extension before it is unpacked, so they cannot filter based
   // on the extension.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       content::Source<CrxInstaller>(this),
       content::Details<const Extension>(extension));
 }
 
+void CrxInstaller::PreloadIcons() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  for (std::set<int>::const_iterator it = preload_sizes_.begin();
+       it != preload_sizes_.end(); ++it) {
+    scoped_ptr<SkBitmap> icon(new SkBitmap());
+
+    const int requested_size = *it;
+    Extension::DecodeIcon(extension_.get(),
+                          requested_size,
+                          ExtensionIconSet::MATCH_BIGGER,
+                          &icon);
+    if (icon->empty())
+      continue;
+
+    if (icon->width() != requested_size ||
+        icon->height() != requested_size) {
+      *icon = skia::ImageOperations::Resize(
+          *icon, skia::ImageOperations::RESIZE_LANCZOS3,
+          requested_size, requested_size);
+    }
+
+    preload_map_[*it] = *icon.get();
+  }
+}
+
+void CrxInstaller::CachePreloadedIcons() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  for (std::map<int, SkBitmap>::const_iterator it = preload_map_.begin();
+       it != preload_map_.end(); ++it) {
+    const std::string icon_path = extension_->icons().Get(
+        it->first, ExtensionIconSet::MATCH_BIGGER);
+    ExtensionResource icon_resource = extension_->GetResource(icon_path);
+    if (icon_resource.empty()) {
+      NOTREACHED();
+      continue;
+    }
+
+    extension_->SetCachedImage(icon_resource,
+                               it->second,
+                               gfx::Size(it->first, it->first));
+  }
+}
+
 }  // namespace extensions