Change browser/page action default icon defined in manifest to support hidpi.

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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 160 matching lines @@
     }
 
     ReportBack(decoded.release(), image_info, original_size, id,
                true /* delete bitmap */);
   }
 
   // Instructs the loader to load a resource on the File thread.
   void LoadResource(const ImageRepresentation& image_info,
                     int id,
                     int resource_id) {
+LOG(ERROR) << "post load job to file thread";
     DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&ImageLoader::LoadResourceOnFileThread, this, image_info,
                    id, resource_id));
   }
 
   void LoadResourceOnFileThread(const ImageRepresentation& image_info,
                                 int id,
                                 int resource_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     const SkBitmap* bitmap = ResourceBundle::GetSharedInstance().GetImageNamed(
         resource_id).ToSkBitmap();
     ReportBack(bitmap, image_info, image_info.desired_size, id,
                false /* don't delete bitmap */);
   }
 
   void ReportBack(const SkBitmap* bitmap, const ImageRepresentation& image_info,
                   const gfx::Size& original_size, int id, bool delete_bitmap) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
+LOG(ERROR) << "post load job resp to calling thread";
     BrowserThread::PostTask(
         callback_thread_id_, FROM_HERE,
         base::Bind(&ImageLoader::ReportOnCallingThread, this,
                    bitmap, image_info, original_size, id, delete_bitmap));
   }
 
   void ReportOnCallingThread(const SkBitmap* bitmap,
                              const ImageRepresentation& image_info,
                              const gfx::Size& original_size,
                              int id,
                              bool delete_bitmap) {
     DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
-
+LOG(ERROR) << "OnBitmapLoaded";
     if (tracker_)
       tracker_->OnBitmapLoaded(bitmap, image_info, original_size, id, true);
 
     if (bitmap && delete_bitmap)
       delete bitmap;
   }
 
  private:
   friend class base::RefCountedThreadSafe<ImageLoader>;
   ~ImageLoader() {}
@@ skipping 146 matching lines @@
   if (info->pending_count == 0) {
     gfx::Image image;
     std::string extension_id = info->extension_id;
 
     if (!info->image_skia.isNull()) {
       info->image_skia.MakeThreadSafe();
       image = gfx::Image(info->image_skia);
     }
 
     load_map_.erase(load_map_it);
-
+LOG(ERROR) << "on image loaded";
     // ImageLoadingTracker might be deleted after the callback so don't do
     // anything after this statement.
     observer_->OnImageLoaded(image, extension_id, id);
   }
 }
 
 void ImageLoadingTracker::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED);
 
   const Extension* extension =
       content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
 
   // Remove reference to this extension from all pending load entries. This
   // ensures we don't attempt to cache the bitmap 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;
     }
   }
 }