Split extensions::MenuManager instance out from ExtensionService.

chrome/browser/extensions/menu_manager.cc

 // 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.
 
 #include "chrome/browser/extensions/menu_manager.h"
 
 #include <algorithm>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/menu_manager_factory.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/context_menus.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/context_menu_params.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/text_elider.h"
 
 using content::WebContents;
 using extensions::ExtensionSystem;
 
@@ skipping 248 matching lines @@
   }
   if (target_url_patterns) {
     if (!target_url_patterns_.Populate(
             *target_url_patterns, URLPattern::SCHEME_ALL, true, error)) {
       return false;
     }
   }
   return true;
 }
 
-MenuManager::MenuManager(Profile* profile)
-    : profile_(profile) {
+MenuManager::MenuManager(Profile* profile, StateStore* store)
+    : profile_(profile), store_(store) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile));
-
-  StateStore* store = ExtensionSystem::Get(profile_)->state_store();
-  if (store)
-    store->RegisterKey(kContextMenusKey);
+  registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
+                 content::NotificationService::AllSources());
+  if (store_)
+    store_->RegisterKey(kContextMenusKey);
 }
 
 MenuManager::~MenuManager() {
   MenuItemMap::iterator i;
   for (i = context_items_.begin(); i != context_items_.end(); ++i) {
     STLDeleteElements(&(i->second));
   }
 }
 
+// static
+MenuManager* MenuManager::Get(Profile* profile) {
+  return MenuManagerFactory::GetForProfile(profile);
+}
+
 std::set<std::string> MenuManager::ExtensionIds() {
   std::set<std::string> id_set;
   for (MenuItemMap::const_iterator i = context_items_.begin();
        i != context_items_.end(); ++i) {
     id_set.insert(i->first);
   }
   return id_set;
 }
 
 const MenuItem::List* MenuManager::MenuItems(
@@ skipping 429 matching lines @@
     return;
   const MenuItem::List* top_items = MenuItems(extension->id());
   MenuItem::List all_items;
   if (top_items) {
     for (MenuItem::List::const_iterator i = top_items->begin();
          i != top_items->end(); ++i) {
       (*i)->GetFlattenedSubtree(&all_items);
     }
   }
 
-  StateStore* store = ExtensionSystem::Get(profile_)->state_store();
-  if (store)
-    store->SetExtensionValue(extension->id(), kContextMenusKey,
-                             MenuItemsToValue(all_items));
+  if (store_)
+    store_->SetExtensionValue(extension->id(), kContextMenusKey,
+                              MenuItemsToValue(all_items));
 }
 
 void MenuManager::ReadFromStorage(const std::string& extension_id,
                                   scoped_ptr<base::Value> value) {
   const Extension* extension =
       ExtensionSystem::Get(profile_)->extension_service()->extensions()->
           GetByID(extension_id);
   if (!extension)
     return;
 
   MenuItem::List items = MenuItemsFromValue(extension_id, value.get());
   for (size_t i = 0; i < items.size(); ++i) {
     if (items[i]->parent_id()) {
       // Parent IDs are stored in the parent_id field for convenience, but
       // they have not yet been validated. Separate them out here.
       // Because of the order in which we store items in the prefs, parents will
       // precede children, so we should already know about any parent items.
       scoped_ptr<MenuItem::Id> parent_id;
       parent_id.swap(items[i]->parent_id_);
       AddChildItem(*parent_id, items[i]);
     } else {
       AddContextItem(extension, items[i]);
     }
   }
 }
 
 void MenuManager::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
-  if (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())) {
-      RemoveAllContextItems(extension->id());
+  switch (type) {
+    case 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())) {
+        RemoveAllContextItems(extension->id());
+      }
+      break;
     }
-  } else if (type == chrome::NOTIFICATION_EXTENSION_LOADED) {
-    const Extension* extension =
-        content::Details<const Extension>(details).ptr();
-    StateStore* store = ExtensionSystem::Get(profile_)->state_store();
-    if (store && BackgroundInfo::HasLazyBackgroundPage(extension)) {
-      store->GetExtensionValue(extension->id(), kContextMenusKey,
-          base::Bind(&MenuManager::ReadFromStorage,
-                     AsWeakPtr(), extension->id()));
+    case chrome::NOTIFICATION_EXTENSION_LOADED: {
+      const Extension* extension =
+          content::Details<const Extension>(details).ptr();
+      if (store_ && BackgroundInfo::HasLazyBackgroundPage(extension)) {
+        store_->GetExtensionValue(extension->id(), kContextMenusKey,
+            base::Bind(&MenuManager::ReadFromStorage,
+                       AsWeakPtr(), extension->id()));
+      }
+      break;
     }
+    case chrome::NOTIFICATION_PROFILE_DESTROYED: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      // We cannot use profile_->HasOffTheRecordProfile as it may already be
+      // false at this point, if for example the incognito profile was destroyed
+      // using DestroyOffTheRecordProfile.
+      if (profile->GetOriginalProfile() == profile_ &&
+          profile->GetOriginalProfile() != profile) {
+        RemoveAllIncognitoContextItems();
+      }
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
   }
 }
 
 const SkBitmap& MenuManager::GetIconForExtension(
     const std::string& extension_id) {
   return icon_manager_.GetIcon(extension_id);
 }
 
 void MenuManager::RemoveAllIncognitoContextItems() {
   // Get all context menu items with "incognito" set to "split".
@@ skipping 42 matching lines @@
       if (uid < other.uid)
         return true;
       if (uid == other.uid)
         return string_uid < other.string_uid;
     }
   }
   return false;
 }
 
 }  // namespace extensions