Contributed by Eriq Augustine <eriq.augustine@gmail.com>

chrome/browser/extensions/extension_menu_manager.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 "chrome/browser/extensions/extension_menu_manager.h"
 
 #include <algorithm>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 121 matching lines @@
   // added.
   if (extension_id.empty() || ContainsKey(items_by_id_, item->id()))
     return false;
 
   DCHECK_EQ(extension->id(), extension_id);
 
   bool first_item = !ContainsKey(context_items_, extension_id);
   context_items_[extension_id].push_back(item);
   items_by_id_[item->id()] = item;
 
-  if (item->type() == ExtensionMenuItem::RADIO && item->checked())
-    RadioItemSelected(item);
+  if (item->type() == ExtensionMenuItem::RADIO) {
+    if (item->checked())
+      RadioItemSelected(item);
+    else
+      SanitizeRadioList(context_items_[extension_id]);
+  }
 
   // If this is the first item for this extension, start loading its icon.
   if (first_item)
     icon_manager_.LoadIcon(extension);
 
   return true;
 }
 
 bool ExtensionMenuManager::AddChildItem(const ExtensionMenuItem::Id& parent_id,
                                         ExtensionMenuItem* child) {
   ExtensionMenuItem* parent = GetItemById(parent_id);
   if (!parent || parent->type() != ExtensionMenuItem::NORMAL ||
       parent->extension_id() != child->extension_id() ||
       ContainsKey(items_by_id_, child->id()))
     return false;
   parent->AddChild(child);
   items_by_id_[child->id()] = child;
+
+  if (child->type() == ExtensionMenuItem::RADIO)
+    SanitizeRadioList(parent->children());
+
   return true;
 }
 
 bool ExtensionMenuManager::DescendantOf(
     ExtensionMenuItem* item,
     const ExtensionMenuItem::Id& ancestor_id) {
   // Work our way up the tree until we find the ancestor or NULL.
   ExtensionMenuItem::Id* id = item->parent_id();
   while (id != NULL) {
     DCHECK(*id != item->id());  // Catch circular graphs.
@@ skipping 23 matching lines @@
   ExtensionMenuItem::Id* old_parent_id = child->parent_id();
   if (old_parent_id != NULL) {
     ExtensionMenuItem* old_parent = GetItemById(*old_parent_id);
     if (!old_parent) {
       NOTREACHED();
       return false;
     }
     ExtensionMenuItem* taken =
       old_parent->ReleaseChild(child_id, false /* non-recursive search*/);
     DCHECK(taken == child);
+    SanitizeRadioList(old_parent->children());
   } else {
     // This is a top-level item, so we need to pull it out of our list of
     // top-level items.
     MenuItemMap::iterator i = context_items_.find(child->extension_id());
     if (i == context_items_.end()) {
       NOTREACHED();
       return false;
     }
     ExtensionMenuItem::List& list = i->second;
     ExtensionMenuItem::List::iterator j = std::find(list.begin(), list.end(),
                                                     child);
     if (j == list.end()) {
       NOTREACHED();
       return false;
     }
     list.erase(j);
+    SanitizeRadioList(list);
   }
 
   if (new_parent) {
     new_parent->AddChild(child);
+    SanitizeRadioList(new_parent->children());
   } else {
     context_items_[child->extension_id()].push_back(child);
     child->parent_id_.reset(NULL);
+    SanitizeRadioList(context_items_[child->extension_id()]);
   }
   return true;
 }
 
 bool ExtensionMenuManager::RemoveContextMenuItem(
     const ExtensionMenuItem::Id& id) {
   if (!ContainsKey(items_by_id_, id))
     return false;
 
   ExtensionMenuItem* menu_item = GetItemById(id);
@@ skipping 10 matching lines @@
   ExtensionMenuItem::List& list = i->second;
   ExtensionMenuItem::List::iterator j;
   for (j = list.begin(); j < list.end(); ++j) {
     // See if the current top-level item is a match.
     if ((*j)->id() == id) {
       items_removed = (*j)->RemoveAllDescendants();
       items_removed.insert(id);
       delete *j;
       list.erase(j);
       result = true;
+      SanitizeRadioList(list);
       break;
     } else {
       // See if the item to remove was found as a descendant of the current
       // top-level item.
       ExtensionMenuItem* child = (*j)->ReleaseChild(id, true /* recursive */);
       if (child) {
         items_removed = child->RemoveAllDescendants();
         items_removed.insert(id);
+        SanitizeRadioList(GetItemById(*child->parent_id())->children());
         delete child;
         result = true;
         break;
       }
     }
   }
   DCHECK(result);  // The check at the very top should have prevented this.
 
   // Clear entries from the items_by_id_ map.
   std::set<ExtensionMenuItem::Id>::iterator removed_iter;
@@ skipping 167 matching lines @@
     properties->SetBoolean("checked", item->checked());
   }
 
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
   std::string event_name = "contextMenus";
   event_router->DispatchEventToExtension(
       item->extension_id(), event_name, json_args, profile, GURL());
 }
 
+void ExtensionMenuManager::SanitizeRadioList(
+    const ExtensionMenuItem::List& item_list) {
+  ExtensionMenuItem::List::const_iterator i = item_list.begin();
+  while (i != item_list.end()) {
+    if ((*i)->type() != ExtensionMenuItem::RADIO) {
+      ++i;
+      break;
+    }
+
+    // Uncheck any checked radio items in the run, and at the end reset
+    // the appropriate one to checked. If no check radio items were found,
+    // then check the first radio item in the run.
+    ExtensionMenuItem::List::const_iterator last_checked = item_list.end();
+    ExtensionMenuItem::List::const_iterator radio_run_iter;
+    for (radio_run_iter = i; radio_run_iter != item_list.end();
+        ++radio_run_iter) {
+      if ((*radio_run_iter)->type() != ExtensionMenuItem::RADIO) {
+        break;
+      }
+
+      if ((*radio_run_iter)->checked()) {
+        last_checked = radio_run_iter;
+        (*radio_run_iter)->SetChecked(false);
+      }
+    }
+
+    if (last_checked != item_list.end())
+      (*last_checked)->SetChecked(true);
+    else
+      (*i)->SetChecked(true);
+
+    i = radio_run_iter;
+  }
+}
+
+bool ExtensionMenuManager::ItemUpdated(const ExtensionMenuItem::Id& id) {
+  if (!ContainsKey(items_by_id_, id))
+    return false;
+
+  ExtensionMenuItem* menu_item = GetItemById(id);
+  DCHECK(menu_item);
+
+  if (menu_item->parent_id()) {
+    SanitizeRadioList(GetItemById(*menu_item->parent_id())->children());
+  } else {
+    std::string extension_id = menu_item->extension_id();
+    MenuItemMap::iterator i = context_items_.find(extension_id);
+    if (i == context_items_.end()) {
+      NOTREACHED();
+      return false;
+    }
+    SanitizeRadioList(i->second);
+  }
+
+  return true;
+}
+
 void ExtensionMenuManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED);
 
   // Remove menu items for disabled/uninstalled extensions.
   const Extension* extension =
       content::Details<UnloadedExtensionInfo>(details)->extension;
   if (ContainsKey(context_items_, extension->id())) {
@@ skipping 33 matching lines @@
   if (profile < other.profile)
     return true;
   if (profile == other.profile) {
     if (extension_id < other.extension_id)
       return true;
     if (extension_id == other.extension_id)
       return uid < other.uid;
   }
   return false;
 }