Try run for https://codereview.chromium.org/426593007.

extensions/browser/process_map.h

 // Copyright 2013 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 EXTENSIONS_BROWSER_PROCESS_MAP_H_
 #define EXTENSIONS_BROWSER_PROCESS_MAP_H_
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "components/keyed_service/core/keyed_service.h"
+#include "extensions/common/features/feature.h"
 
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
+class Extension;
 
 // Contains information about which extensions are assigned to which processes.
 //
 // The relationship between extensions and processes is complex:
 //
 // - Extensions can be either "split" mode or "spanning" mode.
 // - In spanning mode, extensions share a single process between all incognito
 //   and normal windows. This was the original mode for extensions.
 // - In split mode, extensions have separate processes in incognito windows.
 // - There are also hosted apps, which are a kind of extensions, and those
@@ skipping 30 matching lines @@
 //    care about incognito version of this extension (or vice versa if you're in
 //    an incognito profile) then use
 //    extensions::ProcessManager::GetSiteInstanceForURL()->[Has|Get]Process().
 //
 // 3. The process ids contained in this class are *not limited* to the Profile
 //    you got this map from. They can also be associated with that profile's
 //    incognito/normal twin. If you care about this, use
 //    RenderProcessHost::FromID() and check the profile of the resulting object.
 //
 // TODO(aa): The above warnings suggest this class could use improvement :).
+//
+// TODO(kalman): This class is not threadsafe, but is used on both the UI and
+//               IO threads. Somebody should fix that, either make it
+//               threadsafe or enforce single thread. Investigation required.
 class ProcessMap : public KeyedService {
  public:
   ProcessMap();
   virtual ~ProcessMap();
 
   // Returns the instance for |browser_context|. An instance is shared between
   // an incognito and a regular context.
   static ProcessMap* Get(content::BrowserContext* browser_context);
 
   size_t size() const { return items_.size(); }
 
   bool Insert(const std::string& extension_id, int process_id,
               int site_instance_id);
 
   bool Remove(const std::string& extension_id, int process_id,
               int site_instance_id);
   int RemoveAllFromProcess(int process_id);
 
   bool Contains(const std::string& extension_id, int process_id) const;
   bool Contains(int process_id) const;
 
   std::set<std::string> GetExtensionsInProcess(int process_id) const;
 
+  // Guesses the most permissive context type for the process with ID
+  // |process_id|. Context types are renderer (JavaScript) concepts but the
+  // browser can do a decent job in guessing what the process hosts.
+  //
+  //   - For hosted app processes, this will be blessed_web_page.
+  //   - For other extension processes, this will be blessed_extension.
+  //   - For WebUI processes, this will be a webui.
+  //   - For anything else we have the choice of unblessed_extension or
+  //     content_script. Since content scripts are more common, guess that.
+  //     We *could* in theory track which web processes have extension frames
+  //     in them, and those would be unblessed_extension, but we don't at the
+  //     moment, and once OOP iframes exist then there won't even be such a
+  //     thing as an unblessed_extension context.
+  //
+  // |extension| isn't used to upgrade the process trust level, but rather used
+  // as a tiebreaker if a process is found to contain multiple extensions.
+  Feature::Context GuessContextType(const Extension* extension,
+                                    int process_id) const;
+
  private:
   struct Item;
 
   typedef std::set<Item> ItemSet;
   ItemSet items_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessMap);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_PROCESS_MAP_H_