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]);
+    }
+  }

[asargent_no_longer_on_chrome, 2012/01/06 21:17:42]

nit: other code uses the optional style practice of omitting braces for
single-line bodies of if statements, so yours should follow that too (here and
in your other edits in the file). E.g.

if (condition)
  foo();
else
  bar();

instead of:

if (condition) {
  foo();
} else {
  bar();
}

 
   // 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) {

[asargent_no_longer_on_chrome, 2012/01/06 21:17:42]

nit: you could improve readability slightly by making an early out for the
non-radio case. E.g.

while (i != item_list.end()) {
  if ((*i)->type() != ExtensionMenuItem::RADIO) {
    ++i;
    break;
  }
  ... rest of code, now indented one level less ...
}

+      // If there are multiple items selected, the last one will override the
+      // others.
+      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 radio items were found in this run,
+      // check the first radio item in the list (i).

[asargent_no_longer_on_chrome, 2012/01/06 21:17:42]

nit: this comment isn't quite right. It could be something like: "Reset the last
checked item we found to checked. If we didn't find any checked items, set the
first one to checked."

Alternatively, you could just modify the comment several lines above to be
something like "Uncheck any checked radio items in the run, and at the end reset
the appropriate one to checked."

+      if (last_checked != item_list.end()) {
+        (*last_checked)->SetChecked(true);
+      } else {
+        (*i)->SetChecked(true);
+      }
+
+      i = radio_run_iter;
+    } else {
+      ++i;
+    }
+  }
+}
+
+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;
 }