Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/image_loader.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_loader.h"
 
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 53 matching lines @@
                                       image_info.desired_size)) {
     return skia::ImageOperations::Resize(
         bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
         image_info.desired_size.width(), image_info.desired_size.height());
   }
 
   return bitmap;
 }
 
 void LoadResourceOnUIThread(int resource_id, SkBitmap* bitmap) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   gfx::ImageSkia image(
       *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id));
   image.MakeThreadSafe();
   *bitmap = *image.bitmap();
 }
 
 void LoadImageOnBlockingPool(const ImageLoader::ImageRepresentation& image_info,
                              SkBitmap* bitmap) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
@@ skipping 228 matching lines @@
       ImageRepresentation::RESIZE_WHEN_LARGER,
       max_size,
       ui::SCALE_FACTOR_100P));
   LoadImagesAsync(extension, info_list, callback);
 }
 
 void ImageLoader::LoadImagesAsync(
     const Extension* extension,
     const std::vector<ImageRepresentation>& info_list,
     const ImageLoaderImageCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(LoadImagesOnBlockingPool,
                  info_list,
                  LoadResourceBitmaps(extension, info_list)),
       base::Bind(
           &ImageLoader::ReplyBack, weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ImageLoader::LoadImageFamilyAsync(
     const extensions::Extension* extension,
     const std::vector<ImageRepresentation>& info_list,
     const ImageLoaderImageFamilyCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(LoadImagesOnBlockingPool,
                  info_list,
                  LoadResourceBitmaps(extension, info_list)),
       base::Bind(&ImageLoader::ReplyBackWithImageFamily,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ImageLoader::ReplyBack(const ImageLoaderImageCallback& callback,
                             const std::vector<LoadResult>& load_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   gfx::ImageSkia image_skia;
 
   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
        it != load_result.end(); ++it) {
     const SkBitmap& bitmap = it->bitmap;
     const ImageRepresentation& image_rep = it->image_representation;
 
     image_skia.AddRepresentation(gfx::ImageSkiaRep(
         bitmap,
         ui::GetImageScale(image_rep.scale_factor)));
   }
 
   gfx::Image image;
   if (!image_skia.isNull()) {
     image_skia.MakeThreadSafe();
     image = gfx::Image(image_skia);
   }
 
   callback.Run(image);
 }
 
 void ImageLoader::ReplyBackWithImageFamily(
     const ImageLoaderImageFamilyCallback& callback,
     const std::vector<LoadResult>& load_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::map<std::pair<int, int>, gfx::ImageSkia> image_skia_map;
   gfx::ImageFamily image_family;
 
   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
        it != load_result.end();
        ++it) {
     const SkBitmap& bitmap = it->bitmap;
     const ImageRepresentation& image_rep = it->image_representation;
     const std::pair<int, int> key = std::make_pair(
         image_rep.desired_size.width(), image_rep.desired_size.height());
     // Create a new ImageSkia for this width/height, or add a representation to
     // an existing ImageSkia with the same width/height.
     image_skia_map[key].AddRepresentation(
         gfx::ImageSkiaRep(bitmap, ui::GetImageScale(image_rep.scale_factor)));
   }
 
   for (std::map<std::pair<int, int>, gfx::ImageSkia>::iterator it =
            image_skia_map.begin();
        it != image_skia_map.end();
        ++it) {
     it->second.MakeThreadSafe();
     image_family.Add(it->second);
   }
 
   callback.Run(image_family);
 }
 
 }  // namespace extensions