Added new fileBrowserPrivate and fileHandler extension APIs

chrome/browser/tab_contents/render_view_context_menu.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <set>
 
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/page_info_window.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/spellcheck_host.h"
 #include "chrome/browser/spellchecker_platform_engine.h"
+#include "chrome/browser/tab_contents/context_menu_utils.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/translate/translate_prefs.h"
 #include "chrome/browser/ui/download/download_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_restriction.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/print_messages.h"
 #include "chrome/common/url_constants.h"
@@ skipping 142 matching lines @@
 RenderViewContextMenu::~RenderViewContextMenu() {
 }
 
 // Menu construction functions -------------------------------------------------
 
 void RenderViewContextMenu::Init() {
   InitMenu();
   PlatformInit();
 }
 
-static bool ExtensionContextMatch(const ContextMenuParams& params,
-                                  ExtensionMenuItem::ContextList contexts) {
-  bool has_link = !params.link_url.is_empty();
-  bool has_selection = !params.selection_text.empty();
-  bool in_frame = !params.frame_url.is_empty();
-
-  if (contexts.Contains(ExtensionMenuItem::ALL) ||
-      (has_selection && contexts.Contains(ExtensionMenuItem::SELECTION)) ||
-      (has_link && contexts.Contains(ExtensionMenuItem::LINK)) ||
-      (params.is_editable && contexts.Contains(ExtensionMenuItem::EDITABLE)) ||
-      (in_frame && contexts.Contains(ExtensionMenuItem::FRAME))) {
-    return true;
-  }
-
-  switch (params.media_type) {
-    case WebContextMenuData::MediaTypeImage:
-      return contexts.Contains(ExtensionMenuItem::IMAGE);
-
-    case WebContextMenuData::MediaTypeVideo:
-      return contexts.Contains(ExtensionMenuItem::VIDEO);
-
-    case WebContextMenuData::MediaTypeAudio:
-      return contexts.Contains(ExtensionMenuItem::AUDIO);
-
-    default:
-      break;
-  }
-
-  // PAGE is the least specific context, so we only examine that if none of the
-  // other contexts apply (except for FRAME, which is included in PAGE for
-  // backwards compatibility).
-  if (!has_link && !has_selection && !params.is_editable &&
-      params.media_type == WebContextMenuData::MediaTypeNone &&
-      contexts.Contains(ExtensionMenuItem::PAGE))
-    return true;
-
-  return false;
-}
-
-static bool ExtensionPatternMatch(const ExtensionExtent& patterns,
-                                  const GURL& url) {
-  // No patterns means no restriction, so that implicitly matches.
-  if (patterns.is_empty())
-    return true;
-  return patterns.ContainsURL(url);
-}
-
-static const GURL& GetDocumentURL(const ContextMenuParams& params) {
-  return params.frame_url.is_empty() ? params.page_url : params.frame_url;
-}
-
-// Given a list of items, returns the ones that match given the contents
-// of |params| and the profile.
-static ExtensionMenuItem::List GetRelevantExtensionItems(
-    const ExtensionMenuItem::List& items,
-    const ContextMenuParams& params,
-    Profile* profile,
-    bool can_cross_incognito) {
-  ExtensionMenuItem::List result;
-  for (ExtensionMenuItem::List::const_iterator i = items.begin();
-       i != items.end(); ++i) {
-    const ExtensionMenuItem* item = *i;
-
-    if (!ExtensionContextMatch(params, item->contexts()))
-      continue;
-
-    const GURL& document_url = GetDocumentURL(params);
-    if (!ExtensionPatternMatch(item->document_url_patterns(), document_url))
-      continue;
-
-    const GURL& target_url =
-        params.src_url.is_empty() ? params.link_url : params.src_url;
-    if (!ExtensionPatternMatch(item->target_url_patterns(), target_url))
-      continue;
-
-    if (item->id().profile == profile || can_cross_incognito)
-      result.push_back(*i);
-  }
-  return result;
-}
-
 void RenderViewContextMenu::AppendExtensionItems(
     const std::string& extension_id, int* index) {
   ExtensionService* service = profile_->GetExtensionService();
   ExtensionMenuManager* manager = service->menu_manager();
   const Extension* extension = service->GetExtensionById(extension_id, false);
   DCHECK_GE(*index, 0);
   int max_index =
       IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST - IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
   if (!extension || *index >= max_index)
     return;
 
   // Find matching items.
   const ExtensionMenuItem::List* all_items = manager->MenuItems(extension_id);
   if (!all_items || all_items->empty())
     return;
   bool can_cross_incognito = service->CanCrossIncognito(extension);
   ExtensionMenuItem::List items =
-      GetRelevantExtensionItems(*all_items, params_, profile_,
-                                can_cross_incognito);
+      ContextMenuUtils::GetRelevantExtensionItems(*all_items,
+                                                  params_,
+                                                  profile_,
+                                                  can_cross_incognito);
   if (items.empty())
     return;
 
   // If this is the first extension-provided menu item, add a separator.
   if (*index == 0)
     menu_model_.AddSeparator();
 
   int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
 
   // Extensions are only allowed one top-level slot (and it can't be a radio or
   // checkbox item because we are going to put the extension icon next to it).
   // If they have more than that, we automatically push them into a submenu.
   string16 title;
   ExtensionMenuItem::List submenu_items;
   if (items.size() > 1 || items[0]->type() != ExtensionMenuItem::NORMAL) {
     title = UTF8ToUTF16(extension->name());
     submenu_items = items;
   } else {
     ExtensionMenuItem* item = items[0];
     extension_item_map_[menu_id] = item->id();
     title = item->TitleWithReplacement(PrintableSelectionText(),
                                        kMaxExtensionItemTitleLength);
-    submenu_items = GetRelevantExtensionItems(item->children(), params_,
-                                              profile_, can_cross_incognito);
+    submenu_items = ContextMenuUtils::GetRelevantExtensionItems(
+        item->children(), params_, profile_, can_cross_incognito);
   }
 
   // Now add our item(s) to the menu_model_.
   if (submenu_items.empty()) {
     menu_model_.AddItem(menu_id, title);
   } else {
     ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(this);
     extension_menu_models_.push_back(submenu);
     menu_model_.AddSubMenu(menu_id, title, submenu);
     RecursivelyAppendExtensionItems(submenu_items, can_cross_incognito, submenu,
@@ skipping 24 matching lines @@
     }
 
     int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
     if (menu_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST)
       return;
     extension_item_map_[menu_id] = item->id();
     string16 title = item->TitleWithReplacement(selection_text,
                                                 kMaxExtensionItemTitleLength);
     if (item->type() == ExtensionMenuItem::NORMAL) {
       ExtensionMenuItem::List children =
-          GetRelevantExtensionItems(item->children(), params_,
-                                    profile_, can_cross_incognito);
+          ContextMenuUtils::GetRelevantExtensionItems(
+              item->children(), params_, profile_, can_cross_incognito);
       if (children.empty()) {
         menu_model->AddItem(menu_id, title);
       } else {
         ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(this);
         extension_menu_models_.push_back(submenu);
         menu_model->AddSubMenu(menu_id, title, submenu);
         RecursivelyAppendExtensionItems(children, can_cross_incognito,
                                         submenu, index);
       }
     } else if (item->type() == ExtensionMenuItem::CHECKBOX) {
@@ skipping 31 matching lines @@
 
   menu_model_.SetIcon(index, icon);
 }
 
 void RenderViewContextMenu::AppendAllExtensionItems() {
   extension_item_map_.clear();
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return;  // In unit-tests, we may not have an ExtensionService.
   ExtensionMenuManager* menu_manager = service->menu_manager();
-  const GURL& document_url = GetDocumentURL(params_);
+  const GURL& document_url = ContextMenuUtils::GetDocumentURL(params_);
   if (!menu_manager->HasAllowedScheme(document_url))
     return;
 
-  // Get a list of extension id's that have context menu items, and sort it by
-  // the extension's name.
-  std::set<std::string> ids = menu_manager->ExtensionIds();
   std::vector<std::pair<std::string, std::string> > sorted_ids;
-  for (std::set<std::string>::iterator i = ids.begin(); i != ids.end(); ++i) {
-    const Extension* extension = service->GetExtensionById(*i, false);
-    if (extension)
-      sorted_ids.push_back(
-          std::pair<std::string, std::string>(extension->name(), *i));
-  }
-  // TODO(asargent) - See if this works properly for i18n names (bug 32363).
-  std::sort(sorted_ids.begin(), sorted_ids.end());
-
+  ContextMenuUtils::GetSortedContextMenuExtensionIds(service, menu_manager,
+                                                     &sorted_ids);
   if (sorted_ids.empty())
     return;
 
   int index = 0;
   base::TimeTicks begin = base::TimeTicks::Now();
   std::vector<std::pair<std::string, std::string> >::const_iterator i;
   for (i = sorted_ids.begin();
        i != sorted_ids.end(); ++i) {
     AppendExtensionItems(i->second, &index);
   }
@@ skipping 52 matching lines @@
       break;
     case WebContextMenuData::MediaTypeVideo:
       AppendVideoItems();
       break;
     case WebContextMenuData::MediaTypeAudio:
       AppendAudioItems();
       break;
     case WebContextMenuData::MediaTypePlugin:
       AppendPluginItems();
       break;
-#ifdef WEBCONTEXT_MEDIATYPEFILE_DEFINED
     case WebContextMenuData::MediaTypeFile:
+      AppendFileItems();
       break;
-#endif
   }
 
   if (params_.is_editable)
     AppendEditableItems();
   else if (has_selection)
     AppendCopyItem();
 
   if (has_selection)
     AppendSearchProvider();
 
@@ skipping 69 matching lines @@
   AppendMediaItems();
   menu_model_.AddSeparator();
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_SAVEAVAS,
                                   IDS_CONTENT_CONTEXT_SAVEVIDEOAS);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_COPYAVLOCATION,
                                   IDS_CONTENT_CONTEXT_COPYVIDEOLOCATION);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENAVNEWTAB,
                                   IDS_CONTENT_CONTEXT_OPENVIDEONEWTAB);
 }
 
+void RenderViewContextMenu::AppendFileItems() {
+  // TODO(zelidrag): Add file context operations here (i.e. cut, copy, paste...)
+}
+
 void RenderViewContextMenu::AppendMediaItems() {
   int media_flags = params_.media_flags;
 
   menu_model_.AddItemWithStringId(
       IDC_CONTENT_CONTEXT_PLAYPAUSE,
       media_flags & WebContextMenuData::MediaPaused ?
           IDS_CONTENT_CONTEXT_PLAY :
           IDS_CONTENT_CONTEXT_PAUSE);
 
   menu_model_.AddItemWithStringId(
@@ skipping 937 matching lines @@
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void RenderViewContextMenu::MediaPlayerActionAt(
     const gfx::Point& location,
     const WebMediaPlayerAction& action) {
   source_tab_contents_->render_view_host()->MediaPlayerActionAt(
       location, action);
 }