chrome/browser/extensions/menu_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/menu_manager.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/json/json_writer.h"
  10 #include "base/logging.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/chrome_notification_types.h"
  16 #include "chrome/browser/extensions/extension_service.h"
  17 #include "chrome/browser/extensions/extension_tab_util.h"
  18 #include "chrome/browser/extensions/menu_manager_factory.h"
  19 #include "chrome/browser/extensions/tab_helper.h"
  20 #include "chrome/browser/profiles/profile.h"
  21 #include "chrome/common/extensions/api/chrome_web_view_internal.h"
  22 #include "chrome/common/extensions/api/context_menus.h"
  23 #include "content/public/browser/notification_details.h"
  24 #include "content/public/browser/notification_service.h"
  25 #include "content/public/browser/notification_source.h"
  26 #include "content/public/browser/web_contents.h"
  27 #include "content/public/common/context_menu_params.h"
  28 #include "extensions/browser/event_router.h"
  29 #include "extensions/browser/extension_registry.h"
  30 #include "extensions/browser/extension_system.h"
  31 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
  32 #include "extensions/browser/state_store.h"
  33 #include "extensions/common/extension.h"
  34 #include "extensions/common/manifest_handlers/background_info.h"
  35 #include "ui/gfx/favicon_size.h"
  36 #include "ui/gfx/text_elider.h"
  37
  38 using content::WebContents;
  39 using extensions::ExtensionSystem;
  40
  41 namespace extensions {
  42
  43 namespace context_menus = api::context_menus;
  44 namespace chrome_web_view = api::chrome_web_view_internal;
  45
  46 namespace {
  47
  48 // Keys for serialization to and from Value to store in the preferences.
  49 const char kContextMenusKey[] = "context_menus";
  50
  51 const char kCheckedKey[] = "checked";
  52 const char kContextsKey[] = "contexts";
  53 const char kDocumentURLPatternsKey[] = "document_url_patterns";
  54 const char kEnabledKey[] = "enabled";
  55 const char kIncognitoKey[] = "incognito";
  56 const char kParentUIDKey[] = "parent_uid";
  57 const char kStringUIDKey[] = "string_uid";
  58 const char kTargetURLPatternsKey[] = "target_url_patterns";
  59 const char kTitleKey[] = "title";
  60 const char kTypeKey[] = "type";
  61
  62 void SetIdKeyValue(base::DictionaryValue* properties,
  63                    const char* key,
  64                    const MenuItem::Id& id) {
  65   if (id.uid == 0)
  66     properties->SetString(key, id.string_uid);
  67   else
  68     properties->SetInteger(key, id.uid);
  69 }
  70
  71 MenuItem::List MenuItemsFromValue(const std::string& extension_id,
  72                                   base::Value* value) {
  73   MenuItem::List items;
  74
  75   base::ListValue* list = NULL;
  76   if (!value || !value->GetAsList(&list))
  77     return items;
  78
  79   for (size_t i = 0; i < list->GetSize(); ++i) {
  80     base::DictionaryValue* dict = NULL;
  81     if (!list->GetDictionary(i, &dict))
  82       continue;
  83     MenuItem* item = MenuItem::Populate(
  84         extension_id, *dict, NULL);
  85     if (!item)
  86       continue;
  87     items.push_back(item);
  88   }
  89   return items;
  90 }
  91
  92 scoped_ptr<base::Value> MenuItemsToValue(const MenuItem::List& items) {
  93   scoped_ptr<base::ListValue> list(new base::ListValue());
  94   for (size_t i = 0; i < items.size(); ++i)
  95     list->Append(items[i]->ToValue().release());
  96   return scoped_ptr<base::Value>(list.release());
  97 }
  98
  99 bool GetStringList(const base::DictionaryValue& dict,
 100                    const std::string& key,
 101                    std::vector<std::string>* out) {
 102   if (!dict.HasKey(key))
 103     return true;
 104
 105   const base::ListValue* list = NULL;
 106   if (!dict.GetListWithoutPathExpansion(key, &list))
 107     return false;
 108
 109   for (size_t i = 0; i < list->GetSize(); ++i) {
 110     std::string pattern;
 111     if (!list->GetString(i, &pattern))
 112       return false;
 113     out->push_back(pattern);
 114   }
 115
 116   return true;
 117 }
 118
 119 }  // namespace
 120
 121 MenuItem::MenuItem(const Id& id,
 122                    const std::string& title,
 123                    bool checked,
 124                    bool enabled,
 125                    Type type,
 126                    const ContextList& contexts)
 127     : id_(id),
 128       title_(title),
 129       type_(type),
 130       checked_(checked),
 131       enabled_(enabled),
 132       contexts_(contexts) {}
 133
 134 MenuItem::~MenuItem() {
 135   STLDeleteElements(&children_);
 136 }
 137
 138 MenuItem* MenuItem::ReleaseChild(const Id& child_id,
 139                                  bool recursive) {
 140   for (List::iterator i = children_.begin(); i != children_.end(); ++i) {
 141     MenuItem* child = NULL;
 142     if ((*i)->id() == child_id) {
 143       child = *i;
 144       children_.erase(i);
 145       return child;
 146     } else if (recursive) {
 147       child = (*i)->ReleaseChild(child_id, recursive);
 148       if (child)
 149         return child;
 150     }
 151   }
 152   return NULL;
 153 }
 154
 155 void MenuItem::GetFlattenedSubtree(MenuItem::List* list) {
 156   list->push_back(this);
 157   for (List::iterator i = children_.begin(); i != children_.end(); ++i)
 158     (*i)->GetFlattenedSubtree(list);
 159 }
 160
 161 std::set<MenuItem::Id> MenuItem::RemoveAllDescendants() {
 162   std::set<Id> result;
 163   for (List::iterator i = children_.begin(); i != children_.end(); ++i) {
 164     MenuItem* child = *i;
 165     result.insert(child->id());
 166     std::set<Id> removed = child->RemoveAllDescendants();
 167     result.insert(removed.begin(), removed.end());
 168   }
 169   STLDeleteElements(&children_);
 170   return result;
 171 }
 172
 173 base::string16 MenuItem::TitleWithReplacement(const base::string16& selection,
 174                                               size_t max_length) const {
 175   base::string16 result = base::UTF8ToUTF16(title_);
 176   // TODO(asargent) - Change this to properly handle %% escaping so you can
 177   // put "%s" in titles that won't get substituted.
 178   ReplaceSubstringsAfterOffset(&result, 0, base::ASCIIToUTF16("%s"), selection);
 179
 180   if (result.length() > max_length)
 181     result = gfx::TruncateString(result, max_length, gfx::WORD_BREAK);
 182   return result;
 183 }
 184
 185 bool MenuItem::SetChecked(bool checked) {
 186   if (type_ != CHECKBOX && type_ != RADIO)
 187     return false;
 188   checked_ = checked;
 189   return true;
 190 }
 191
 192 void MenuItem::AddChild(MenuItem* item) {
 193   item->parent_id_.reset(new Id(id_));
 194   children_.push_back(item);
 195 }
 196
 197 scoped_ptr<base::DictionaryValue> MenuItem::ToValue() const {
 198   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
 199   // Should only be called for extensions with event pages, which only have
 200   // string IDs for items.
 201   DCHECK_EQ(0, id_.uid);
 202   value->SetString(kStringUIDKey, id_.string_uid);
 203   value->SetBoolean(kIncognitoKey, id_.incognito);
 204   value->SetInteger(kTypeKey, type_);
 205   if (type_ != SEPARATOR)
 206     value->SetString(kTitleKey, title_);
 207   if (type_ == CHECKBOX || type_ == RADIO)
 208     value->SetBoolean(kCheckedKey, checked_);
 209   value->SetBoolean(kEnabledKey, enabled_);
 210   value->Set(kContextsKey, contexts_.ToValue().release());
 211   if (parent_id_) {
 212     DCHECK_EQ(0, parent_id_->uid);
 213     value->SetString(kParentUIDKey, parent_id_->string_uid);
 214   }
 215   value->Set(kDocumentURLPatternsKey,
 216              document_url_patterns_.ToValue().release());
 217   value->Set(kTargetURLPatternsKey, target_url_patterns_.ToValue().release());
 218   return value.Pass();
 219 }
 220
 221 // static
 222 MenuItem* MenuItem::Populate(const std::string& extension_id,
 223                              const base::DictionaryValue& value,
 224                              std::string* error) {
 225   bool incognito = false;
 226   if (!value.GetBoolean(kIncognitoKey, &incognito))
 227     return NULL;
 228   Id id(incognito, MenuItem::ExtensionKey(extension_id));
 229   if (!value.GetString(kStringUIDKey, &id.string_uid))
 230     return NULL;
 231   int type_int;
 232   Type type = NORMAL;
 233   if (!value.GetInteger(kTypeKey, &type_int))
 234     return NULL;
 235   type = static_cast<Type>(type_int);
 236   std::string title;
 237   if (type != SEPARATOR && !value.GetString(kTitleKey, &title))
 238     return NULL;
 239   bool checked = false;
 240   if ((type == CHECKBOX || type == RADIO) &&
 241       !value.GetBoolean(kCheckedKey, &checked)) {
 242     return NULL;
 243   }
 244   bool enabled = true;
 245   if (!value.GetBoolean(kEnabledKey, &enabled))
 246     return NULL;
 247   ContextList contexts;
 248   const base::Value* contexts_value = NULL;
 249   if (!value.Get(kContextsKey, &contexts_value))
 250     return NULL;
 251   if (!contexts.Populate(*contexts_value))
 252     return NULL;
 253
 254   scoped_ptr<MenuItem> result(new MenuItem(
 255       id, title, checked, enabled, type, contexts));
 256
 257   std::vector<std::string> document_url_patterns;
 258   if (!GetStringList(value, kDocumentURLPatternsKey, &document_url_patterns))
 259     return NULL;
 260   std::vector<std::string> target_url_patterns;
 261   if (!GetStringList(value, kTargetURLPatternsKey, &target_url_patterns))
 262     return NULL;
 263
 264   if (!result->PopulateURLPatterns(&document_url_patterns,
 265                                    &target_url_patterns,
 266                                    error)) {
 267     return NULL;
 268   }
 269
 270   // parent_id is filled in from the value, but it might not be valid. It's left
 271   // to be validated upon being added (via AddChildItem) to the menu manager.
 272   scoped_ptr<Id> parent_id(
 273       new Id(incognito, MenuItem::ExtensionKey(extension_id)));
 274   if (value.HasKey(kParentUIDKey)) {
 275     if (!value.GetString(kParentUIDKey, &parent_id->string_uid))
 276       return NULL;
 277     result->parent_id_.swap(parent_id);
 278   }
 279   return result.release();
 280 }
 281
 282 bool MenuItem::PopulateURLPatterns(
 283     std::vector<std::string>* document_url_patterns,
 284     std::vector<std::string>* target_url_patterns,
 285     std::string* error) {
 286   if (document_url_patterns) {
 287     if (!document_url_patterns_.Populate(
 288             *document_url_patterns, URLPattern::SCHEME_ALL, true, error)) {
 289       return false;
 290     }
 291   }
 292   if (target_url_patterns) {
 293     if (!target_url_patterns_.Populate(
 294             *target_url_patterns, URLPattern::SCHEME_ALL, true, error)) {
 295       return false;
 296     }
 297   }
 298   return true;
 299 }
 300
 301 // static
 302 const char MenuManager::kOnContextMenus[] = "contextMenus";
 303 const char MenuManager::kOnWebviewContextMenus[] =
 304     "webViewInternal.contextMenus";
 305
 306 MenuManager::MenuManager(content::BrowserContext* context, StateStore* store)
 307     : extension_registry_observer_(this),
 308       browser_context_(context),
 309       store_(store) {
 310   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 311   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
 312                  content::NotificationService::AllSources());
 313   if (store_)
 314     store_->RegisterKey(kContextMenusKey);
 315 }
 316
 317 MenuManager::~MenuManager() {
 318   MenuItemMap::iterator i;
 319   for (i = context_items_.begin(); i != context_items_.end(); ++i) {
 320     STLDeleteElements(&(i->second));
 321   }
 322 }
 323
 324 // static
 325 MenuManager* MenuManager::Get(content::BrowserContext* context) {
 326   return MenuManagerFactory::GetForBrowserContext(context);
 327 }
 328
 329 std::set<MenuItem::ExtensionKey> MenuManager::ExtensionIds() {
 330   std::set<MenuItem::ExtensionKey> id_set;
 331   for (MenuItemMap::const_iterator i = context_items_.begin();
 332        i != context_items_.end(); ++i) {
 333     id_set.insert(i->first);
 334   }
 335   return id_set;
 336 }
 337
 338 const MenuItem::List* MenuManager::MenuItems(
 339     const MenuItem::ExtensionKey& key) {
 340   MenuItemMap::iterator i = context_items_.find(key);
 341   if (i != context_items_.end()) {
 342     return &(i->second);
 343   }
 344   return NULL;
 345 }
 346
 347 bool MenuManager::AddContextItem(const Extension* extension, MenuItem* item) {
 348   const MenuItem::ExtensionKey& key = item->id().extension_key;
 349   // The item must have a non-empty extension id, and not have already been
 350   // added.
 351   if (key.empty() || ContainsKey(items_by_id_, item->id()))
 352     return false;
 353
 354   DCHECK_EQ(extension->id(), key.extension_id);
 355
 356   bool first_item = !ContainsKey(context_items_, key);
 357   context_items_[key].push_back(item);
 358   items_by_id_[item->id()] = item;
 359
 360   if (item->type() == MenuItem::RADIO) {
 361     if (item->checked())
 362       RadioItemSelected(item);
 363     else
 364       SanitizeRadioList(context_items_[key]);
 365   }
 366
 367   // If this is the first item for this extension, start loading its icon.
 368   if (first_item)
 369     icon_manager_.LoadIcon(browser_context_, extension);
 370
 371   return true;
 372 }
 373
 374 bool MenuManager::AddChildItem(const MenuItem::Id& parent_id,
 375                                MenuItem* child) {
 376   MenuItem* parent = GetItemById(parent_id);
 377   if (!parent || parent->type() != MenuItem::NORMAL ||
 378       parent->incognito() != child->incognito() ||
 379       parent->extension_id() != child->extension_id() ||
 380       ContainsKey(items_by_id_, child->id()))
 381     return false;
 382   parent->AddChild(child);
 383   items_by_id_[child->id()] = child;
 384
 385   if (child->type() == MenuItem::RADIO)
 386     SanitizeRadioList(parent->children());
 387   return true;
 388 }
 389
 390 bool MenuManager::DescendantOf(MenuItem* item,
 391                                const MenuItem::Id& ancestor_id) {
 392   // Work our way up the tree until we find the ancestor or NULL.
 393   MenuItem::Id* id = item->parent_id();
 394   while (id != NULL) {
 395     DCHECK(*id != item->id());  // Catch circular graphs.
 396     if (*id == ancestor_id)
 397       return true;
 398     MenuItem* next = GetItemById(*id);
 399     if (!next) {
 400       NOTREACHED();
 401       return false;
 402     }
 403     id = next->parent_id();
 404   }
 405   return false;
 406 }
 407
 408 bool MenuManager::ChangeParent(const MenuItem::Id& child_id,
 409                                const MenuItem::Id* parent_id) {
 410   MenuItem* child = GetItemById(child_id);
 411   MenuItem* new_parent = parent_id ? GetItemById(*parent_id) : NULL;
 412   if ((parent_id && (child_id == *parent_id)) || !child ||
 413       (!new_parent && parent_id != NULL) ||
 414       (new_parent && (DescendantOf(new_parent, child_id) ||
 415                       child->incognito() != new_parent->incognito() ||
 416                       child->extension_id() != new_parent->extension_id())))
 417     return false;
 418
 419   MenuItem::Id* old_parent_id = child->parent_id();
 420   if (old_parent_id != NULL) {
 421     MenuItem* old_parent = GetItemById(*old_parent_id);
 422     if (!old_parent) {
 423       NOTREACHED();
 424       return false;
 425     }
 426     MenuItem* taken =
 427       old_parent->ReleaseChild(child_id, false /* non-recursive search*/);
 428     DCHECK(taken == child);
 429     SanitizeRadioList(old_parent->children());
 430   } else {
 431     // This is a top-level item, so we need to pull it out of our list of
 432     // top-level items.
 433     const MenuItem::ExtensionKey& child_key = child->id().extension_key;
 434     MenuItemMap::iterator i = context_items_.find(child_key);
 435     if (i == context_items_.end()) {
 436       NOTREACHED();
 437       return false;
 438     }
 439     MenuItem::List& list = i->second;
 440     MenuItem::List::iterator j = std::find(list.begin(), list.end(), child);
 441     if (j == list.end()) {
 442       NOTREACHED();
 443       return false;
 444     }
 445     list.erase(j);
 446     SanitizeRadioList(list);
 447   }
 448
 449   if (new_parent) {
 450     new_parent->AddChild(child);
 451     SanitizeRadioList(new_parent->children());
 452   } else {
 453     const MenuItem::ExtensionKey& child_key = child->id().extension_key;
 454     context_items_[child_key].push_back(child);
 455     child->parent_id_.reset(NULL);
 456     SanitizeRadioList(context_items_[child_key]);
 457   }
 458   return true;
 459 }
 460
 461 bool MenuManager::RemoveContextMenuItem(const MenuItem::Id& id) {
 462   if (!ContainsKey(items_by_id_, id))
 463     return false;
 464
 465   MenuItem* menu_item = GetItemById(id);
 466   DCHECK(menu_item);
 467   const MenuItem::ExtensionKey extension_key = id.extension_key;
 468   MenuItemMap::iterator i = context_items_.find(extension_key);
 469   if (i == context_items_.end()) {
 470     NOTREACHED();
 471     return false;
 472   }
 473
 474   bool result = false;
 475   std::set<MenuItem::Id> items_removed;
 476   MenuItem::List& list = i->second;
 477   MenuItem::List::iterator j;
 478   for (j = list.begin(); j < list.end(); ++j) {
 479     // See if the current top-level item is a match.
 480     if ((*j)->id() == id) {
 481       items_removed = (*j)->RemoveAllDescendants();
 482       items_removed.insert(id);
 483       delete *j;
 484       list.erase(j);
 485       result = true;
 486       SanitizeRadioList(list);
 487       break;
 488     } else {
 489       // See if the item to remove was found as a descendant of the current
 490       // top-level item.
 491       MenuItem* child = (*j)->ReleaseChild(id, true /* recursive */);
 492       if (child) {
 493         items_removed = child->RemoveAllDescendants();
 494         items_removed.insert(id);
 495         SanitizeRadioList(GetItemById(*child->parent_id())->children());
 496         delete child;
 497         result = true;
 498         break;
 499       }
 500     }
 501   }
 502   DCHECK(result);  // The check at the very top should have prevented this.
 503
 504   // Clear entries from the items_by_id_ map.
 505   std::set<MenuItem::Id>::iterator removed_iter;
 506   for (removed_iter = items_removed.begin();
 507        removed_iter != items_removed.end();
 508        ++removed_iter) {
 509     items_by_id_.erase(*removed_iter);
 510   }
 511
 512   if (list.empty()) {
 513     context_items_.erase(extension_key);
 514     icon_manager_.RemoveIcon(extension_key.extension_id);
 515   }
 516   return result;
 517 }
 518
 519 void MenuManager::RemoveAllContextItems(
 520     const MenuItem::ExtensionKey& extension_key) {
 521   MenuItem::List::iterator i;
 522   for (i = context_items_[extension_key].begin();
 523        i != context_items_[extension_key].end();
 524        ++i) {
 525     MenuItem* item = *i;
 526     items_by_id_.erase(item->id());
 527
 528     // Remove descendants from this item and erase them from the lookup cache.
 529     std::set<MenuItem::Id> removed_ids = item->RemoveAllDescendants();
 530     std::set<MenuItem::Id>::const_iterator j;
 531     for (j = removed_ids.begin(); j != removed_ids.end(); ++j) {
 532       items_by_id_.erase(*j);
 533     }
 534   }
 535   STLDeleteElements(&context_items_[extension_key]);
 536   context_items_.erase(extension_key);
 537   icon_manager_.RemoveIcon(extension_key.extension_id);
 538 }
 539
 540 MenuItem* MenuManager::GetItemById(const MenuItem::Id& id) const {
 541   std::map<MenuItem::Id, MenuItem*>::const_iterator i =
 542       items_by_id_.find(id);
 543   if (i != items_by_id_.end())
 544     return i->second;
 545   else
 546     return NULL;
 547 }
 548
 549 void MenuManager::RadioItemSelected(MenuItem* item) {
 550   // If this is a child item, we need to get a handle to the list from its
 551   // parent. Otherwise get a handle to the top-level list.
 552   const MenuItem::List* list = NULL;
 553   if (item->parent_id()) {
 554     MenuItem* parent = GetItemById(*item->parent_id());
 555     if (!parent) {
 556       NOTREACHED();
 557       return;
 558     }
 559     list = &(parent->children());
 560   } else {
 561     const MenuItem::ExtensionKey& key = item->id().extension_key;
 562     if (context_items_.find(key) == context_items_.end()) {
 563       NOTREACHED();
 564       return;
 565     }
 566     list = &context_items_[key];
 567   }
 568
 569   // Find where |item| is in the list.
 570   MenuItem::List::const_iterator item_location;
 571   for (item_location = list->begin(); item_location != list->end();
 572        ++item_location) {
 573     if (*item_location == item)
 574       break;
 575   }
 576   if (item_location == list->end()) {
 577     NOTREACHED();  // We should have found the item.
 578     return;
 579   }
 580
 581   // Iterate backwards from |item| and uncheck any adjacent radio items.
 582   MenuItem::List::const_iterator i;
 583   if (item_location != list->begin()) {
 584     i = item_location;
 585     do {
 586       --i;
 587       if ((*i)->type() != MenuItem::RADIO)
 588         break;
 589       (*i)->SetChecked(false);
 590     } while (i != list->begin());
 591   }
 592
 593   // Now iterate forwards from |item| and uncheck any adjacent radio items.
 594   for (i = item_location + 1; i != list->end(); ++i) {
 595     if ((*i)->type() != MenuItem::RADIO)
 596       break;
 597     (*i)->SetChecked(false);
 598   }
 599 }
 600
 601 static void AddURLProperty(base::DictionaryValue* dictionary,
 602                            const std::string& key, const GURL& url) {
 603   if (!url.is_empty())
 604     dictionary->SetString(key, url.possibly_invalid_spec());
 605 }
 606
 607 void MenuManager::ExecuteCommand(content::BrowserContext* context,
 608                                  WebContents* web_contents,
 609                                  const content::ContextMenuParams& params,
 610                                  const MenuItem::Id& menu_item_id) {
 611   EventRouter* event_router = EventRouter::Get(context);
 612   if (!event_router)
 613     return;
 614
 615   MenuItem* item = GetItemById(menu_item_id);
 616   if (!item)
 617     return;
 618
 619   // ExtensionService/Extension can be NULL in unit tests :(
 620   ExtensionService* service =
 621       ExtensionSystem::Get(browser_context_)->extension_service();
 622   const Extension* extension =
 623       service ? service->extensions()->GetByID(item->extension_id()) : NULL;
 624
 625   if (item->type() == MenuItem::RADIO)
 626     RadioItemSelected(item);
 627
 628   scoped_ptr<base::ListValue> args(new base::ListValue());
 629
 630   base::DictionaryValue* properties = new base::DictionaryValue();
 631   SetIdKeyValue(properties, "menuItemId", item->id());
 632   if (item->parent_id())
 633     SetIdKeyValue(properties, "parentMenuItemId", *item->parent_id());
 634
 635   switch (params.media_type) {
 636     case blink::WebContextMenuData::MediaTypeImage:
 637       properties->SetString("mediaType", "image");
 638       break;
 639     case blink::WebContextMenuData::MediaTypeVideo:
 640       properties->SetString("mediaType", "video");
 641       break;
 642     case blink::WebContextMenuData::MediaTypeAudio:
 643       properties->SetString("mediaType", "audio");
 644       break;
 645     default:  {}  // Do nothing.
 646   }
 647
 648   AddURLProperty(properties, "linkUrl", params.unfiltered_link_url);
 649   AddURLProperty(properties, "srcUrl", params.src_url);
 650   AddURLProperty(properties, "pageUrl", params.page_url);
 651   AddURLProperty(properties, "frameUrl", params.frame_url);
 652
 653   if (params.selection_text.length() > 0)
 654     properties->SetString("selectionText", params.selection_text);
 655
 656   properties->SetBoolean("editable", params.is_editable);
 657
 658   WebViewGuest* webview_guest = WebViewGuest::FromWebContents(web_contents);
 659   if (webview_guest) {
 660     // This is used in web_view_internalcustom_bindings.js.
 661     // The property is not exposed to developer API.
 662     properties->SetInteger("webviewInstanceId",
 663                            webview_guest->view_instance_id());
 664   }
 665
 666   args->Append(properties);
 667
 668   // Add the tab info to the argument list.
 669   // No tab info in a platform app.
 670   if (!extension || !extension->is_platform_app()) {
 671     // Note: web_contents are NULL in unit tests :(
 672     if (web_contents) {
 673       args->Append(ExtensionTabUtil::CreateTabValue(web_contents));
 674     } else {
 675       args->Append(new base::DictionaryValue());
 676     }
 677   }
 678
 679   if (item->type() == MenuItem::CHECKBOX ||
 680       item->type() == MenuItem::RADIO) {
 681     bool was_checked = item->checked();
 682     properties->SetBoolean("wasChecked", was_checked);
 683
 684     // RADIO items always get set to true when you click on them, but CHECKBOX
 685     // items get their state toggled.
 686     bool checked =
 687         (item->type() == MenuItem::RADIO) ? true : !was_checked;
 688
 689     item->SetChecked(checked);
 690     properties->SetBoolean("checked", item->checked());
 691
 692     if (extension)
 693       WriteToStorage(extension, item->id().extension_key);
 694   }
 695
 696   // Note: web_contents are NULL in unit tests :(
 697   if (web_contents && extensions::TabHelper::FromWebContents(web_contents)) {
 698     extensions::TabHelper::FromWebContents(web_contents)->
 699         active_tab_permission_granter()->GrantIfRequested(extension);
 700   }
 701
 702   {
 703     // Dispatch to menu item's .onclick handler.
 704     scoped_ptr<Event> event(
 705         new Event(webview_guest ? kOnWebviewContextMenus
 706                                 : kOnContextMenus,
 707                   scoped_ptr<base::ListValue>(args->DeepCopy())));
 708     event->restrict_to_browser_context = context;
 709     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
 710     event_router->DispatchEventToExtension(item->extension_id(), event.Pass());
 711   }
 712   {
 713     // Dispatch to .contextMenus.onClicked handler.
 714     scoped_ptr<Event> event(
 715         new Event(webview_guest ? chrome_web_view::OnClicked::kEventName
 716                                 : context_menus::OnClicked::kEventName,
 717                   args.Pass()));
 718     event->restrict_to_browser_context = context;
 719     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
 720     if (webview_guest)
 721       event->filter_info.SetInstanceID(webview_guest->view_instance_id());
 722     event_router->DispatchEventToExtension(item->extension_id(), event.Pass());
 723   }
 724 }
 725
 726 void MenuManager::SanitizeRadioList(const MenuItem::List& item_list) {
 727   MenuItem::List::const_iterator i = item_list.begin();
 728   while (i != item_list.end()) {
 729     if ((*i)->type() != MenuItem::RADIO) {
 730       ++i;
 731       break;
 732     }
 733
 734     // Uncheck any checked radio items in the run, and at the end reset
 735     // the appropriate one to checked. If no check radio items were found,
 736     // then check the first radio item in the run.
 737     MenuItem::List::const_iterator last_checked = item_list.end();
 738     MenuItem::List::const_iterator radio_run_iter;
 739     for (radio_run_iter = i; radio_run_iter != item_list.end();
 740         ++radio_run_iter) {
 741       if ((*radio_run_iter)->type() != MenuItem::RADIO) {
 742         break;
 743       }
 744
 745       if ((*radio_run_iter)->checked()) {
 746         last_checked = radio_run_iter;
 747         (*radio_run_iter)->SetChecked(false);
 748       }
 749     }
 750
 751     if (last_checked != item_list.end())
 752       (*last_checked)->SetChecked(true);
 753     else
 754       (*i)->SetChecked(true);
 755
 756     i = radio_run_iter;
 757   }
 758 }
 759
 760 bool MenuManager::ItemUpdated(const MenuItem::Id& id) {
 761   if (!ContainsKey(items_by_id_, id))
 762     return false;
 763
 764   MenuItem* menu_item = GetItemById(id);
 765   DCHECK(menu_item);
 766
 767   if (menu_item->parent_id()) {
 768     SanitizeRadioList(GetItemById(*menu_item->parent_id())->children());
 769   } else {
 770     MenuItemMap::iterator i =
 771         context_items_.find(menu_item->id().extension_key);
 772     if (i == context_items_.end()) {
 773       NOTREACHED();
 774       return false;
 775     }
 776     SanitizeRadioList(i->second);
 777   }
 778
 779   return true;
 780 }
 781
 782 void MenuManager::WriteToStorage(const Extension* extension,
 783                                  const MenuItem::ExtensionKey& extension_key) {
 784   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
 785     return;
 786   // <webview> menu items are transient and not stored in storage.
 787   if (extension_key.webview_instance_id)
 788     return;
 789   const MenuItem::List* top_items = MenuItems(extension_key);
 790   MenuItem::List all_items;
 791   if (top_items) {
 792     for (MenuItem::List::const_iterator i = top_items->begin();
 793          i != top_items->end(); ++i) {
 794       DCHECK(!(*i)->id().extension_key.webview_instance_id);
 795       (*i)->GetFlattenedSubtree(&all_items);
 796     }
 797   }
 798
 799   if (store_) {
 800     store_->SetExtensionValue(extension->id(), kContextMenusKey,
 801                               MenuItemsToValue(all_items));
 802   }
 803 }
 804
 805 void MenuManager::ReadFromStorage(const std::string& extension_id,
 806                                   scoped_ptr<base::Value> value) {
 807   const Extension* extension = ExtensionSystem::Get(browser_context_)
 808                                    ->extension_service()
 809                                    ->extensions()
 810                                    ->GetByID(extension_id);
 811   if (!extension)
 812     return;
 813
 814   MenuItem::List items = MenuItemsFromValue(extension_id, value.get());
 815   for (size_t i = 0; i < items.size(); ++i) {
 816     bool added = false;
 817
 818     if (items[i]->parent_id()) {
 819       // Parent IDs are stored in the parent_id field for convenience, but
 820       // they have not yet been validated. Separate them out here.
 821       // Because of the order in which we store items in the prefs, parents will
 822       // precede children, so we should already know about any parent items.
 823       scoped_ptr<MenuItem::Id> parent_id;
 824       parent_id.swap(items[i]->parent_id_);
 825       added = AddChildItem(*parent_id, items[i]);
 826     } else {
 827       added = AddContextItem(extension, items[i]);
 828     }
 829
 830     if (!added)
 831       delete items[i];
 832   }
 833 }
 834
 835 void MenuManager::OnExtensionLoaded(content::BrowserContext* browser_context,
 836                                     const Extension* extension) {
 837   if (store_ && BackgroundInfo::HasLazyBackgroundPage(extension)) {
 838     store_->GetExtensionValue(
 839         extension->id(),
 840         kContextMenusKey,
 841         base::Bind(
 842             &MenuManager::ReadFromStorage, AsWeakPtr(), extension->id()));
 843   }
 844 }
 845
 846 void MenuManager::OnExtensionUnloaded(content::BrowserContext* browser_context,
 847                                       const Extension* extension,
 848                                       UnloadedExtensionInfo::Reason reason) {
 849   MenuItem::ExtensionKey extension_key(extension->id());
 850   if (ContainsKey(context_items_, extension_key)) {
 851     RemoveAllContextItems(extension_key);
 852   }
 853 }
 854
 855 void MenuManager::Observe(int type,
 856                           const content::NotificationSource& source,
 857                           const content::NotificationDetails& details) {
 858   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
 859   Profile* profile = content::Source<Profile>(source).ptr();
 860   // We cannot use profile_->HasOffTheRecordProfile as it may already be
 861   // false at this point, if for example the incognito profile was destroyed
 862   // using DestroyOffTheRecordProfile.
 863   if (profile->GetOriginalProfile() == browser_context_ &&
 864       profile->GetOriginalProfile() != profile) {
 865     RemoveAllIncognitoContextItems();
 866   }
 867 }
 868
 869 const SkBitmap& MenuManager::GetIconForExtension(
 870     const std::string& extension_id) {
 871   return icon_manager_.GetIcon(extension_id);
 872 }
 873
 874 void MenuManager::RemoveAllIncognitoContextItems() {
 875   // Get all context menu items with "incognito" set to "split".
 876   std::set<MenuItem::Id> items_to_remove;
 877   std::map<MenuItem::Id, MenuItem*>::const_iterator iter;
 878   for (iter = items_by_id_.begin();
 879        iter != items_by_id_.end();
 880        ++iter) {
 881     if (iter->first.incognito)
 882       items_to_remove.insert(iter->first);
 883   }
 884
 885   std::set<MenuItem::Id>::iterator remove_iter;
 886   for (remove_iter = items_to_remove.begin();
 887        remove_iter != items_to_remove.end();
 888        ++remove_iter)
 889     RemoveContextMenuItem(*remove_iter);
 890 }
 891
 892 MenuItem::ExtensionKey::ExtensionKey() : webview_instance_id(0) {}
 893
 894 MenuItem::ExtensionKey::ExtensionKey(const std::string& extension_id,
 895                                      int webview_instance_id)
 896     : extension_id(extension_id), webview_instance_id(webview_instance_id) {}
 897
 898 MenuItem::ExtensionKey::ExtensionKey(const std::string& extension_id)
 899     : extension_id(extension_id), webview_instance_id(0) {}
 900
 901 bool MenuItem::ExtensionKey::operator==(const ExtensionKey& other) const {
 902   return extension_id == other.extension_id &&
 903          webview_instance_id == other.webview_instance_id;
 904 }
 905
 906 bool MenuItem::ExtensionKey::operator<(const ExtensionKey& other) const {
 907   if (extension_id != other.extension_id)
 908     return extension_id < other.extension_id;
 909
 910   return webview_instance_id < other.webview_instance_id;
 911 }
 912
 913 bool MenuItem::ExtensionKey::operator!=(const ExtensionKey& other) const {
 914   return !(*this == other);
 915 }
 916
 917 bool MenuItem::ExtensionKey::empty() const {
 918   return extension_id.empty() && !webview_instance_id;
 919 }
 920
 921 MenuItem::Id::Id() : incognito(false), uid(0) {}
 922
 923 MenuItem::Id::Id(bool incognito, const MenuItem::ExtensionKey& extension_key)
 924     : incognito(incognito), extension_key(extension_key), uid(0) {}
 925
 926 MenuItem::Id::~Id() {
 927 }
 928
 929 bool MenuItem::Id::operator==(const Id& other) const {
 930   return (incognito == other.incognito &&
 931           extension_key == other.extension_key && uid == other.uid &&
 932           string_uid == other.string_uid);
 933 }
 934
 935 bool MenuItem::Id::operator!=(const Id& other) const {
 936   return !(*this == other);
 937 }
 938
 939 bool MenuItem::Id::operator<(const Id& other) const {
 940   if (incognito < other.incognito)
 941     return true;
 942   if (incognito == other.incognito) {
 943     if (extension_key < other.extension_key)
 944       return true;
 945     if (extension_key == other.extension_key) {
 946       if (uid < other.uid)
 947         return true;
 948       if (uid == other.uid)
 949         return string_uid < other.string_uid;
 950     }
 951   }
 952   return false;
 953 }
 954
 955 }  // namespace extensions