Give platform apps control over launcher right-click context menu.

chrome/browser/ui/app_list/extension_app_item.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/app_list/extension_app_item.h"
 
 #include "base/utf_string_conversions.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/extensions/context_menu_matcher.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/extension_uninstall_dialog.h"
 #include "chrome/browser/extensions/management_policy.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
+#include "content/public/common/context_menu_params.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/extensions/api/rtc_private/rtc_private_api.h"
 #endif
 
 using extensions::Extension;
@@ skipping 81 matching lines @@
   profile->GetExtensionService()->extension_prefs()->SetLaunchType(
       extension_id, launch_type);
 }
 
 bool IsExtensionEnabled(Profile* profile, const std::string& extension_id) {
   ExtensionService* service = profile->GetExtensionService();
   return service->IsExtensionEnabled(extension_id) &&
       !service->GetTerminatedExtension(extension_id);
 }
 
+bool MenuItemHasLauncherContext(const extensions::MenuItem* item) {
+  return item->contexts().Contains(extensions::MenuItem::LAUNCHER);
+}
+
 }  // namespace
 
 ExtensionAppItem::ExtensionAppItem(Profile* profile,
                                    const Extension* extension,
                                    AppListController* controller)
     : ChromeAppListItem(TYPE_APP),
       profile_(profile),
       extension_id_(extension->id()),
       controller_(controller) {
   SetTitle(extension->name());
@@ skipping 74 matching lines @@
   } else {
     NOTREACHED();
     return string16();
   }
 }
 
 bool ExtensionAppItem::IsCommandIdChecked(int command_id) const {
   if (command_id >= LAUNCH_TYPE_START && command_id < LAUNCH_TYPE_LAST) {
     return static_cast<int>(GetExtensionLaunchType(profile_, extension_id_)) +
         LAUNCH_TYPE_START == command_id;
+  } else if (command_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+             command_id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    return extension_menu_items_->IsCommandIdChecked(command_id);
   }
   return false;
 }
 
 bool ExtensionAppItem::IsCommandIdEnabled(int command_id) const {
   if (command_id == TOGGLE_PIN) {
     return controller_->CanPin();
   } else if (command_id == OPTIONS) {
     const Extension* extension = GetExtension();
     return IsExtensionEnabled(profile_, extension_id_) && extension &&
         !extension->options_url().is_empty();
   } else if (command_id == UNINSTALL) {
     const Extension* extension = GetExtension();
     const extensions::ManagementPolicy* policy =
         extensions::ExtensionSystem::Get(profile_)->management_policy();
     return extension &&
            policy->UserMayModifySettings(extension, NULL);
   } else if (command_id == DETAILS) {
     const Extension* extension = GetExtension();
     return extension && extension->from_webstore();
+  } else if (command_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+             command_id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    return extension_menu_items_->IsCommandIdEnabled(command_id);
   }
   return true;
 }
 
 bool ExtensionAppItem::GetAcceleratorForCommandId(
     int command_id,
     ui::Accelerator* acclelrator) {
   return false;
 }
 
@@ skipping 10 matching lines @@
     SetExtensionLaunchType(profile_,
                            extension_id_,
                            static_cast<extensions::ExtensionPrefs::LaunchType>(
                                command_id - LAUNCH_TYPE_START));
   } else if (command_id == OPTIONS) {
     ShowExtensionOptions();
   } else if (command_id == UNINSTALL) {
     StartExtensionUninstall();
   } else if (command_id == DETAILS) {
     ShowExtensionDetails();
+  } else if (command_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+             command_id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    extension_menu_items_->ExecuteCommand(command_id,
+                                          content::ContextMenuParams());
   }
 }
 
 void ExtensionAppItem::Activate(int event_flags) {
   const Extension* extension = GetExtension();
   if (!extension)
     return;
 
 #if defined(OS_CHROMEOS)
   // Talk extension isn't an app, send special rtcPrivate API message to
@@ skipping 10 matching lines @@
   controller_->ActivateApp(profile_, extension->id(), event_flags);
 }
 
 ui::MenuModel* ExtensionAppItem::GetContextMenuModel() {
   // No context menu for Chrome app.
   if (extension_id_ == extension_misc::kChromeAppId)
     return NULL;
 
   if (!context_menu_model_.get()) {
     context_menu_model_.reset(new ui::SimpleMenuModel(this));
+    extension_menu_items_.reset(new extensions::ContextMenuMatcher(
+        profile_, this, context_menu_model_.get(),
+        base::Bind(MenuItemHasLauncherContext)));
+
     context_menu_model_->AddItem(LAUNCH, UTF8ToUTF16(title()));
     // Talk extension isn't an app and so doesn't support most launch options.
     if (!IsTalkExtension()) {
+      int index = 0;
+      extension_menu_items_->AppendExtensionItems(extension_id_, string16(),
+                                                  &index);
       context_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
       context_menu_model_->AddItemWithStringId(
           TOGGLE_PIN,
           controller_->IsAppPinned(extension_id_) ?
               IDS_APP_LIST_CONTEXT_MENU_UNPIN :
               IDS_APP_LIST_CONTEXT_MENU_PIN);
       context_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
       context_menu_model_->AddCheckItemWithStringId(
           LAUNCH_TYPE_REGULAR_TAB,
           IDS_APP_CONTEXT_MENU_OPEN_REGULAR);
@@ skipping 11 matching lines @@
     }
     context_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
     context_menu_model_->AddItemWithStringId(OPTIONS, IDS_NEW_TAB_APP_OPTIONS);
     context_menu_model_->AddItemWithStringId(DETAILS, IDS_NEW_TAB_APP_DETAILS);
     context_menu_model_->AddItemWithStringId(UNINSTALL,
                                              IDS_EXTENSIONS_UNINSTALL);
   }
 
   return context_menu_model_.get();
 }