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"
 
 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 31 matching lines @@
       if (IsCustomItemCheckedInternal(items[i].submenu, id))
         return true;
     }
   }
   return false;
 }
 
 const size_t kMaxCustomMenuDepth = 5;
 const size_t kMaxCustomMenuTotalItems = 1000;
 
-void AddCustomItemsToMenu(const std::vector<content::MenuItem>& items,
-                          size_t depth,
-                          size_t* total_items,
-                          ui::SimpleMenuModel::Delegate* delegate,
-                          ui::SimpleMenuModel* menu_model) {
+}  // namespace
+
+void RenderViewContextMenuBase::OnIconDownloaded(
+    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;
+  SetIcon(icon_map_.find(id)->second,
+          gfx::Image(gfx::Image::CreateFrom1xBitmap(bitmaps[0])));
+}
+
+void RenderViewContextMenuBase::AddCustomItemsToMenu(
+    const std::vector<content::MenuItem>& items,
+    size_t depth,
+    size_t* total_items,
+    ui::SimpleMenuModel::Delegate* delegate,
+    ui::SimpleMenuModel* menu_model) {
   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.empty()) {
+      int download_id = source_web_contents_->DownloadImage(
+          GURL(items[i].icon),
+          false,  // is_favicon
+          0,      // no max size
+          base::Bind(&RenderViewContextMenuBase::OnIconDownloaded,
+                     weak_ptr_factory_.GetWeakPtr()));
+      icon_map_[download_id] = command_id;

[lazyboy, 2015/02/09 23:45:23]

You don't need this map, you can bind |command_id| to OnIconDownloaded call
above.

[pals, 2015/02/10 12:19:41]

Done.

+    }
+
     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 27 matching lines @@
             submenu);
         break;
       }
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
-}  // namespace
-
 // static
 void RenderViewContextMenuBase::SetContentCustomCommandIdRange(
     int first, int last) {
   // The range is inclusive.
   content_context_custom_first = first;
   content_context_custom_last = last;
 }
 
 // static
 const size_t RenderViewContextMenuBase::kMaxSelectionTextLength = 50;
@@ skipping 11 matching lines @@
 
 RenderViewContextMenuBase::RenderViewContextMenuBase(
     content::RenderFrameHost* render_frame_host,
     const content::ContextMenuParams& params)
     : params_(params),
       source_web_contents_(WebContents::FromRenderFrameHost(render_frame_host)),
       browser_context_(source_web_contents_->GetBrowserContext()),
       menu_model_(this),
       render_frame_id_(render_frame_host->GetRoutingID()),
       command_executed_(false),
-      render_process_id_(render_frame_host->GetProcess()->GetID()) {
+      render_process_id_(render_frame_host->GetProcess()->GetID()),
+      weak_ptr_factory_(this) {
 }
 
 RenderViewContextMenuBase::~RenderViewContextMenuBase() {
 }
 
 // Menu construction functions -------------------------------------------------
 
 void RenderViewContextMenuBase::Init() {
   // Command id range must have been already initializerd.
   DCHECK_NE(-1, content_context_custom_first);
@@ skipping 35 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::Image& icon) {
+  if (toolkit_delegate_) {

[lazyboy, 2015/02/09 23:45:23]

nit: no need for {} if it's a one liner.

[pals, 2015/02/10 12:19:41]

Done.

+    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);
   }
@@ skipping 152 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);
 }