Attempt to load component extension favicon from the resources first.

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/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
+#include "grit/component_extension_resources_map.h"
+#include "grit/theme_resources.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
 
@@ skipping 153 matching lines @@
   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_++;
   load_map_[id] = load_info;
 
   for (std::vector<ImageInfo>::const_iterator it = info_list.begin();
        it != info_list.end(); ++it) {
+    // Load resources for component extensions.
+    if (load_info.extension_id == extension_misc::kWebStoreAppId) {
+      OnImageLoaded(
+          ExtensionIconSource::LoadImageByResourceId(IDR_WEBSTORE_ICON),
+          it->resource, it->max_size, id, false);
+      continue;
+    }
+
     // 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, false);
       continue;
     }
 
+    SkBitmap* from_resources = TryLoadingComponentExtensionImage(extension,
+                                                                 it->resource);
+    if (from_resources) {
+      OnImageLoaded(from_resources, it->resource, it->max_size, id, false);

[Finnur, 2012/04/10 13:46:39]

You've selected in both cases to not honor the |cache| param and hard-code it to
false instead. Is that what we want?

[dgozman, 2012/04/10 14:19:48]

Why do we cache icon available locally and waste some space?

[Finnur, 2012/04/10 14:32:21]

All the files this class deals with are local, so I don't see how this would be
different? We cache so we don't have to load the files from disk each time and
can respond quickly with the image on the UI thread when it has been loaded
once.

The question you should be asking yourself is: The API for this class allows for
caching of the image. Are you certain it is correct in all cases to ignore the
|caching| parameter when we load resources of this type? Shouldn't we let the
caller decide?

If so, the cache needs to be consulted first (see line 216).


On 2012/04/10 14:19:48, dgozman wrote:

[dgozman, 2012/04/10 16:59:51]

Oh, now I see. Changed so the |CacheParam| decides.

+      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, false);
       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);
   }
 }
 
+SkBitmap* ImageLoadingTracker::TryLoadingComponentExtensionImage(
+    const Extension* extension,
+    const ExtensionResource& resource) {
+  if (extension->location() != Extension::COMPONENT)
+    return NULL;
+
+  FilePath directory_path = extension->path();
+  FilePath relative_path = directory_path.BaseName().Append(
+      resource.relative_path());
+
+  for (size_t i = 0; i < kComponentExtensionResourcesSize; ++i) {
+    FilePath bm_resource_path =
+        FilePath().AppendASCII(kComponentExtensionResources[i].name);
+    bm_resource_path = bm_resource_path.NormalizePathSeparators();
+
+    if (relative_path == bm_resource_path) {
+      return ExtensionIconSource::LoadImageByResourceId(
+          kComponentExtensionResources[i].value);

[Finnur, 2012/04/10 14:32:21]

Wait, we're on the UI thread here so we should not be performing this request
here (it does IO).

[dgozman, 2012/04/10 16:59:51]

Done.

+    }
+  }
+  return NULL;
+}
+
 void ImageLoadingTracker::OnImageLoaded(
     SkBitmap* image,
     const ExtensionResource& resource,
     const gfx::Size& original_size,
     int id,
     bool should_cache) {
   LoadMap::iterator load_map_it = load_map_.find(id);
   DCHECK(load_map_it != load_map_.end());
   PendingLoadInfo* info = &load_map_it->second;
 
@@ skipping 45 matching lines @@
   // 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;
     }
   }
 }