Consolidate icon loading on ChromeOS

chrome/browser/icon_loader_chromeos.cc

 // Copyright (c) 2011 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/ui/webui/fileicon_source_chromeos.h"
+#include "chrome/browser/icon_loader.h"
 
+#include <string>
 #include <map>
 #include <utility>
-#include <vector>
 
-#include "base/file_util.h"
-#include "base/memory/singleton.h"
-#include "base/string_split.h"
-#include "base/string_util.h"
-#include "base/threading/thread_restrictions.h"
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/message_loop.h"
 #include "chrome/browser/icon_loader.h"
-#include "chrome/browser/io_thread.h"
-#include "chrome/browser/ui/webui/chrome_url_data_manager.h"
-#include "chrome/common/url_constants.h"
-#include "googleurl/src/gurl.h"
 #include "grit/component_extension_resources.h"
-#include "grit/component_extension_resources_map.h"
-#include "grit/generated_resources.h"
-#include "grit/theme_resources.h"
-#include "grit/ui_resources.h"
-#include "net/base/escape.h"
-#include "net/base/mime_util.h"
+#include "skia/ext/image_operations.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/canvas_skia.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/image.h"
+#include "webkit/glue/image_decoder.h"
 
 namespace {
 
 struct IdrBySize {
   int idr_small_;
   int idr_normal_;
   int idr_large_;
 };
 
-typedef std::map<std::string, IconLoader::IconSize> QueryIconSizeMap;
 typedef std::map<std::string, IdrBySize> ExtensionIconSizeMap;
 
-const char *kIconSize = "iconsize";
-
 const IdrBySize kAudioIdrs = {
   IDR_FILE_MANAGER_IMG_FILETYPE_AUDIO,
   IDR_FILE_MANAGER_IMG_FILETYPE_LARGE_AUDIO,
   IDR_FILE_MANAGER_IMG_FILETYPE_LARGE_AUDIO
 };
 const IdrBySize kDeviceIdrs = {
   IDR_FILE_MANAGER_IMG_FILETYPE_DEVICE,
   IDR_FILE_MANAGER_IMG_FILETYPE_DEVICE,
   IDR_FILE_MANAGER_IMG_FILETYPE_DEVICE
 };
@@ skipping 46 matching lines @@
   IDR_FILE_MANAGER_IMG_FILETYPE_TEXT,
   IDR_FILE_MANAGER_IMG_FILETYPE_TEXT,
   IDR_FILE_MANAGER_IMG_FILETYPE_TEXT
 };
 const IdrBySize kVideoIdrs = {
   IDR_FILE_MANAGER_IMG_FILETYPE_VIDEO,
   IDR_FILE_MANAGER_IMG_FILETYPE_LARGE_VIDEO,
   IDR_FILE_MANAGER_IMG_FILETYPE_LARGE_VIDEO
 };
 
-QueryIconSizeMap BuildQueryIconSizeMap() {
-  QueryIconSizeMap::value_type kQueryIconSizeData[] = {
-    std::make_pair("small", IconLoader::SMALL),
-    std::make_pair("normal", IconLoader::NORMAL),
-    std::make_pair("large", IconLoader::LARGE)
-  };
-
-  size_t kQSize = arraysize(kQueryIconSizeData);
-  return QueryIconSizeMap(&kQueryIconSizeData[0],
-                          &kQueryIconSizeData[kQSize]);
-}
-
 // The code below should match translation in
 // chrome/browser/resources/file_manager/js/file_manager.js
 // chrome/browser/resources/file_manager/css/file_manager.css
 // 'audio': /\.(mp3|m4a|oga|ogg|wav)$/i,
 // 'html': /\.(html?)$/i,
 // 'image': /\.(bmp|gif|jpe?g|ico|png|webp)$/i,
 // 'pdf' : /\.(pdf)$/i,
 // 'text': /\.(pod|rst|txt|log)$/i,
 // 'video': /\.(mov|mp4|m4v|mpe?g4?|ogm|ogv|ogx|webm)$/i
 
@@ skipping 34 matching lines @@
     std::make_pair(".ogv", kVideoIdrs),
     std::make_pair(".ogx", kVideoIdrs),
     std::make_pair(".webm", kVideoIdrs),
   };
 
   const size_t kESize = arraysize(kExtensionIdrBySizeData);
   return ExtensionIconSizeMap(&kExtensionIdrBySizeData[0],
                               &kExtensionIdrBySizeData[kESize]);
 }
 
-// Split on the very first &. The first part is path, the rest query.
-void GetExtensionAndQuery(const std::string& url,
-                          std::string* extension,
-                          std::string* query) {
-  // We receive the url with chrome://fileicon/ stripped but GURL expects it.
-  const GURL gurl("chrome://fileicon/" + net::EscapePath(url));
-  const std::string path = gurl.path();
-  *extension = StringToLowerASCII(FilePath(path).Extension());
-  *query = gurl.query();
-}
-
-// Simple parser for data on the query.
-IconLoader::IconSize QueryToIconSize(const std::string& query) {
-  CR_DEFINE_STATIC_LOCAL(
-      QueryIconSizeMap, kQueryIconSizeMap, (BuildQueryIconSizeMap()));
-  typedef std::pair<std::string, std::string> KVPair;
-  std::vector<KVPair> parameters;
-  if (base::SplitStringIntoKeyValuePairs(query, '=', '&', &parameters)) {
-    for (std::vector<KVPair>::const_iterator itk = parameters.begin();
-         itk != parameters.end(); ++itk) {
-      if (itk->first == kIconSize) {
-        QueryIconSizeMap::const_iterator itq(
-            kQueryIconSizeMap.find(itk->second));
-        if (itq != kQueryIconSizeMap.end())
-          return itq->second;
-      }
-    }
-  }
-  return IconLoader::NORMAL;
-}
-
 // Finds matching resource of proper size. Fallback to generic.
-int UrlToIDR(const std::string& url) {
+int FileTypeToIDR(const std::string& extension, IconLoader::IconSize size) {
   CR_DEFINE_STATIC_LOCAL(
       ExtensionIconSizeMap, kExtensionIdrSizeMap, (BuildExtensionIdrSizeMap()));
-  std::string extension, query;
   int idr = -1;
-  GetExtensionAndQuery(url, &extension, &query);
-  const IconLoader::IconSize size = QueryToIconSize(query);
   ExtensionIconSizeMap::const_iterator it =
       kExtensionIdrSizeMap.find(extension);
   if (it != kExtensionIdrSizeMap.end()) {
     IdrBySize idrbysize = it->second;
     if (size == IconLoader::SMALL) {
       idr = idrbysize.idr_small_;
     } else if (size == IconLoader::NORMAL) {
       idr = idrbysize.idr_normal_;
     } else if (size == IconLoader::LARGE) {
       idr = idrbysize.idr_large_;
     }
   }
   if (idr == -1) {
     if (size == IconLoader::SMALL) {
       idr = kGenericIdrs.idr_small_;
     } else if (size == IconLoader::NORMAL) {
       idr = kGenericIdrs.idr_normal_;
     } else {
       idr = kGenericIdrs.idr_large_;
     }
   }
   return idr;
 }
+
+SkBitmap* GenerateBitmapWithSize(SkBitmap* source, int pixel_size) {
+  DCHECK(source);
+  DCHECK(source->width() == source->height());
+
+  if (pixel_size == -1 || source->width() == pixel_size)
+    return new SkBitmap(*source);
+
+  return new SkBitmap(skia::ImageOperations::Resize(
+      *source, skia::ImageOperations::RESIZE_BEST, pixel_size, pixel_size));
+}
+
+int IconSizeToPixelSize(IconLoader::IconSize size) {
+  switch (size) {
+    case IconLoader::SMALL:  return 16;
+    case IconLoader::NORMAL: return 32;
+    case IconLoader::LARGE:  // fallthrough

[ilja, 2012/01/22 02:31:43]

What happens when LARGE is requested? CrOS file manager uses some icons that are
128 large I believe. Not sure they would go through this path right now.

[asanka, 2012/01/23 19:16:47]

The pixel size determined here is used to decide whether we need to resize the
image before sending it out. If an icon size of LARGE is requested (also the
case for ALL),  we return the image as-is without resizing.  If the size of the
resource was 128x128, then the resulting image would be 128x128.

Consequently, if we only have a 16px image, then:
  SMALL = 16px
  NORMAL = 16px resized to 32px
  LARGE = 16px

If we have a 16px small icon, and a 128px large icon,
  SMALL = 16px
  NORMAL = 128px resized to 32px
  LARGE = 128px

+    case IconLoader::ALL:    // fallthrough
+    default:
+      return -1;
+  }
+}
+
 }  // namespace
 
-FileIconSourceCros::FileIconSourceCros()
-    : DataSource("fileicon", NULL) {
+void IconLoader::ReadIcon() {
+  int idr = FileTypeToIDR(group_, icon_size_);
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  scoped_refptr<RefCountedStaticMemory> bytes(rb.LoadDataResourceBytes(idr));
+  DCHECK(bytes.get());
+  SkBitmap bitmap;
+  if (!gfx::PNGCodec::Decode(bytes->front(), bytes->size(), &bitmap)) {
+    NOTREACHED();
+  }
+  image_.reset(new gfx::Image(
+      GenerateBitmapWithSize(&bitmap, IconSizeToPixelSize(icon_size_))));
+  target_message_loop_->PostTask(
+      FROM_HERE, base::Bind(&IconLoader::NotifyDelegate, this));
 }
-
-FileIconSourceCros::~FileIconSourceCros() {
-}
-
-void FileIconSourceCros::StartDataRequest(const std::string& url,
-                                          bool is_incognito,
-                                          int request_id) {
-  int idr = UrlToIDR(url);
-  const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  scoped_refptr<RefCountedStaticMemory> bytes(rb.LoadDataResourceBytes(idr));
-  SendResponse(request_id, bytes);
-}
-
-// The mime type refers to the type of the response/icon served.
-std::string FileIconSourceCros::GetMimeType(
-    const std::string& url) const {
-  return "image/png";
-}