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;
+  content::MenuItem item = icon_map_.find(id)->second;
+  int command_id = RenderViewContextMenuBase::ConvertToContentCustomCommandId(
+      item.action);
+  gfx::Image* icon = new gfx::Image(gfx::Image::CreateFrom1xBitmap(bitmaps[0]));

[lazyboy, 2015/02/05 01:09:55]

|icon| is leaked after this function returns, right?
You'll need to find a better way to manage lifetime of this.

[pals, 2015/02/05 09:01:02]

Done.

+  UpdateMenuItem(command_id, item.enabled, false, item.label, icon);

[lazyboy, 2015/02/05 01:09:55]

The .enabled and .label can be retrieved from the menu_model_ instead of storing
it separately in the map.
This is also race-y, e.g. you're updating the label to the initial/original
value; What if the label already changed before tis download finishes.

Consider the following:
you have an item with label "a", has an icon
you initiate download of the icon
something else changes the label of the same item to "b"
download icon finishes and it updates the icon, but also incorrectly updates the
label to "a".

+}
+
+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),

[lazyboy, 2015/02/05 01:09:55]

this URL is coming from the renderer/ process, so we need to make sure we don't
do unexpected things. We can ask some security folks to chime in here, I'll do
that once other concerns are addressed.

[pals, 2015/02/05 09:01:02]

I think we should put a max size limitation on the icon's size.

+          false,  // is_favicon
+          0,      // no max size
+          base::Bind(&RenderViewContextMenuBase::OnIconDownloaded,
+                     weak_ptr_factory_.GetWeakPtr()));
+      icon_map_[download_id] = items[i];
+    }
+
     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 38 matching lines @@
 
 void RenderViewContextMenuBase::AddSubMenu(int command_id,
                                        const base::string16& label,
                                        ui::MenuModel* model) {
   menu_model_.AddSubMenu(command_id, label, model);
 }
 
 void RenderViewContextMenuBase::UpdateMenuItem(int command_id,
                                            bool enabled,
                                            bool hidden,
-                                           const base::string16& label) {
+                                           const base::string16& label,
+                                           gfx::Image* icon) {
   if (toolkit_delegate_) {
     toolkit_delegate_->UpdateMenuItem(command_id,
                                       enabled,
                                       hidden,
-                                      label);
+                                      label,
+                                      icon);
   }
 }
 
 RenderViewHost* RenderViewContextMenuBase::GetRenderViewHost() const {
   return source_web_contents_->GetRenderViewHost();
 }
 
 WebContents* RenderViewContextMenuBase::GetWebContents() const {
   return source_web_contents_;
 }
@@ skipping 143 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);
 }