Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(123)

Side by Side Diff: chrome/browser/extensions/image_loading_tracker.cc

Issue 10825012: chromeos: Fix pixelated icons in app list and launcher (part 2) (by xiyuan) (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "chrome/browser/extensions/image_loading_tracker.h" 5 #include "chrome/browser/extensions/image_loading_tracker.h"
6 6
7 #include <string> 7 #include <string>
8 #include <vector> 8 #include <vector>
9 9
10 #include "base/bind.h" 10 #include "base/bind.h"
11 #include "base/file_util.h" 11 #include "base/file_util.h"
12 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h" 12 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
13 #include "chrome/common/chrome_notification_types.h" 13 #include "chrome/common/chrome_notification_types.h"
14 #include "chrome/common/extensions/extension.h" 14 #include "chrome/common/extensions/extension.h"
15 #include "chrome/common/extensions/extension_constants.h" 15 #include "chrome/common/extensions/extension_constants.h"
16 #include "chrome/common/extensions/extension_resource.h" 16 #include "chrome/common/extensions/extension_resource.h"
17 #include "content/public/browser/browser_thread.h" 17 #include "content/public/browser/browser_thread.h"
18 #include "content/public/browser/notification_service.h" 18 #include "content/public/browser/notification_service.h"
19 #include "grit/component_extension_resources_map.h" 19 #include "grit/component_extension_resources_map.h"
20 #include "grit/theme_resources.h" 20 #include "grit/theme_resources.h"
21 #include "skia/ext/image_operations.h" 21 #include "skia/ext/image_operations.h"
22 #include "third_party/skia/include/core/SkBitmap.h" 22 #include "third_party/skia/include/core/SkBitmap.h"
23 #include "ui/gfx/image/image.h" 23 #include "ui/gfx/image/image.h"
24 #include "ui/gfx/image/image_skia.h"
25 #include "ui/gfx/image/image_skia_rep.h" 24 #include "ui/gfx/image/image_skia_rep.h"
26 #include "webkit/glue/image_decoder.h" 25 #include "webkit/glue/image_decoder.h"
27 26
28 using content::BrowserThread; 27 using content::BrowserThread;
29 using extensions::Extension; 28 using extensions::Extension;
30 29
30 namespace {
31
32 struct ComponentExtensionResource {
33 const char* extension_id;
34 const int resource_id;
35 };
36
37 const ComponentExtensionResource kSpecialComponentExtensionResources[] = {
38 { extension_misc::kWebStoreAppId, IDR_WEBSTORE_ICON },
39 { extension_misc::kWebStoreAppId, IDR_PRODUCT_LOGO_128 },
Aaron Boodman 2012/08/02 17:50:56 Why are there two that have the same id?
tbarzic 2012/08/02 20:12:52 looking at the old code, it looks like the second
40 };
41
42 // Finds special component extension resource id for given extension id.
43 bool FindSpecialExtensionResourceId(const std::string& extension_id,
44 int* out_resource_id) {
45 for (size_t i = 0; i < arraysize(kSpecialComponentExtensionResources); ++i) {
46 if (extension_id == kSpecialComponentExtensionResources[i].extension_id) {
47 if (out_resource_id)
48 *out_resource_id = kSpecialComponentExtensionResources[i].resource_id;
49 return true;
50 }
51 }
52
53 return false;
54 }
55
56 } // namespace
57
31 //////////////////////////////////////////////////////////////////////////////// 58 ////////////////////////////////////////////////////////////////////////////////
32 // ImageLoadingTracker::Observer 59 // ImageLoadingTracker::Observer
33 60
34 ImageLoadingTracker::Observer::~Observer() {} 61 ImageLoadingTracker::Observer::~Observer() {}
35 62
36 //////////////////////////////////////////////////////////////////////////////// 63 ////////////////////////////////////////////////////////////////////////////////
37 // ImageLoadingTracker::ImageInfo 64 // ImageLoadingTracker::ImageRepInfo
38 65
39 ImageLoadingTracker::ImageInfo::ImageInfo( 66 ImageLoadingTracker::ImageRepInfo::ImageRepInfo(
40 const ExtensionResource& resource, gfx::Size max_size) 67 const ExtensionResource& resource,
41 : resource(resource), max_size(max_size) { 68 ResizeMethod resize_method,
69 const gfx::Size& desired_size,
70 ui::ScaleFactor scale_factor)
71 : resource(resource),
72 resize_method(resize_method),
73 desired_size(desired_size),
74 scale_factor(scale_factor) {
42 } 75 }
43 76
44 ImageLoadingTracker::ImageInfo::~ImageInfo() { 77 ImageLoadingTracker::ImageRepInfo::~ImageRepInfo() {
45 } 78 }
46 79
47 //////////////////////////////////////////////////////////////////////////////// 80 ////////////////////////////////////////////////////////////////////////////////
48 // ImageLoadingTracker::PendingLoadInfo 81 // ImageLoadingTracker::PendingLoadInfo
49 82
50 ImageLoadingTracker::PendingLoadInfo::PendingLoadInfo() 83 ImageLoadingTracker::PendingLoadInfo::PendingLoadInfo()
51 : extension(NULL), 84 : extension(NULL),
52 cache(CACHE), 85 cache(CACHE),
53 pending_count(0) { 86 pending_count(0) {
54 } 87 }
55 88
56 ImageLoadingTracker::PendingLoadInfo::~PendingLoadInfo() {} 89 ImageLoadingTracker::PendingLoadInfo::~PendingLoadInfo() {}
57 90
58 //////////////////////////////////////////////////////////////////////////////// 91 ////////////////////////////////////////////////////////////////////////////////
59 // ImageLoadingTracker::ImageLoader 92 // ImageLoadingTracker::ImageLoader
60 93
61 // A RefCounted class for loading images on the File thread and reporting back 94 // A RefCounted class for loading bitmaps/image reps on the File thread and
62 // on the UI thread. 95 // reporting back on the UI thread.
63 class ImageLoadingTracker::ImageLoader 96 class ImageLoadingTracker::ImageLoader
64 : public base::RefCountedThreadSafe<ImageLoader> { 97 : public base::RefCountedThreadSafe<ImageLoader> {
65 public: 98 public:
66 explicit ImageLoader(ImageLoadingTracker* tracker) 99 explicit ImageLoader(ImageLoadingTracker* tracker)
67 : tracker_(tracker) { 100 : tracker_(tracker) {
68 CHECK(BrowserThread::GetCurrentThreadIdentifier(&callback_thread_id_)); 101 CHECK(BrowserThread::GetCurrentThreadIdentifier(&callback_thread_id_));
69 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE)); 102 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
70 } 103 }
71 104
72 // Lets this class know that the tracker is no longer interested in the 105 // Lets this class know that the tracker is no longer interested in the
73 // results. 106 // results.
74 void StopTracking() { 107 void StopTracking() {
75 tracker_ = NULL; 108 tracker_ = NULL;
76 } 109 }
77 110
78 // Instructs the loader to load a task on the File thread. 111 // Instructs the loader to load a task on the File thread.
79 void LoadImage(const ExtensionResource& resource, 112 void LoadImage(const ImageRepInfo& image_info, int id) {
80 const gfx::Size& max_size,
81 int id) {
82 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE)); 113 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
83 BrowserThread::PostTask( 114 BrowserThread::PostTask(
84 BrowserThread::FILE, FROM_HERE, 115 BrowserThread::FILE, FROM_HERE,
85 base::Bind(&ImageLoader::LoadOnFileThread, this, resource, 116 base::Bind(&ImageLoader::LoadOnFileThread, this, image_info, id));
86 max_size, id));
87 } 117 }
88 118
89 void LoadOnFileThread(const ExtensionResource& resource, 119 void LoadOnFileThread(const ImageRepInfo& image_info, int id) {
90 const gfx::Size& max_size,
91 int id) {
92 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 120 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
93 121
94 // Read the file from disk. 122 // Read the file from disk.
95 std::string file_contents; 123 std::string file_contents;
96 FilePath path = resource.GetFilePath(); 124 FilePath path = image_info.resource.GetFilePath();
97 if (path.empty() || !file_util::ReadFileToString(path, &file_contents)) { 125 if (path.empty() || !file_util::ReadFileToString(path, &file_contents)) {
98 ReportBack(NULL, resource, gfx::Size(), id); 126 ReportBack(NULL, image_info, gfx::Size(), id);
99 return; 127 return;
100 } 128 }
101 129
102 // Decode the image using WebKit's image decoder. 130 // Decode the bitmap using WebKit's image decoder.
103 const unsigned char* data = 131 const unsigned char* data =
104 reinterpret_cast<const unsigned char*>(file_contents.data()); 132 reinterpret_cast<const unsigned char*>(file_contents.data());
105 webkit_glue::ImageDecoder decoder; 133 webkit_glue::ImageDecoder decoder;
106 scoped_ptr<SkBitmap> decoded(new SkBitmap()); 134 scoped_ptr<SkBitmap> decoded(new SkBitmap());
107 // Note: This class only decodes images from extension resources. Chrome 135 // Note: This class only decodes bitmaps from extension resources. Chrome
108 // doesn't (for security reasons) directly load extension resources provided 136 // doesn't (for security reasons) directly load extension resources provided
109 // by the extension author, but instead decodes them in a separate 137 // by the extension author, but instead decodes them in a separate
110 // locked-down utility process. Only if the decoding succeeds is the image 138 // locked-down utility process. Only if the decoding succeeds is the image
111 // saved from memory to disk and subsequently used in the Chrome UI. 139 // saved from memory to disk and subsequently used in the Chrome UI.
112 // Chrome is therefore decoding images here that were generated by Chrome. 140 // Chrome is therefore decoding bitmaps here that were generated by Chrome.
113 *decoded = decoder.Decode(data, file_contents.length()); 141 *decoded = decoder.Decode(data, file_contents.length());
114 if (decoded->empty()) { 142 if (decoded->empty()) {
115 ReportBack(NULL, resource, gfx::Size(), id); 143 ReportBack(NULL, image_info, gfx::Size(), id);
116 return; // Unable to decode. 144 return; // Unable to decode.
117 } 145 }
118 146
119 gfx::Size original_size(decoded->width(), decoded->height()); 147 gfx::Size original_size(decoded->width(), decoded->height());
120 148
121 if (decoded->width() > max_size.width() || 149 if (image_info.resize_method == ImageRepInfo::ALWAYS_RESIZE ||
Aaron Boodman 2012/08/02 17:50:56 If it is the exact same size, you shouldn't resamp
tbarzic 2012/08/02 20:12:52 Yep, also it may be safer not to rely on ResizeMet
122 decoded->height() > max_size.height()) { 150 decoded->width() > image_info.desired_size.width() ||
151 decoded->height() > image_info.desired_size.height()) {
123 // The bitmap is too big, re-sample. 152 // The bitmap is too big, re-sample.
124 *decoded = skia::ImageOperations::Resize( 153 *decoded = skia::ImageOperations::Resize(
125 *decoded, skia::ImageOperations::RESIZE_LANCZOS3, 154 *decoded, skia::ImageOperations::RESIZE_LANCZOS3,
126 max_size.width(), max_size.height()); 155 image_info.desired_size.width(), image_info.desired_size.height());
127 } 156 }
128 157
129 ReportBack(decoded.release(), resource, original_size, id); 158 ReportBack(decoded.release(), image_info, original_size, id);
130 } 159 }
131 160
132 // Instructs the loader to load a resource on the File thread. 161 // Instructs the loader to load a resource on the File thread.
133 void LoadResource(const ExtensionResource& resource, 162 void LoadResource(const ImageRepInfo& image_info, int id, int resource_id) {
134 const gfx::Size& max_size,
135 int id,
136 int resource_id) {
137 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE)); 163 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
138 BrowserThread::PostTask( 164 BrowserThread::PostTask(
139 BrowserThread::FILE, FROM_HERE, 165 BrowserThread::FILE, FROM_HERE,
140 base::Bind(&ImageLoader::LoadResourceOnFileThread, this, resource, 166 base::Bind(&ImageLoader::LoadResourceOnFileThread, this, image_info,
141 max_size, id, resource_id)); 167 id, resource_id));
142 } 168 }
143 169
144 void LoadResourceOnFileThread(const ExtensionResource& resource, 170 void LoadResourceOnFileThread(const ImageRepInfo& image_info,
145 const gfx::Size& max_size,
146 int id, 171 int id,
147 int resource_id) { 172 int resource_id) {
148 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 173 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
149 SkBitmap* image = ExtensionIconSource::LoadImageByResourceId( 174 SkBitmap* bitmap = ExtensionIconSource::LoadImageByResourceId(
Aaron Boodman 2012/08/02 17:50:56 It's weird layering to call ExtensionIconSource he
tbarzic 2012/08/02 20:12:52 Done.
150 resource_id); 175 resource_id);
151 ReportBack(image, resource, max_size, id); 176 ReportBack(bitmap, image_info, image_info.desired_size, id);
152 } 177 }
153 178
154 void ReportBack(SkBitmap* image, const ExtensionResource& resource, 179 void ReportBack(SkBitmap* bitmap, const ImageRepInfo& image_info,
155 const gfx::Size& original_size, int id) { 180 const gfx::Size& original_size, int id) {
156 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 181 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
157 182
158 BrowserThread::PostTask( 183 BrowserThread::PostTask(
159 callback_thread_id_, FROM_HERE, 184 callback_thread_id_, FROM_HERE,
160 base::Bind(&ImageLoader::ReportOnUIThread, this, 185 base::Bind(&ImageLoader::ReportOnUIThread, this,
161 image, resource, original_size, id)); 186 bitmap, image_info, original_size, id));
162 } 187 }
163 188
164 void ReportOnUIThread(SkBitmap* image, const ExtensionResource& resource, 189 void ReportOnUIThread(SkBitmap* bitmap, const ImageRepInfo& image_info,
165 const gfx::Size& original_size, int id) { 190 const gfx::Size& original_size, int id) {
166 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE)); 191 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
167 192
168 if (tracker_) 193 if (tracker_)
169 tracker_->OnImageLoaded(image, resource, original_size, id, true); 194 tracker_->OnBitmapLoaded(bitmap, image_info, original_size, id, true);
170 195
171 delete image; 196 delete bitmap;
172 } 197 }
173 198
174 private: 199 private:
175 friend class base::RefCountedThreadSafe<ImageLoader>; 200 friend class base::RefCountedThreadSafe<ImageLoader>;
176 ~ImageLoader() {} 201 ~ImageLoader() {}
177 202
178 // The tracker we are loading the image for. If NULL, it means the tracker is 203 // The tracker we are loading the bitmap for. If NULL, it means the tracker is
179 // no longer interested in the reply. 204 // no longer interested in the reply.
180 ImageLoadingTracker* tracker_; 205 ImageLoadingTracker* tracker_;
181 206
182 // The thread that we need to call back on to report that we are done. 207 // The thread that we need to call back on to report that we are done.
183 BrowserThread::ID callback_thread_id_; 208 BrowserThread::ID callback_thread_id_;
184 209
185 DISALLOW_COPY_AND_ASSIGN(ImageLoader); 210 DISALLOW_COPY_AND_ASSIGN(ImageLoader);
186 }; 211 };
187 212
188 //////////////////////////////////////////////////////////////////////////////// 213 ////////////////////////////////////////////////////////////////////////////////
189 // ImageLoadingTracker 214 // ImageLoadingTracker
190 215
191 ImageLoadingTracker::ImageLoadingTracker(Observer* observer) 216 ImageLoadingTracker::ImageLoadingTracker(Observer* observer)
192 : observer_(observer), 217 : observer_(observer),
193 next_id_(0) { 218 next_id_(0) {
194 registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED, 219 registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
195 content::NotificationService::AllSources()); 220 content::NotificationService::AllSources());
196 } 221 }
197 222
198 ImageLoadingTracker::~ImageLoadingTracker() { 223 ImageLoadingTracker::~ImageLoadingTracker() {
199 // The loader is created lazily and is NULL if the tracker is destroyed before 224 // The loader is created lazily and is NULL if the tracker is destroyed before
200 // any valid image load tasks have been posted. 225 // any valid image load tasks have been posted.
201 if (loader_) 226 if (loader_)
202 loader_->StopTracking(); 227 loader_->StopTracking();
203 } 228 }
204 229
230 bool ImageLoadingTracker::CanLoadImage(const extensions::Extension* extension,
Aaron Boodman 2012/08/02 17:50:56 This method is weird. First of all, it doesn't eve
tbarzic 2012/08/02 20:12:52 makes sense.. the version fallbacks to the SCALE_F
231 const ExtensionResource& resource) {
232 if (FindSpecialExtensionResourceId(extension->id(), NULL))
233 return true;
234
235 return !resource.relative_path().empty();
236 }
237
205 void ImageLoadingTracker::LoadImage(const Extension* extension, 238 void ImageLoadingTracker::LoadImage(const Extension* extension,
206 const ExtensionResource& resource, 239 const ExtensionResource& resource,
207 const gfx::Size& max_size, 240 const gfx::Size& max_size,
208 CacheParam cache) { 241 CacheParam cache) {
209 std::vector<ImageInfo> info_list; 242 std::vector<ImageRepInfo> info_list;
210 info_list.push_back(ImageInfo(resource, max_size)); 243 info_list.push_back(ImageRepInfo(resource,
244 ImageRepInfo::RESIZE_WHEN_LARGER,
245 max_size,
246 ui::SCALE_FACTOR_100P));
211 LoadImages(extension, info_list, cache); 247 LoadImages(extension, info_list, cache);
212 } 248 }
213 249
214 void ImageLoadingTracker::LoadImages(const Extension* extension, 250 void ImageLoadingTracker::LoadImages(const Extension* extension,
215 const std::vector<ImageInfo>& info_list, 251 const std::vector<ImageRepInfo>& info_list,
216 CacheParam cache) { 252 CacheParam cache) {
217 PendingLoadInfo load_info; 253 PendingLoadInfo load_info;
218 load_info.extension = extension; 254 load_info.extension = extension;
219 load_info.cache = cache; 255 load_info.cache = cache;
220 load_info.extension_id = extension->id(); 256 load_info.extension_id = extension->id();
221 load_info.pending_count = info_list.size(); 257 load_info.pending_count = info_list.size();
222 int id = next_id_++; 258 int id = next_id_++;
223 load_map_[id] = load_info; 259 load_map_[id] = load_info;
224 260
225 for (std::vector<ImageInfo>::const_iterator it = info_list.begin(); 261 for (std::vector<ImageRepInfo>::const_iterator it = info_list.begin();
226 it != info_list.end(); ++it) { 262 it != info_list.end(); ++it) {
263 int resource_id = -1;
264
227 // Load resources for special component extensions. 265 // Load resources for special component extensions.
228 if (load_info.extension_id == extension_misc::kWebStoreAppId) { 266 if (FindSpecialExtensionResourceId(load_info.extension_id, &resource_id)) {
229 if (!loader_) 267 if (!loader_)
230 loader_ = new ImageLoader(this); 268 loader_ = new ImageLoader(this);
231 loader_->LoadResource(it->resource, it->max_size, id, IDR_WEBSTORE_ICON); 269 loader_->LoadResource(*it, id, resource_id);
232 continue;
233 } else if (load_info.extension_id == extension_misc::kChromeAppId) {
234 if (!loader_)
235 loader_ = new ImageLoader(this);
236 loader_->LoadResource(it->resource,
237 it->max_size,
238 id,
239 IDR_PRODUCT_LOGO_128);
240 continue; 270 continue;
241 } 271 }
242 272
243 // If we don't have a path we don't need to do any further work, just 273 // If we don't have a path we don't need to do any further work, just
244 // respond back. 274 // respond back.
245 if (it->resource.relative_path().empty()) { 275 if (it->resource.relative_path().empty()) {
246 OnImageLoaded(NULL, it->resource, it->max_size, id, false); 276 OnBitmapLoaded(NULL, *it, it->desired_size, id, false);
247 continue; 277 continue;
248 } 278 }
249 279
250 DCHECK(extension->path() == it->resource.extension_root()); 280 DCHECK(extension->path() == it->resource.extension_root());
251 281
252 // See if the extension has the image already. 282 // See if the extension has the bitmap already.
253 if (extension->HasCachedImage(it->resource, it->max_size)) { 283 if (extension->HasCachedImage(it->resource, it->desired_size)) {
254 SkBitmap image = extension->GetCachedImage(it->resource, it->max_size); 284 SkBitmap bitmap = extension->GetCachedImage(it->resource,
255 OnImageLoaded(&image, it->resource, it->max_size, id, false); 285 it->desired_size);
286 OnBitmapLoaded(&bitmap, *it, it->desired_size, id, false);
256 continue; 287 continue;
257 } 288 }
258 289
259 // Instruct the ImageLoader to load this on the File thread. LoadImage and 290 // Instruct the ImageLoader to load this on the File thread. LoadImage and
260 // LoadResource do not block. 291 // LoadResource do not block.
261 if (!loader_) 292 if (!loader_)
262 loader_ = new ImageLoader(this); 293 loader_ = new ImageLoader(this);
263 294
264 int resource_id;
265 if (IsComponentExtensionResource(extension, it->resource, resource_id)) 295 if (IsComponentExtensionResource(extension, it->resource, resource_id))
266 loader_->LoadResource(it->resource, it->max_size, id, resource_id); 296 loader_->LoadResource(*it, id, resource_id);
267 else 297 else
268 loader_->LoadImage(it->resource, it->max_size, id); 298 loader_->LoadImage(*it, id);
269 } 299 }
270 } 300 }
271 301
272 bool ImageLoadingTracker::IsComponentExtensionResource( 302 bool ImageLoadingTracker::IsComponentExtensionResource(
273 const Extension* extension, 303 const Extension* extension,
274 const ExtensionResource& resource, 304 const ExtensionResource& resource,
275 int& resource_id) const { 305 int& resource_id) const {
276 if (extension->location() != Extension::COMPONENT) 306 if (extension->location() != Extension::COMPONENT)
277 return false; 307 return false;
278 308
279 FilePath directory_path = extension->path(); 309 FilePath directory_path = extension->path();
280 FilePath relative_path = directory_path.BaseName().Append( 310 FilePath relative_path = directory_path.BaseName().Append(
281 resource.relative_path()); 311 resource.relative_path());
282 312
283 for (size_t i = 0; i < kComponentExtensionResourcesSize; ++i) { 313 for (size_t i = 0; i < kComponentExtensionResourcesSize; ++i) {
284 FilePath resource_path = 314 FilePath resource_path =
285 FilePath().AppendASCII(kComponentExtensionResources[i].name); 315 FilePath().AppendASCII(kComponentExtensionResources[i].name);
286 resource_path = resource_path.NormalizePathSeparators(); 316 resource_path = resource_path.NormalizePathSeparators();
287 317
288 if (relative_path == resource_path) { 318 if (relative_path == resource_path) {
289 resource_id = kComponentExtensionResources[i].value; 319 resource_id = kComponentExtensionResources[i].value;
290 return true; 320 return true;
291 } 321 }
292 } 322 }
293 return false; 323 return false;
294 } 324 }
295 325
296 void ImageLoadingTracker::OnImageLoaded( 326 void ImageLoadingTracker::OnBitmapLoaded(
297 SkBitmap* image, 327 SkBitmap* bitmap,
298 const ExtensionResource& resource, 328 const ImageRepInfo& image_info,
299 const gfx::Size& original_size, 329 const gfx::Size& original_size,
300 int id, 330 int id,
301 bool should_cache) { 331 bool should_cache) {
302 LoadMap::iterator load_map_it = load_map_.find(id); 332 LoadMap::iterator load_map_it = load_map_.find(id);
303 DCHECK(load_map_it != load_map_.end()); 333 DCHECK(load_map_it != load_map_.end());
304 PendingLoadInfo* info = &load_map_it->second; 334 PendingLoadInfo* info = &load_map_it->second;
305 335
306 // Save the pending results. 336 // Save the pending results.
307 DCHECK(info->pending_count > 0); 337 DCHECK_GT(info->pending_count, 0u);
308 info->pending_count--; 338 info->pending_count--;
309 if (image) 339 if (bitmap) {
310 info->bitmaps.push_back(*image); 340 info->image_skia.AddRepresentation(gfx::ImageSkiaRep(*bitmap,
341 image_info.scale_factor));
Aaron Boodman 2012/08/02 17:50:56 Incorrect indentation. First character of each lin
tbarzic 2012/08/02 20:12:52 Done.
342 }
311 343
312 // Add to the extension's image cache if requested. 344 // Add to the extension's bitmap cache if requested.
313 DCHECK(info->cache != CACHE || info->extension); 345 DCHECK(info->cache != CACHE || info->extension);
314 if (should_cache && info->cache == CACHE && 346 if (should_cache && info->cache == CACHE &&
315 !info->extension->HasCachedImage(resource, original_size)) { 347 !info->extension->HasCachedImage(image_info.resource, original_size)) {
316 info->extension->SetCachedImage(resource, image ? *image : SkBitmap(), 348 info->extension->SetCachedImage(image_info.resource,
349 bitmap ? *bitmap : SkBitmap(),
317 original_size); 350 original_size);
318 } 351 }
319 352
320 // If all pending images are done then report back. 353 // If all pending bitmaps are done then report back.
321 if (info->pending_count == 0) { 354 if (info->pending_count == 0) {
322 gfx::Image image; 355 gfx::Image image;
323 std::string extension_id = info->extension_id; 356 std::string extension_id = info->extension_id;
324 357
325 if (info->bitmaps.size() > 0) { 358 if (!info->image_skia.empty())
326 gfx::ImageSkia image_skia; 359 image = gfx::Image(info->image_skia);
327 for (std::vector<SkBitmap>::const_iterator it = info->bitmaps.begin();
328 it != info->bitmaps.end(); ++it) {
329 // TODO(pkotwicz): Do something better but ONLY when DIP is enabled.
330 image_skia.AddRepresentation(
331 gfx::ImageSkiaRep(*it, ui::SCALE_FACTOR_100P));
332 }
333 image = gfx::Image(image_skia);
334 }
335 360
336 load_map_.erase(load_map_it); 361 load_map_.erase(load_map_it);
337 362
338 // ImageLoadingTracker might be deleted after the callback so don't 363 // ImageLoadingTracker might be deleted after the callback so don't do
339 // anything after this statement. 364 // anything after this statement.
340 observer_->OnImageLoaded(image, extension_id, id); 365 observer_->OnImageLoaded(image, extension_id, id);
341 } 366 }
342 } 367 }
343 368
344 void ImageLoadingTracker::Observe(int type, 369 void ImageLoadingTracker::Observe(int type,
345 const content::NotificationSource& source, 370 const content::NotificationSource& source,
346 const content::NotificationDetails& details) { 371 const content::NotificationDetails& details) {
347 DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED); 372 DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED);
348 373
349 const Extension* extension = 374 const Extension* extension =
350 content::Details<extensions::UnloadedExtensionInfo>(details)->extension; 375 content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
351 376
352 // Remove reference to this extension from all pending load entries. This 377 // Remove reference to this extension from all pending load entries. This
353 // ensures we don't attempt to cache the image when the load completes. 378 // ensures we don't attempt to cache the bitmap when the load completes.
354 for (LoadMap::iterator i = load_map_.begin(); i != load_map_.end(); ++i) { 379 for (LoadMap::iterator i = load_map_.begin(); i != load_map_.end(); ++i) {
355 PendingLoadInfo* info = &i->second; 380 PendingLoadInfo* info = &i->second;
356 if (info->extension == extension) { 381 if (info->extension == extension) {
357 info->extension = NULL; 382 info->extension = NULL;
358 info->cache = DONT_CACHE; 383 info->cache = DONT_CACHE;
359 } 384 }
360 } 385 }
361 } 386 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698