Don't derive from ChromeURLDataManager::DataSource, and instead have these classes implement a dele…

chrome/browser/ui/webui/extensions/extension_icon_source.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/ui/webui/extensions/extension_icon_source.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/image_loader.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/component_extension_resources_map.h"
 #include "grit/theme_resources.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 19 matching lines @@
 SkBitmap* ToBitmap(const unsigned char* data, size_t size) {
   webkit_glue::ImageDecoder decoder;
   SkBitmap* decoded = new SkBitmap();
   *decoded = decoder.Decode(data, size);
   return decoded;
 }
 
 }  // namespace
 
 ExtensionIconSource::ExtensionIconSource(Profile* profile)
-    : DataSource(chrome::kChromeUIExtensionIconHost, MessageLoop::current()),
-      profile_(profile) {
+    : profile_(profile) {
 }
 
 struct ExtensionIconSource::ExtensionIconRequest {
   int request_id;
   const extensions::Extension* extension;
   bool grayscale;
   int size;
   ExtensionIconSet::MatchType match;
 };
 
@@ skipping 23 matching lines @@
   std::string contents = ResourceBundle::GetSharedInstance()
       .GetRawDataResourceForScale(resource_id,
                                   ui::SCALE_FACTOR_100P).as_string();
 
   // Convert and return it.
   const unsigned char* data =
       reinterpret_cast<const unsigned char*>(contents.data());
   return ToBitmap(data, contents.length());
 }
 
+std::string ExtensionIconSource::GetSource() {
+  return chrome::kChromeUIExtensionIconHost;
+}
+
 std::string ExtensionIconSource::GetMimeType(const std::string&) const {
   // We need to explicitly return a mime type, otherwise if the user tries to
   // drag the image they get no extension.
   return "image/png";
 }
 
 void ExtensionIconSource::StartDataRequest(const std::string& path,
                                            bool is_incognito,
                                            int request_id) {
   // This is where everything gets started. First, parse the request and make
@@ skipping 37 matching lines @@
 
 void ExtensionIconSource::FinalizeImage(const SkBitmap* image,
                                         int request_id) {
   SkBitmap bitmap;
   if (GetData(request_id)->grayscale)
     bitmap = DesaturateImage(image);
   else
     bitmap = *image;
 
   ClearData(request_id);
-  SendResponse(request_id, BitmapToMemory(&bitmap));
+  url_data_source()->SendResponse(request_id, BitmapToMemory(&bitmap));
 }
 
 void ExtensionIconSource::LoadDefaultImage(int request_id) {
   ExtensionIconRequest* request = GetData(request_id);
   const SkBitmap* default_image = NULL;
 
   if (request->extension->is_app())
     default_image = GetDefaultAppImage();
   else
     default_image = GetDefaultExtensionImage();
@@ skipping 10 matching lines @@
 
   FinalizeImage(&resized_image, request_id);
 }
 
 void ExtensionIconSource::LoadExtensionImage(const ExtensionResource& icon,
                                              int request_id) {
   ExtensionIconRequest* request = GetData(request_id);
   extensions::ImageLoader::Get(profile_)->LoadImageAsync(
       request->extension, icon,
       gfx::Size(request->size, request->size),
-      base::Bind(&ExtensionIconSource::OnImageLoaded, this, request_id));
+      base::Bind(&ExtensionIconSource::OnImageLoaded, AsWeakPtr(), request_id));
 }
 
 void ExtensionIconSource::LoadFaviconImage(int request_id) {
   FaviconService* favicon_service =
       FaviconServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
   // Fall back to the default icons if the service isn't available.
   if (favicon_service == NULL) {
     LoadDefaultImage(request_id);
     return;
   }
@@ skipping 16 matching lines @@
   // Fallback to the default icon if there wasn't a favicon.
   if (!bitmap_result.is_valid()) {
     LoadDefaultImage(request_id);
     return;
   }
 
   if (!request->grayscale) {
     // If we don't need a grayscale image, then we can bypass FinalizeImage
     // to avoid unnecessary conversions.
     ClearData(request_id);
-    SendResponse(request_id, bitmap_result.bitmap_data);
+    url_data_source()->SendResponse(request_id, bitmap_result.bitmap_data);
   } else {
     FinalizeImage(ToBitmap(bitmap_result.bitmap_data->front(),
                            bitmap_result.bitmap_data->size()), request_id);
   }
 }
 
 void ExtensionIconSource::OnImageLoaded(int request_id,
                                         const gfx::Image& image) {
   if (image.IsEmpty())
     LoadIconFailed(request_id);
@@ skipping 53 matching lines @@
 
   SetData(request_id, extension, grayscale, size, match_type);
 
   return true;
 }
 
 void ExtensionIconSource::SendDefaultResponse(int request_id) {
   // We send back the default application icon (not resized or desaturated)
   // as the default response, like when there is no data.
   ClearData(request_id);
-  SendResponse(request_id, BitmapToMemory(GetDefaultAppImage()));
+  url_data_source()->SendResponse(
+      request_id, BitmapToMemory(GetDefaultAppImage()));
 }
 
 void ExtensionIconSource::SetData(int request_id,
                                   const extensions::Extension* extension,
                                   bool grayscale,
                                   int size,
                                   ExtensionIconSet::MatchType match) {
   ExtensionIconRequest* request = new ExtensionIconRequest();
   request->request_id = request_id;
   request->extension = extension;
@@ skipping 10 matching lines @@
 
 void ExtensionIconSource::ClearData(int request_id) {
   std::map<int, ExtensionIconRequest*>::iterator i =
       request_map_.find(request_id);
   if (i == request_map_.end())
     return;
 
   delete i->second;
   request_map_.erase(i);
 }