Fix bug where we were not displaying icons in the management

chrome/browser/extensions/extensions_ui.cc

 // Copyright (c) 2006-2009 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/extensions_ui.h"
 
+#include "app/gfx/codec/png_codec.h"
+#include "app/gfx/color_utils.h"
+#include "app/gfx/skbitmap_operations.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
+#include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
+#include "net/base/base64.h"
 #include "net/base/net_util.h"
-

[Finnur, 2009/11/05 03:55:08]

nit: Did you delete this line on purpose?
I think I've seen people put the resources at the bottom in a separate section.
If we are going to have this in one section, shouldn't this be before net/* to
maintain alphabetical sorting? If we are going to have two sections, then the
webkit include moves up.

 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
+#include "webkit/glue/image_decoder.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // ExtensionsHTMLSource
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionsUIHTMLSource::ExtensionsUIHTMLSource()
     : DataSource(chrome::kChromeUIExtensionsHost, MessageLoop::current()) {
 }
@@ skipping 59 matching lines @@
   jstemplate_builder::AppendI18nTemplateProcessHtml(&full_html);
   jstemplate_builder::AppendJsTemplateSourceHtml(&full_html);
 
   scoped_refptr<RefCountedBytes> html_bytes(new RefCountedBytes);
   html_bytes->data.resize(full_html.size());
   std::copy(full_html.begin(), full_html.end(), html_bytes->data.begin());
 
   SendResponse(request_id, html_bytes);
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// ExtensionsDOMHandler::IconLoader
+//
+///////////////////////////////////////////////////////////////////////////////

[Finnur, 2009/11/05 03:55:08]

nit: Add one more / to complete 80 columns. :)

+
+ExtensionsDOMHandler::IconLoader::IconLoader(ExtensionsDOMHandler* handler)
+    : handler_(handler) {
+}
+
+void ExtensionsDOMHandler::IconLoader::LoadIcons(
+    std::vector<ExtensionResource>* icons, DictionaryValue* json) {
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(this,
+          &IconLoader::LoadIconsOnFileThread, icons, json));
+}
+
+void ExtensionsDOMHandler::IconLoader::Cancel() {
+  handler_ = NULL;
+}
+
+void ExtensionsDOMHandler::IconLoader::LoadIconsOnFileThread(
+    std::vector<ExtensionResource>* icons, DictionaryValue* json) {
+  scoped_ptr<std::vector<ExtensionResource> > icons_deleter(icons);
+  scoped_ptr<DictionaryValue> json_deleter(json);
+
+  ListValue* extensions = NULL;
+  CHECK(json->GetList(L"extensions", &extensions));
+
+  for (size_t i = 0; i < icons->size(); ++i) {
+    DictionaryValue* extension = NULL;
+    CHECK(extensions->GetDictionary(static_cast<int>(i), &extension));
+
+    // Read the file.
+    std::string file_contents;
+    if (icons->at(i).relative_path().empty() ||
+        !file_util::ReadFileToString(icons->at(i).GetFilePath(),
+                                     &file_contents)) {
+      // If there's no icon, default to the puzzle icon. This is safe to do from
+      // the file thread.
+      file_contents = ResourceBundle::GetSharedInstance().GetDataResource(
+          IDR_INFOBAR_PLUGIN_INSTALL);
+    }
+
+    // If the extension is disabled, we desaturate the icon to add to the
+    // disabledness effect.
+    bool enabled = false;
+    CHECK(extension->GetBoolean(L"enabled", &enabled));

[Finnur, 2009/11/05 03:55:08]

nit: Why CHECK here instead of DCHECK?

+    if (!enabled) {
+      const unsigned char* data =
+          reinterpret_cast<const unsigned char*>(file_contents.data());
+      webkit_glue::ImageDecoder decoder;
+      scoped_ptr<SkBitmap> decoded(new SkBitmap());
+      *decoded = decoder.Decode(data, file_contents.length());
+
+      // Desaturate the icon and lighten it a bit.
+      color_utils::HSL shift = {-1, 0, 0.6};
+      *decoded = SkBitmapOperations::CreateHSLShiftedBitmap(*decoded, shift);
+
+      std::vector<unsigned char> output;
+      gfx::PNGCodec::EncodeBGRASkBitmap(*decoded, false, &output);
+
+      // Lame, but we must make a copy of this now, because base64 doesn't take
+      // the same input type.
+      file_contents.assign(reinterpret_cast<char*>(&output.front()),
+                           output.size());
+    }
+
+    // Create a data URL (all icons are converted to PNGs during unpacking).
+    std::string base64_encoded;
+    net::Base64Encode(file_contents, &base64_encoded);
+    GURL icon_url("data:image/png;base64," + base64_encoded);
+
+    extension->SetString(L"icon", icon_url.spec());
+  }
+
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(this, &IconLoader::ReportResultOnUIThread,
+                        json_deleter.release()));
+}
+
+void ExtensionsDOMHandler::IconLoader::ReportResultOnUIThread(
+    DictionaryValue* json) {
+  if (handler_)
+    handler_->OnIconsLoaded(json);
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 // ExtensionsDOMHandler
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionsDOMHandler::ExtensionsDOMHandler(ExtensionsService* extension_service)
     : extensions_service_(extension_service) {
 }
 
@@ skipping 16 matching lines @@
       NewCallback(this, &ExtensionsDOMHandler::HandleLoadMessage));
   dom_ui_->RegisterMessageCallback("pack",
       NewCallback(this, &ExtensionsDOMHandler::HandlePackMessage));
   dom_ui_->RegisterMessageCallback("autoupdate",
       NewCallback(this, &ExtensionsDOMHandler::HandleAutoUpdateMessage));
   dom_ui_->RegisterMessageCallback("selectFilePath",
       NewCallback(this, &ExtensionsDOMHandler::HandleSelectFilePathMessage));
 }
 
 void ExtensionsDOMHandler::HandleRequestExtensionsData(const Value* value) {
-  DictionaryValue results;
+  DictionaryValue* results = new DictionaryValue();
 
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
+
+  // Stores the icon resource for each of the extensions in extensions_list. We
+  // build up a list of them here, then load them on the file thread in
+  // ::LoadIcons().
+  std::vector<ExtensionResource>* extension_icons =
+      new std::vector<ExtensionResource>();
+
   const ExtensionList* extensions = extensions_service_->extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     // Don't show the themes since this page's UI isn't really useful for
     // themes.
     if (!(*extension)->IsTheme()) {
       extensions_list->Append(CreateExtensionDetailValue(
           *extension, GetActivePagesForExtension((*extension)->id()), true));
+      extension_icons->push_back(PickExtensionIcon(*extension));
     }
   }
   extensions = extensions_service_->disabled_extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (!(*extension)->IsTheme()) {
       extensions_list->Append(CreateExtensionDetailValue(
           *extension, GetActivePagesForExtension((*extension)->id()), false));
+      extension_icons->push_back(PickExtensionIcon(*extension));
     }
   }
-  results.Set(L"extensions", extensions_list);
+  results->Set(L"extensions", extensions_list);
 
   bool developer_mode = dom_ui_->GetProfile()->GetPrefs()
       ->GetBoolean(prefs::kExtensionsUIDeveloperMode);
-  results.SetBoolean(L"developerMode", developer_mode);
+  results->SetBoolean(L"developerMode", developer_mode);
 
-  dom_ui_->CallJavascriptFunction(L"returnExtensionsData", results);
+  if (icon_loader_.get())
+    icon_loader_->Cancel();
+
+  icon_loader_ = new IconLoader(this);
+  icon_loader_->LoadIcons(extension_icons, results);
+}
+
+void ExtensionsDOMHandler::OnIconsLoaded(DictionaryValue* json) {
+  dom_ui_->CallJavascriptFunction(L"returnExtensionsData", *json);
+  delete json;
 
   // Register for notifications that we need to reload the page.
   registrar_.RemoveAll();
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
       NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
       NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
       NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED_DISABLED,
       NotificationService::AllSources());
 }
 
+ExtensionResource ExtensionsDOMHandler::PickExtensionIcon(
+    Extension* extension) {
+  // Try to fetch the medium sized icon, then (if missing) go for the large one.
+  const std::map<int, std::string>& icons = extension->icons();
+  std::map<int, std::string>::const_iterator iter =
+      icons.find(Extension::EXTENSION_ICON_MEDIUM);
+  if (iter == icons.end())
+    iter = icons.find(Extension::EXTENSION_ICON_LARGE);
+  if (iter != icons.end())
+    return extension->GetResource(iter->second);
+  else
+    return ExtensionResource();
+}
+
 void ExtensionsDOMHandler::HandleToggleDeveloperMode(const Value* value) {
   bool developer_mode = dom_ui_->GetProfile()->GetPrefs()
       ->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   dom_ui_->GetProfile()->GetPrefs()->SetBoolean(
       prefs::kExtensionsUIDeveloperMode, !developer_mode);
 }
 
 void ExtensionsDOMHandler::HandleInspectMessage(const Value* value) {
   std::string render_process_id_str;
   std::string render_view_id_str;
@@ skipping 268 matching lines @@
   // Determine the sort order: Extensions loaded through --load-extensions show
   // up at the top. Disabled extensions show up at the bottom.
     if (extension->location() == Extension::LOAD)
     extension_data->SetInteger(L"order", 1);
   else
     extension_data->SetInteger(L"order", 2);
 
   if (!extension->options_url().is_empty())
     extension_data->SetString(L"options_url", extension->options_url().spec());
 
-  // Try to fetch the medium sized icon, then (if missing) go for the large one.
-  const std::map<int, std::string>& icons = extension->icons();
-  std::map<int, std::string>::const_iterator iter =
-      icons.find(Extension::EXTENSION_ICON_MEDIUM);
-  if (iter == icons.end())
-    iter = icons.find(Extension::EXTENSION_ICON_LARGE);
-  if (iter != icons.end())
-    extension_data->SetString(L"icon", iter->second);
-  else
-    extension_data->SetString(L"icon", "");
-
   // Add list of content_script detail DictionaryValues
   ListValue *content_script_list = new ListValue();
   UserScriptList content_scripts = extension->content_scripts();
   for (UserScriptList::const_iterator script = content_scripts.begin();
     script != content_scripts.end(); ++script) {
       content_script_list->Append(
           CreateContentScriptDetailValue(*script, extension->path()));
   }
   extension_data->Set(L"content_scripts", content_script_list);
 
@@ skipping 38 matching lines @@
                                      view->routing_id()));
     }
   }
 
   return result;
 }
 
 ExtensionsDOMHandler::~ExtensionsDOMHandler() {
   if (pack_job_.get())
     pack_job_->ClearClient();
+
+  if (icon_loader_.get())
+    icon_loader_->Cancel();
 }
 
 // ExtensionsDOMHandler, public: -----------------------------------------------
 
 ExtensionsUI::ExtensionsUI(TabContents* contents) : DOMUI(contents) {
   ExtensionsService *exstension_service =
       GetProfile()->GetOriginalProfile()->GetExtensionsService();
 
   ExtensionsDOMHandler* handler = new ExtensionsDOMHandler(exstension_service);
   AddMessageHandler(handler);
@@ skipping 13 matching lines @@
 // static
 RefCountedMemory* ExtensionsUI::GetFaviconResourceBytes() {
   return ResourceBundle::GetSharedInstance().
       LoadImageResourceBytes(IDR_PLUGIN);
 }
 
 // static
 void ExtensionsUI::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode, false);
 }