Show icons for custom menuitems in contextmenu.

components/renderer_context_menu/render_view_context_menu_base.cc

 // Copyright 2014 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 "components/renderer_context_menu/render_view_context_menu_base.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/menu_item.h"
 #include "third_party/WebKit/public/web/WebContextMenuData.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia_operations.h"
 
 using blink::WebContextMenuData;
 using blink::WebString;
 using blink::WebURL;
 using content::BrowserContext;
 using content::OpenURLParams;
 using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::WebContents;
 
@@ skipping 30 matching lines @@
     if (items[i].type == content::MenuItem::SUBMENU) {
       if (IsCustomItemCheckedInternal(items[i].submenu, id))
         return true;
     }
   }
   return false;
 }
 
 const size_t kMaxCustomMenuDepth = 5;
 const size_t kMaxCustomMenuTotalItems = 1000;
+const size_t kMenuItemIconSize = 16;
+
+void OnIconDownloaded(RenderViewContextMenuBase* menu,
+                      int command_id,
+                      int id,
+                      int http_status_code,
+                      const GURL& image_url,
+                      const std::vector<SkBitmap>& bitmaps,
+                      const std::vector<gfx::Size>& original_bitmap_sizes) {
+  if (bitmaps.empty())
+    return;
+  gfx::ImageSkia icon = gfx::ImageSkia::CreateFrom1xBitmap(bitmaps[0]);
+  // Scale icon to a 16X16 size.
+  gfx::ImageSkia scaled_icon =
+      gfx::ImageSkiaOperations::CreateResizedImage(
+          icon,
+          skia::ImageOperations::RESIZE_BEST,
+          gfx::Size(kMenuItemIconSize, kMenuItemIconSize));
+  if (menu)
+    menu->SetIcon(command_id, scaled_icon);
+}
 
 void AddCustomItemsToMenu(const std::vector<content::MenuItem>& items,
                           size_t depth,
                           size_t* total_items,
                           ui::SimpleMenuModel::Delegate* delegate,
-                          ui::SimpleMenuModel* menu_model) {
+                          ui::SimpleMenuModel* menu_model,
+                          content::WebContents* web_contents) {
   if (depth > kMaxCustomMenuDepth) {
     LOG(ERROR) << "Custom menu too deeply nested.";
     return;
   }
   for (size_t i = 0; i < items.size(); ++i) {
     int command_id = RenderViewContextMenuBase::ConvertToContentCustomCommandId(
         items[i].action);
+    if (items[i].icon.is_valid()) {

[jochen (gone - plz use gerrit), 2015/02/24 10:26:57]

i'm still concerned what happens if you specify for example a chrome:// URL or a
chrome-extension:// URL

what about data: URLs, are they allowed?

+      web_contents->DownloadImage(
+          items[i].icon,
+          true,  // is_favicon
+          0,     // unlimited
+          base::Bind(OnIconDownloaded,
+                     base::Unretained(
+                         static_cast<RenderViewContextMenuBase*>(delegate)),
+                     command_id));
+    }
+
     if (!RenderViewContextMenuBase::IsContentCustomCommandId(command_id)) {
       LOG(ERROR) << "Custom menu action value out of range.";
       return;
     }
     if (*total_items >= kMaxCustomMenuTotalItems) {
       LOG(ERROR) << "Custom menu too large (too many items).";
       return;
     }
     (*total_items)++;
     switch (items[i].type) {
@@ skipping 12 matching lines @@
       case content::MenuItem::GROUP:
         // TODO(viettrungluu): I don't know what this is supposed to do.
         NOTREACHED();
         break;
       case content::MenuItem::SEPARATOR:
         menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
         break;
       case content::MenuItem::SUBMENU: {
         ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(delegate);
         AddCustomItemsToMenu(items[i].submenu, depth + 1, total_items, delegate,
-                             submenu);
+                             submenu, web_contents);
         menu_model->AddSubMenu(
             RenderViewContextMenuBase::ConvertToContentCustomCommandId(
                 items[i].action),
             items[i].label,
             submenu);
         break;
       }
       default:
         NOTREACHED();
         break;
@@ skipping 83 matching lines @@
 void RenderViewContextMenuBase::AddSeparator() {
   menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
 }
 
 void RenderViewContextMenuBase::AddSubMenu(int command_id,
                                        const base::string16& label,
                                        ui::MenuModel* model) {
   menu_model_.AddSubMenu(command_id, label, model);
 }
 
+void RenderViewContextMenuBase::SetIcon(int command_id,
+                                        const gfx::ImageSkia& icon) {
+  if (toolkit_delegate_)
+    toolkit_delegate_->SetIcon(command_id, icon);
+}
+
 void RenderViewContextMenuBase::UpdateMenuItem(int command_id,
                                            bool enabled,
                                            bool hidden,
                                            const base::string16& label) {
   if (toolkit_delegate_) {
     toolkit_delegate_->UpdateMenuItem(command_id,
                                       enabled,
                                       hidden,
                                       label);
   }
 }
 
 RenderViewHost* RenderViewContextMenuBase::GetRenderViewHost() const {
   return source_web_contents_->GetRenderViewHost();
 }
 
 WebContents* RenderViewContextMenuBase::GetWebContents() const {
   return source_web_contents_;
 }
 
 BrowserContext* RenderViewContextMenuBase::GetBrowserContext() const {
   return browser_context_;
 }
 
 bool RenderViewContextMenuBase::AppendCustomItems() {
   size_t total_items = 0;
   AddCustomItemsToMenu(params_.custom_items, 0, &total_items, this,
-                       &menu_model_);
+                       &menu_model_, source_web_contents_);
   return total_items > 0;
 }
 
 bool RenderViewContextMenuBase::IsCommandIdKnown(
     int id,
     bool* enabled) const {
   // If this command is is added by one of our observers, we dispatch
   // it to the observer.
   ObserverListBase<RenderViewContextMenuObserver>::Iterator it(observers_);
   RenderViewContextMenuObserver* observer;
@@ skipping 124 matching lines @@
 }
 
 bool RenderViewContextMenuBase::IsCustomItemChecked(int id) const {
   return IsCustomItemCheckedInternal(params_.custom_items, id);
 }
 
 bool RenderViewContextMenuBase::IsCustomItemEnabled(int id) const {
   return IsCustomItemEnabledInternal(params_.custom_items, id);
 }