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/state_store.h"
20 #include "chrome/browser/extensions/tab_helper.h"
21 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
22 #include "chrome/browser/profiles/profile.h"
23 #include "chrome/common/extensions/api/context_menus.h"
24 #include "chrome/common/extensions/api/webview.h"
25 #include "content/public/browser/notification_details.h"
26 #include "content/public/browser/notification_service.h"
27 #include "content/public/browser/notification_source.h"
28 #include "content/public/browser/web_contents.h"
29 #include "content/public/common/context_menu_params.h"
30 #include "extensions/browser/event_router.h"
31 #include "extensions/browser/extension_registry.h"
32 #include "extensions/browser/extension_system.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 webview = api::webview;
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
SetIdKeyValue(base::DictionaryValue * properties,const char * key,const MenuItem::Id & id)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
MenuItemsFromValue(const std::string & extension_id,base::Value * value)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
MenuItemsToValue(const MenuItem::List & items)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
GetStringList(const base::DictionaryValue & dict,const std::string & key,std::vector<std::string> * out)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
MenuItem(const Id & id,const std::string & title,bool checked,bool enabled,Type type,const ContextList & contexts)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
~MenuItem()134 MenuItem::~MenuItem() {
135 STLDeleteElements(&children_);
136 }
137
ReleaseChild(const Id & child_id,bool recursive)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
GetFlattenedSubtree(MenuItem::List * list)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
RemoveAllDescendants()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
TitleWithReplacement(const base::string16 & selection,size_t max_length) const173 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);
182 return result;
183 }
184
SetChecked(bool checked)185 bool MenuItem::SetChecked(bool checked) {
186 if (type_ != CHECKBOX && type_ != RADIO)
187 return false;
188 checked_ = checked;
189 return true;
190 }
191
AddChild(MenuItem * item)192 void MenuItem::AddChild(MenuItem* item) {
193 item->parent_id_.reset(new Id(id_));
194 children_.push_back(item);
195 }
196
ToValue() const197 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
Populate(const std::string & extension_id,const base::DictionaryValue & value,std::string * error)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
PopulateURLPatterns(std::vector<std::string> * document_url_patterns,std::vector<std::string> * target_url_patterns,std::string * error)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[] = "webview.contextMenus";
304
MenuManager(Profile * profile,StateStore * store)305 MenuManager::MenuManager(Profile* profile, StateStore* store)
306 : extension_registry_observer_(this), profile_(profile), store_(store) {
307 extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
308 registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
309 content::NotificationService::AllSources());
310 if (store_)
311 store_->RegisterKey(kContextMenusKey);
312 }
313
~MenuManager()314 MenuManager::~MenuManager() {
315 MenuItemMap::iterator i;
316 for (i = context_items_.begin(); i != context_items_.end(); ++i) {
317 STLDeleteElements(&(i->second));
318 }
319 }
320
321 // static
Get(Profile * profile)322 MenuManager* MenuManager::Get(Profile* profile) {
323 return MenuManagerFactory::GetForProfile(profile);
324 }
325
ExtensionIds()326 std::set<MenuItem::ExtensionKey> MenuManager::ExtensionIds() {
327 std::set<MenuItem::ExtensionKey> id_set;
328 for (MenuItemMap::const_iterator i = context_items_.begin();
329 i != context_items_.end(); ++i) {
330 id_set.insert(i->first);
331 }
332 return id_set;
333 }
334
MenuItems(const MenuItem::ExtensionKey & key)335 const MenuItem::List* MenuManager::MenuItems(
336 const MenuItem::ExtensionKey& key) {
337 MenuItemMap::iterator i = context_items_.find(key);
338 if (i != context_items_.end()) {
339 return &(i->second);
340 }
341 return NULL;
342 }
343
AddContextItem(const Extension * extension,MenuItem * item)344 bool MenuManager::AddContextItem(const Extension* extension, MenuItem* item) {
345 const MenuItem::ExtensionKey& key = item->id().extension_key;
346 // The item must have a non-empty extension id, and not have already been
347 // added.
348 if (key.empty() || ContainsKey(items_by_id_, item->id()))
349 return false;
350
351 DCHECK_EQ(extension->id(), key.extension_id);
352
353 bool first_item = !ContainsKey(context_items_, key);
354 context_items_[key].push_back(item);
355 items_by_id_[item->id()] = item;
356
357 if (item->type() == MenuItem::RADIO) {
358 if (item->checked())
359 RadioItemSelected(item);
360 else
361 SanitizeRadioList(context_items_[key]);
362 }
363
364 // If this is the first item for this extension, start loading its icon.
365 if (first_item)
366 icon_manager_.LoadIcon(profile_, extension);
367
368 return true;
369 }
370
AddChildItem(const MenuItem::Id & parent_id,MenuItem * child)371 bool MenuManager::AddChildItem(const MenuItem::Id& parent_id,
372 MenuItem* child) {
373 MenuItem* parent = GetItemById(parent_id);
374 if (!parent || parent->type() != MenuItem::NORMAL ||
375 parent->incognito() != child->incognito() ||
376 parent->extension_id() != child->extension_id() ||
377 ContainsKey(items_by_id_, child->id()))
378 return false;
379 parent->AddChild(child);
380 items_by_id_[child->id()] = child;
381
382 if (child->type() == MenuItem::RADIO)
383 SanitizeRadioList(parent->children());
384 return true;
385 }
386
DescendantOf(MenuItem * item,const MenuItem::Id & ancestor_id)387 bool MenuManager::DescendantOf(MenuItem* item,
388 const MenuItem::Id& ancestor_id) {
389 // Work our way up the tree until we find the ancestor or NULL.
390 MenuItem::Id* id = item->parent_id();
391 while (id != NULL) {
392 DCHECK(*id != item->id()); // Catch circular graphs.
393 if (*id == ancestor_id)
394 return true;
395 MenuItem* next = GetItemById(*id);
396 if (!next) {
397 NOTREACHED();
398 return false;
399 }
400 id = next->parent_id();
401 }
402 return false;
403 }
404
ChangeParent(const MenuItem::Id & child_id,const MenuItem::Id * parent_id)405 bool MenuManager::ChangeParent(const MenuItem::Id& child_id,
406 const MenuItem::Id* parent_id) {
407 MenuItem* child = GetItemById(child_id);
408 MenuItem* new_parent = parent_id ? GetItemById(*parent_id) : NULL;
409 if ((parent_id && (child_id == *parent_id)) || !child ||
410 (!new_parent && parent_id != NULL) ||
411 (new_parent && (DescendantOf(new_parent, child_id) ||
412 child->incognito() != new_parent->incognito() ||
413 child->extension_id() != new_parent->extension_id())))
414 return false;
415
416 MenuItem::Id* old_parent_id = child->parent_id();
417 if (old_parent_id != NULL) {
418 MenuItem* old_parent = GetItemById(*old_parent_id);
419 if (!old_parent) {
420 NOTREACHED();
421 return false;
422 }
423 MenuItem* taken =
424 old_parent->ReleaseChild(child_id, false /* non-recursive search*/);
425 DCHECK(taken == child);
426 SanitizeRadioList(old_parent->children());
427 } else {
428 // This is a top-level item, so we need to pull it out of our list of
429 // top-level items.
430 const MenuItem::ExtensionKey& child_key = child->id().extension_key;
431 MenuItemMap::iterator i = context_items_.find(child_key);
432 if (i == context_items_.end()) {
433 NOTREACHED();
434 return false;
435 }
436 MenuItem::List& list = i->second;
437 MenuItem::List::iterator j = std::find(list.begin(), list.end(), child);
438 if (j == list.end()) {
439 NOTREACHED();
440 return false;
441 }
442 list.erase(j);
443 SanitizeRadioList(list);
444 }
445
446 if (new_parent) {
447 new_parent->AddChild(child);
448 SanitizeRadioList(new_parent->children());
449 } else {
450 const MenuItem::ExtensionKey& child_key = child->id().extension_key;
451 context_items_[child_key].push_back(child);
452 child->parent_id_.reset(NULL);
453 SanitizeRadioList(context_items_[child_key]);
454 }
455 return true;
456 }
457
RemoveContextMenuItem(const MenuItem::Id & id)458 bool MenuManager::RemoveContextMenuItem(const MenuItem::Id& id) {
459 if (!ContainsKey(items_by_id_, id))
460 return false;
461
462 MenuItem* menu_item = GetItemById(id);
463 DCHECK(menu_item);
464 const MenuItem::ExtensionKey extension_key = id.extension_key;
465 MenuItemMap::iterator i = context_items_.find(extension_key);
466 if (i == context_items_.end()) {
467 NOTREACHED();
468 return false;
469 }
470
471 bool result = false;
472 std::set<MenuItem::Id> items_removed;
473 MenuItem::List& list = i->second;
474 MenuItem::List::iterator j;
475 for (j = list.begin(); j < list.end(); ++j) {
476 // See if the current top-level item is a match.
477 if ((*j)->id() == id) {
478 items_removed = (*j)->RemoveAllDescendants();
479 items_removed.insert(id);
480 delete *j;
481 list.erase(j);
482 result = true;
483 SanitizeRadioList(list);
484 break;
485 } else {
486 // See if the item to remove was found as a descendant of the current
487 // top-level item.
488 MenuItem* child = (*j)->ReleaseChild(id, true /* recursive */);
489 if (child) {
490 items_removed = child->RemoveAllDescendants();
491 items_removed.insert(id);
492 SanitizeRadioList(GetItemById(*child->parent_id())->children());
493 delete child;
494 result = true;
495 break;
496 }
497 }
498 }
499 DCHECK(result); // The check at the very top should have prevented this.
500
501 // Clear entries from the items_by_id_ map.
502 std::set<MenuItem::Id>::iterator removed_iter;
503 for (removed_iter = items_removed.begin();
504 removed_iter != items_removed.end();
505 ++removed_iter) {
506 items_by_id_.erase(*removed_iter);
507 }
508
509 if (list.empty()) {
510 context_items_.erase(extension_key);
511 icon_manager_.RemoveIcon(extension_key.extension_id);
512 }
513 return result;
514 }
515
RemoveAllContextItems(const MenuItem::ExtensionKey & extension_key)516 void MenuManager::RemoveAllContextItems(
517 const MenuItem::ExtensionKey& extension_key) {
518 MenuItem::List::iterator i;
519 for (i = context_items_[extension_key].begin();
520 i != context_items_[extension_key].end();
521 ++i) {
522 MenuItem* item = *i;
523 items_by_id_.erase(item->id());
524
525 // Remove descendants from this item and erase them from the lookup cache.
526 std::set<MenuItem::Id> removed_ids = item->RemoveAllDescendants();
527 std::set<MenuItem::Id>::const_iterator j;
528 for (j = removed_ids.begin(); j != removed_ids.end(); ++j) {
529 items_by_id_.erase(*j);
530 }
531 }
532 STLDeleteElements(&context_items_[extension_key]);
533 context_items_.erase(extension_key);
534 icon_manager_.RemoveIcon(extension_key.extension_id);
535 }
536
GetItemById(const MenuItem::Id & id) const537 MenuItem* MenuManager::GetItemById(const MenuItem::Id& id) const {
538 std::map<MenuItem::Id, MenuItem*>::const_iterator i =
539 items_by_id_.find(id);
540 if (i != items_by_id_.end())
541 return i->second;
542 else
543 return NULL;
544 }
545
RadioItemSelected(MenuItem * item)546 void MenuManager::RadioItemSelected(MenuItem* item) {
547 // If this is a child item, we need to get a handle to the list from its
548 // parent. Otherwise get a handle to the top-level list.
549 const MenuItem::List* list = NULL;
550 if (item->parent_id()) {
551 MenuItem* parent = GetItemById(*item->parent_id());
552 if (!parent) {
553 NOTREACHED();
554 return;
555 }
556 list = &(parent->children());
557 } else {
558 const MenuItem::ExtensionKey& key = item->id().extension_key;
559 if (context_items_.find(key) == context_items_.end()) {
560 NOTREACHED();
561 return;
562 }
563 list = &context_items_[key];
564 }
565
566 // Find where |item| is in the list.
567 MenuItem::List::const_iterator item_location;
568 for (item_location = list->begin(); item_location != list->end();
569 ++item_location) {
570 if (*item_location == item)
571 break;
572 }
573 if (item_location == list->end()) {
574 NOTREACHED(); // We should have found the item.
575 return;
576 }
577
578 // Iterate backwards from |item| and uncheck any adjacent radio items.
579 MenuItem::List::const_iterator i;
580 if (item_location != list->begin()) {
581 i = item_location;
582 do {
583 --i;
584 if ((*i)->type() != MenuItem::RADIO)
585 break;
586 (*i)->SetChecked(false);
587 } while (i != list->begin());
588 }
589
590 // Now iterate forwards from |item| and uncheck any adjacent radio items.
591 for (i = item_location + 1; i != list->end(); ++i) {
592 if ((*i)->type() != MenuItem::RADIO)
593 break;
594 (*i)->SetChecked(false);
595 }
596 }
597
AddURLProperty(base::DictionaryValue * dictionary,const std::string & key,const GURL & url)598 static void AddURLProperty(base::DictionaryValue* dictionary,
599 const std::string& key, const GURL& url) {
600 if (!url.is_empty())
601 dictionary->SetString(key, url.possibly_invalid_spec());
602 }
603
ExecuteCommand(Profile * profile,WebContents * web_contents,const content::ContextMenuParams & params,const MenuItem::Id & menu_item_id)604 void MenuManager::ExecuteCommand(Profile* profile,
605 WebContents* web_contents,
606 const content::ContextMenuParams& params,
607 const MenuItem::Id& menu_item_id) {
608 EventRouter* event_router = EventRouter::Get(profile);
609 if (!event_router)
610 return;
611
612 MenuItem* item = GetItemById(menu_item_id);
613 if (!item)
614 return;
615
616 // ExtensionService/Extension can be NULL in unit tests :(
617 ExtensionService* service =
618 ExtensionSystem::Get(profile_)->extension_service();
619 const Extension* extension =
620 service ? service->extensions()->GetByID(item->extension_id()) : NULL;
621
622 if (item->type() == MenuItem::RADIO)
623 RadioItemSelected(item);
624
625 scoped_ptr<base::ListValue> args(new base::ListValue());
626
627 base::DictionaryValue* properties = new base::DictionaryValue();
628 SetIdKeyValue(properties, "menuItemId", item->id());
629 if (item->parent_id())
630 SetIdKeyValue(properties, "parentMenuItemId", *item->parent_id());
631
632 switch (params.media_type) {
633 case blink::WebContextMenuData::MediaTypeImage:
634 properties->SetString("mediaType", "image");
635 break;
636 case blink::WebContextMenuData::MediaTypeVideo:
637 properties->SetString("mediaType", "video");
638 break;
639 case blink::WebContextMenuData::MediaTypeAudio:
640 properties->SetString("mediaType", "audio");
641 break;
642 default: {} // Do nothing.
643 }
644
645 AddURLProperty(properties, "linkUrl", params.unfiltered_link_url);
646 AddURLProperty(properties, "srcUrl", params.src_url);
647 AddURLProperty(properties, "pageUrl", params.page_url);
648 AddURLProperty(properties, "frameUrl", params.frame_url);
649
650 if (params.selection_text.length() > 0)
651 properties->SetString("selectionText", params.selection_text);
652
653 properties->SetBoolean("editable", params.is_editable);
654
655 WebViewGuest* webview_guest = WebViewGuest::FromWebContents(web_contents);
656 if (webview_guest) {
657 // This is used in webview_custom_bindings.js.
658 // The property is not exposed to developer API.
659 properties->SetInteger("webviewInstanceId",
660 webview_guest->view_instance_id());
661 }
662
663 args->Append(properties);
664
665 // Add the tab info to the argument list.
666 // No tab info in a platform app.
667 if (!extension || !extension->is_platform_app()) {
668 // Note: web_contents are NULL in unit tests :(
669 if (web_contents) {
670 args->Append(ExtensionTabUtil::CreateTabValue(web_contents));
671 } else {
672 args->Append(new base::DictionaryValue());
673 }
674 }
675
676 if (item->type() == MenuItem::CHECKBOX ||
677 item->type() == MenuItem::RADIO) {
678 bool was_checked = item->checked();
679 properties->SetBoolean("wasChecked", was_checked);
680
681 // RADIO items always get set to true when you click on them, but CHECKBOX
682 // items get their state toggled.
683 bool checked =
684 (item->type() == MenuItem::RADIO) ? true : !was_checked;
685
686 item->SetChecked(checked);
687 properties->SetBoolean("checked", item->checked());
688
689 if (extension)
690 WriteToStorage(extension, item->id().extension_key);
691 }
692
693 // Note: web_contents are NULL in unit tests :(
694 if (web_contents && extensions::TabHelper::FromWebContents(web_contents)) {
695 extensions::TabHelper::FromWebContents(web_contents)->
696 active_tab_permission_granter()->GrantIfRequested(extension);
697 }
698
699 {
700 // Dispatch to menu item's .onclick handler.
701 scoped_ptr<Event> event(
702 new Event(webview_guest ? kOnWebviewContextMenus
703 : kOnContextMenus,
704 scoped_ptr<base::ListValue>(args->DeepCopy())));
705 event->restrict_to_browser_context = profile;
706 event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
707 event_router->DispatchEventToExtension(item->extension_id(), event.Pass());
708 }
709 {
710 // Dispatch to .contextMenus.onClicked handler.
711 scoped_ptr<Event> event(
712 new Event(webview_guest ? webview::OnClicked::kEventName
713 : context_menus::OnClicked::kEventName,
714 args.Pass()));
715 event->restrict_to_browser_context = profile;
716 event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
717 if (webview_guest)
718 event->filter_info.SetInstanceID(webview_guest->view_instance_id());
719 event_router->DispatchEventToExtension(item->extension_id(), event.Pass());
720 }
721 }
722
SanitizeRadioList(const MenuItem::List & item_list)723 void MenuManager::SanitizeRadioList(const MenuItem::List& item_list) {
724 MenuItem::List::const_iterator i = item_list.begin();
725 while (i != item_list.end()) {
726 if ((*i)->type() != MenuItem::RADIO) {
727 ++i;
728 break;
729 }
730
731 // Uncheck any checked radio items in the run, and at the end reset
732 // the appropriate one to checked. If no check radio items were found,
733 // then check the first radio item in the run.
734 MenuItem::List::const_iterator last_checked = item_list.end();
735 MenuItem::List::const_iterator radio_run_iter;
736 for (radio_run_iter = i; radio_run_iter != item_list.end();
737 ++radio_run_iter) {
738 if ((*radio_run_iter)->type() != MenuItem::RADIO) {
739 break;
740 }
741
742 if ((*radio_run_iter)->checked()) {
743 last_checked = radio_run_iter;
744 (*radio_run_iter)->SetChecked(false);
745 }
746 }
747
748 if (last_checked != item_list.end())
749 (*last_checked)->SetChecked(true);
750 else
751 (*i)->SetChecked(true);
752
753 i = radio_run_iter;
754 }
755 }
756
ItemUpdated(const MenuItem::Id & id)757 bool MenuManager::ItemUpdated(const MenuItem::Id& id) {
758 if (!ContainsKey(items_by_id_, id))
759 return false;
760
761 MenuItem* menu_item = GetItemById(id);
762 DCHECK(menu_item);
763
764 if (menu_item->parent_id()) {
765 SanitizeRadioList(GetItemById(*menu_item->parent_id())->children());
766 } else {
767 MenuItemMap::iterator i =
768 context_items_.find(menu_item->id().extension_key);
769 if (i == context_items_.end()) {
770 NOTREACHED();
771 return false;
772 }
773 SanitizeRadioList(i->second);
774 }
775
776 return true;
777 }
778
WriteToStorage(const Extension * extension,const MenuItem::ExtensionKey & extension_key)779 void MenuManager::WriteToStorage(const Extension* extension,
780 const MenuItem::ExtensionKey& extension_key) {
781 if (!BackgroundInfo::HasLazyBackgroundPage(extension))
782 return;
783 // <webview> menu items are transient and not stored in storage.
784 if (extension_key.webview_instance_id)
785 return;
786 const MenuItem::List* top_items = MenuItems(extension_key);
787 MenuItem::List all_items;
788 if (top_items) {
789 for (MenuItem::List::const_iterator i = top_items->begin();
790 i != top_items->end(); ++i) {
791 DCHECK(!(*i)->id().extension_key.webview_instance_id);
792 (*i)->GetFlattenedSubtree(&all_items);
793 }
794 }
795
796 if (store_) {
797 store_->SetExtensionValue(extension->id(), kContextMenusKey,
798 MenuItemsToValue(all_items));
799 }
800 }
801
ReadFromStorage(const std::string & extension_id,scoped_ptr<base::Value> value)802 void MenuManager::ReadFromStorage(const std::string& extension_id,
803 scoped_ptr<base::Value> value) {
804 const Extension* extension =
805 ExtensionSystem::Get(profile_)->extension_service()->extensions()->
806 GetByID(extension_id);
807 if (!extension)
808 return;
809
810 MenuItem::List items = MenuItemsFromValue(extension_id, value.get());
811 for (size_t i = 0; i < items.size(); ++i) {
812 bool added = false;
813
814 if (items[i]->parent_id()) {
815 // Parent IDs are stored in the parent_id field for convenience, but
816 // they have not yet been validated. Separate them out here.
817 // Because of the order in which we store items in the prefs, parents will
818 // precede children, so we should already know about any parent items.
819 scoped_ptr<MenuItem::Id> parent_id;
820 parent_id.swap(items[i]->parent_id_);
821 added = AddChildItem(*parent_id, items[i]);
822 } else {
823 added = AddContextItem(extension, items[i]);
824 }
825
826 if (!added)
827 delete items[i];
828 }
829 }
830
OnExtensionLoaded(content::BrowserContext * browser_context,const Extension * extension)831 void MenuManager::OnExtensionLoaded(content::BrowserContext* browser_context,
832 const Extension* extension) {
833 if (store_ && BackgroundInfo::HasLazyBackgroundPage(extension)) {
834 store_->GetExtensionValue(
835 extension->id(),
836 kContextMenusKey,
837 base::Bind(
838 &MenuManager::ReadFromStorage, AsWeakPtr(), extension->id()));
839 }
840 }
841
OnExtensionUnloaded(content::BrowserContext * browser_context,const Extension * extension,UnloadedExtensionInfo::Reason reason)842 void MenuManager::OnExtensionUnloaded(content::BrowserContext* browser_context,
843 const Extension* extension,
844 UnloadedExtensionInfo::Reason reason) {
845 MenuItem::ExtensionKey extension_key(extension->id());
846 if (ContainsKey(context_items_, extension_key)) {
847 RemoveAllContextItems(extension_key);
848 }
849 }
850
Observe(int type,const content::NotificationSource & source,const content::NotificationDetails & details)851 void MenuManager::Observe(int type,
852 const content::NotificationSource& source,
853 const content::NotificationDetails& details) {
854 DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
855 Profile* profile = content::Source<Profile>(source).ptr();
856 // We cannot use profile_->HasOffTheRecordProfile as it may already be
857 // false at this point, if for example the incognito profile was destroyed
858 // using DestroyOffTheRecordProfile.
859 if (profile->GetOriginalProfile() == profile_ &&
860 profile->GetOriginalProfile() != profile) {
861 RemoveAllIncognitoContextItems();
862 }
863 }
864
GetIconForExtension(const std::string & extension_id)865 const SkBitmap& MenuManager::GetIconForExtension(
866 const std::string& extension_id) {
867 return icon_manager_.GetIcon(extension_id);
868 }
869
RemoveAllIncognitoContextItems()870 void MenuManager::RemoveAllIncognitoContextItems() {
871 // Get all context menu items with "incognito" set to "split".
872 std::set<MenuItem::Id> items_to_remove;
873 std::map<MenuItem::Id, MenuItem*>::const_iterator iter;
874 for (iter = items_by_id_.begin();
875 iter != items_by_id_.end();
876 ++iter) {
877 if (iter->first.incognito)
878 items_to_remove.insert(iter->first);
879 }
880
881 std::set<MenuItem::Id>::iterator remove_iter;
882 for (remove_iter = items_to_remove.begin();
883 remove_iter != items_to_remove.end();
884 ++remove_iter)
885 RemoveContextMenuItem(*remove_iter);
886 }
887
ExtensionKey()888 MenuItem::ExtensionKey::ExtensionKey() : webview_instance_id(0) {}
889
ExtensionKey(const std::string & extension_id,int webview_instance_id)890 MenuItem::ExtensionKey::ExtensionKey(const std::string& extension_id,
891 int webview_instance_id)
892 : extension_id(extension_id), webview_instance_id(webview_instance_id) {}
893
ExtensionKey(const std::string & extension_id)894 MenuItem::ExtensionKey::ExtensionKey(const std::string& extension_id)
895 : extension_id(extension_id), webview_instance_id(0) {}
896
operator ==(const ExtensionKey & other) const897 bool MenuItem::ExtensionKey::operator==(const ExtensionKey& other) const {
898 return extension_id == other.extension_id &&
899 webview_instance_id == other.webview_instance_id;
900 }
901
operator <(const ExtensionKey & other) const902 bool MenuItem::ExtensionKey::operator<(const ExtensionKey& other) const {
903 if (extension_id != other.extension_id)
904 return extension_id < other.extension_id;
905
906 return webview_instance_id < other.webview_instance_id;
907 }
908
operator !=(const ExtensionKey & other) const909 bool MenuItem::ExtensionKey::operator!=(const ExtensionKey& other) const {
910 return !(*this == other);
911 }
912
empty() const913 bool MenuItem::ExtensionKey::empty() const {
914 return extension_id.empty() && !webview_instance_id;
915 }
916
Id()917 MenuItem::Id::Id() : incognito(false), uid(0) {}
918
Id(bool incognito,const MenuItem::ExtensionKey & extension_key)919 MenuItem::Id::Id(bool incognito, const MenuItem::ExtensionKey& extension_key)
920 : incognito(incognito), extension_key(extension_key), uid(0) {}
921
~Id()922 MenuItem::Id::~Id() {
923 }
924
operator ==(const Id & other) const925 bool MenuItem::Id::operator==(const Id& other) const {
926 return (incognito == other.incognito &&
927 extension_key == other.extension_key && uid == other.uid &&
928 string_uid == other.string_uid);
929 }
930
operator !=(const Id & other) const931 bool MenuItem::Id::operator!=(const Id& other) const {
932 return !(*this == other);
933 }
934
operator <(const Id & other) const935 bool MenuItem::Id::operator<(const Id& other) const {
936 if (incognito < other.incognito)
937 return true;
938 if (incognito == other.incognito) {
939 if (extension_key < other.extension_key)
940 return true;
941 if (extension_key == other.extension_key) {
942 if (uid < other.uid)
943 return true;
944 if (uid == other.uid)
945 return string_uid < other.string_uid;
946 }
947 }
948 return false;
949 }
950
951 } // namespace extensions
952