Simplify WebUI data sources. Currently WebUI data sources implement a URLDataSourceDelegate interfa…

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 23 matching lines @@
   return decoded;
 }
 
 }  // namespace
 
 ExtensionIconSource::ExtensionIconSource(Profile* profile)
     : profile_(profile) {
 }
 
 struct ExtensionIconSource::ExtensionIconRequest {
-  int request_id;
+  content::URLDataSource::GotDataCallback callback;
   const extensions::Extension* extension;
   bool grayscale;
   int size;
   ExtensionIconSet::MatchType match;
 };
 
 // static
 GURL ExtensionIconSource::GetIconURL(const extensions::Extension* extension,
                                      int icon_size,
                                      ExtensionIconSet::MatchType match,
@@ skipping 29 matching lines @@
 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) {
+void ExtensionIconSource::StartDataRequest(
+    const std::string& path,
+    bool is_incognito,
+    const content::URLDataSource::GotDataCallback& callback) {
   // This is where everything gets started. First, parse the request and make
   // the request data available for later.
-  if (!ParseData(path, request_id)) {
-    SendDefaultResponse(request_id);
+  static int next_id = 0;
+  if (!ParseData(path, ++next_id, callback)) {
+    SendDefaultResponse(next_id);
     return;
   }
 
-  ExtensionIconRequest* request = GetData(request_id);
+  ExtensionIconRequest* request = GetData(next_id);
   ExtensionResource icon =
       request->extension->GetIconResource(request->size, request->match);
 
   if (icon.relative_path().empty()) {
-    LoadIconFailed(request_id);
+    LoadIconFailed(next_id);
   } else {
-    LoadExtensionImage(icon, request_id);
+    LoadExtensionImage(icon, next_id);
   }
 }
 
 ExtensionIconSource::~ExtensionIconSource() {
   // Clean up all the temporary data we're holding for requests.
   STLDeleteValues(&request_map_);
 }
 
 const SkBitmap* ExtensionIconSource::GetDefaultAppImage() {
   if (!default_app_data_.get())
     default_app_data_.reset(LoadImageByResourceId(IDR_APP_DEFAULT_ICON));
 
   return default_app_data_.get();
 }
 
 const SkBitmap* ExtensionIconSource::GetDefaultExtensionImage() {
   if (!default_extension_data_.get()) {
     default_extension_data_.reset(
         LoadImageByResourceId(IDR_EXTENSION_DEFAULT_ICON));
   }
 
   return default_extension_data_.get();
 }
 
 void ExtensionIconSource::FinalizeImage(const SkBitmap* image,
                                         int request_id) {
   SkBitmap bitmap;
-  if (GetData(request_id)->grayscale)
+  ExtensionIconRequest* request = GetData(request_id);
+  if (request->grayscale)
     bitmap = DesaturateImage(image);
   else
     bitmap = *image;
 
+  request->callback.Run(BitmapToMemory(&bitmap));
   ClearData(request_id);
-  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 46 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.
+    request->callback.Run(bitmap_result.bitmap_data);
     ClearData(request_id);
-    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);
   else
     FinalizeImage(image.ToSkBitmap(), request_id);
 }
 
 void ExtensionIconSource::LoadIconFailed(int request_id) {
   ExtensionIconRequest* request = GetData(request_id);
   ExtensionResource icon =
       request->extension->GetIconResource(request->size, request->match);
 
   if (request->size == extension_misc::EXTENSION_ICON_BITTY)
     LoadFaviconImage(request_id);
   else
     LoadDefaultImage(request_id);
 }
 
-bool ExtensionIconSource::ParseData(const std::string& path,
-                                    int request_id) {
+bool ExtensionIconSource::ParseData(
+    const std::string& path,
+    int request_id,
+    const content::URLDataSource::GotDataCallback& callback) {
   // Extract the parameters from the path by lower casing and splitting.
   std::string path_lower = StringToLowerASCII(path);
   std::vector<std::string> path_parts;
 
   base::SplitString(path_lower, '/', &path_parts);
   if (path_lower.empty() || path_parts.size() < 3)
     return false;
 
   std::string size_param = path_parts.at(1);
   std::string match_param = path_parts.at(2);
@@ skipping 17 matching lines @@
 
   std::string extension_id = path_parts.at(0);
   const extensions::Extension* extension =
       extensions::ExtensionSystem::Get(profile_)->extension_service()->
           GetInstalledExtension(extension_id);
   if (!extension)
     return false;
 
   bool grayscale = path_lower.find("grayscale=true") != std::string::npos;
 
-  SetData(request_id, extension, grayscale, size, match_type);
+  SetData(request_id, callback, 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.
+  ExtensionIconRequest* request = GetData(request_id);
+  request->callback.Run(BitmapToMemory(GetDefaultAppImage()));
   ClearData(request_id);
-  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) {
+void ExtensionIconSource::SetData(
+    int request_id,
+    const content::URLDataSource::GotDataCallback& callback,
+    const extensions::Extension* extension,
+    bool grayscale,
+    int size,
+    ExtensionIconSet::MatchType match) {
   ExtensionIconRequest* request = new ExtensionIconRequest();
-  request->request_id = request_id;
+  request->callback = callback;
   request->extension = extension;
   request->grayscale = grayscale;
   request->size = size;
   request->match = match;
   request_map_[request_id] = request;
 }
 
 ExtensionIconSource::ExtensionIconRequest* ExtensionIconSource::GetData(
     int request_id) {
   return request_map_[request_id];
 }
 
 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);
 }