Remove NOTIFICATION_EXTENSION_LOADED_DEPRECATED from MenuManager.

chrome/browser/extensions/menu_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_MENU_MANAGER_H_
 #define CHROME_BROWSER_EXTENSIONS_MENU_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_icon_manager.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/url_pattern_set.h"
 
-
 class Profile;
 class SkBitmap;
 
 namespace content {
 class WebContents;
 struct ContextMenuParams;
 }
 
 namespace extensions {
 class Extension;
+class ExtensionRegistry;
 class StateStore;
 
 // Represents a menu item added by an extension.
 class MenuItem {
  public:
   // A list of MenuItems.
   typedef std::vector<MenuItem*> List;
 
   // Key used to identify which extension a menu item belongs to.
   // A menu item can also belong to a <webview> inside an extension,
@@ skipping 213 matching lines @@
 
   // Any children this item may have.
   List children_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuItem);
 };
 
 // This class keeps track of menu items added by extensions.
 class MenuManager : public content::NotificationObserver,
                     public base::SupportsWeakPtr<MenuManager>,
-                    public KeyedService {
+                    public KeyedService,
+                    public ExtensionRegistryObserver {
  public:
   static const char kOnContextMenus[];
   static const char kOnWebviewContextMenus[];
 
   MenuManager(Profile* profile, StateStore* store_);
   virtual ~MenuManager();
 
   // Convenience function to get the MenuManager for a Profile.
   static MenuManager* Get(Profile* profile);
 
@@ skipping 46 matching lines @@
   void ExecuteCommand(Profile* profile,
                       content::WebContents* web_contents,
                       const content::ContextMenuParams& params,
                       const MenuItem::Id& menu_item_id);
 
   // This returns a bitmap of width/height kFaviconSize, loaded either from an
   // entry specified in the extension's 'icon' section of the manifest, or a
   // default extension icon.
   const SkBitmap& GetIconForExtension(const std::string& extension_id);
 
-  // Implements the content::NotificationObserver interface.
+  // content::NotificationObserver implementation.
   virtual void Observe(int type, const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // ExtensionRegistryObserver implementation.
+  virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
+                                 const Extension* extension) OVERRIDE;
+  virtual void OnExtensionUnloaded(
+      content::BrowserContext* browser_context,
+      const Extension* extension,
+      UnloadedExtensionInfo::Reason reason) OVERRIDE;
+
   // Stores the menu items for the extension in the state storage.
   void WriteToStorage(const Extension* extension,
                       const MenuItem::ExtensionKey& extension_key);
 
   // Reads menu items for the extension from the state storage. Any invalid
   // items are ignored.
   void ReadFromStorage(const std::string& extension_id,
                        scoped_ptr<base::Value> value);
 
   // Removes all "incognito" "split" mode context items.
@@ skipping 20 matching lines @@
   typedef std::map<MenuItem::ExtensionKey, MenuItem::List> MenuItemMap;
   MenuItemMap context_items_;
 
   // This lets us make lookup by id fast. It maps id to MenuItem* for
   // all items the menu manager knows about, including all children of top-level
   // items.
   std::map<MenuItem::Id, MenuItem*> items_by_id_;
 
   content::NotificationRegistrar registrar_;
 
+  // Listen to extension load, unloaded notifications.
+  ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
+      extension_registry_observer_;
+
   ExtensionIconManager icon_manager_;
 
   Profile* profile_;
 
   // Owned by ExtensionSystem.
   StateStore* store_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuManager);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_MENU_MANAGER_H_