Convert extensions::ProcessMap to BrowserContextKeyedService

chrome/browser/extensions/extension_service.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_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 12 matching lines @@
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_sync_service.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pending_extension_manager.h"
 #include "extensions/browser/process_manager.h"
-#include "extensions/browser/process_map.h"
 #include "extensions/browser/quota_service.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "extensions/common/one_shot_event.h"
 
 class CommandLine;
 class ExtensionErrorUI;
 class ExtensionToolbarModel;
@@ skipping 74 matching lines @@
       const std::string& extension_id,
       extensions::UnloadedExtensionInfo::Reason reason) = 0;
   virtual void RemoveComponentExtension(const std::string& extension_id) = 0;
 
   virtual bool is_ready() = 0;
 
   // Returns task runner for crx installation file I/O operations.
   virtual base::SequencedTaskRunner* GetFileTaskRunner() = 0;
 };
 
-// Manages installed and running Chromium extensions.
+// Manages installed and running Chromium extensions. An instance is shared
+// between normal and incognito profiles.
 class ExtensionService
     : public ExtensionServiceInterface,
       public extensions::ExternalProviderInterface::VisitorInterface,
       public content::NotificationObserver,
       public extensions::Blacklist::Observer {
  public:
   // Returns the Extension for a given url or NULL if the url doesn't belong to
   // an installed extension. This may be a hosted app extent or a
   // chrome-extension:// url.
   const extensions::Extension* GetInstalledExtensionByUrl(
@@ skipping 33 matching lines @@
   // Returns a set of all installed, disabled, blacklisted, and terminated
   // extensions.
   scoped_ptr<extensions::ExtensionSet> GenerateInstalledExtensionsSet() const;
 
   // Gets the object managing the set of pending extensions.
   virtual extensions::PendingExtensionManager*
       pending_extension_manager() OVERRIDE;
 
   const base::FilePath& install_directory() const { return install_directory_; }
 
-  extensions::ProcessMap* process_map() { return &process_map_; }
-
   // Updates the app launcher value for the moved extension so that it is now
   // located after the given predecessor and before the successor. This will
   // trigger a sync if needed. Empty strings are used to indicate no successor
   // or predecessor.
   void OnExtensionMoved(const std::string& moved_extension_id,
                         const std::string& predecessor_extension_id,
                         const std::string& successor_extension_id);
 
   // Whether the persistent background page, if any, is ready. We don't load
   // other components until then. If there is no background page, or if it is
@@ skipping 621 matching lines @@
   // allow background processing of garbage collection of on-disk state without
   // needing to worry about race conditions caused by extension installation and
   // reinstallation.
   bool installs_delayed_for_gc_;
 
   // Set to true if this is the first time this ExtensionService has run.
   // Used for specially handling external extensions that are installed the
   // first time.
   bool is_first_run_;
 
-  extensions::ProcessMap process_map_;
-
   // A set of the extension ids currently being reloaded.  We use this to
   // avoid showing a "new install" notice for an extension reinstall.
   std::set<std::string> extensions_being_reloaded_;
 
   scoped_ptr<ExtensionErrorUI> extension_error_ui_;
   // Sequenced task runner for extension related file operations.
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
 #if defined(ENABLE_EXTENSIONS)
   scoped_ptr<extensions::ExtensionActionStorageManager>
@@ skipping 22 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            UnloadBlacklistedExtensionPolicy);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            WillNotLoadBlacklistedExtensionsFromDirectory);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlacklistedInPrefsFromStartup);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_