Add an "affinity" option to webPreferences

atom/browser/atom_browser_client.cc

@@ -218,21 +218,61 @@ void AtomBrowserClient::OverrideSiteInstanceForNavigation(
                                    current_instance, url))
     return;
 
-  scoped_refptr<content::SiteInstance> site_instance =
-      content::SiteInstance::CreateForURL(browser_context, url);
+  bool is_new_instance = true;
+  scoped_refptr<content::SiteInstance> site_instance;
+
+  // Do we have an affinity site to manage ?
+  std::string affinity;
+  auto web_contents =
+      content::WebContents::FromRenderFrameHost(render_frame_host);
+  if (WebContentsPreferences::GetAffinity(web_contents, &affinity)
+      && !affinity.empty()) {
+    affinity = base::ToLowerASCII(affinity);
+    auto iter = site_per_affinities.find(affinity);
+    if (iter != site_per_affinities.end()) {
+      site_instance = iter->second;
+      is_new_instance = false;
+    } else {
+      // We must not provide the url.
+      // This site is "isolated" and must not be taken into account
+      // when Chromium looking at a candidate for an url.
+      site_instance = content::SiteInstance::Create(
+          browser_context);
+      site_per_affinities[affinity] = site_instance.get();
+    }
+  } else {
+    site_instance = content::SiteInstance::CreateForURL(
+        browser_context,
+        url);
+  }
   *new_instance = site_instance.get();
 
-  // Make sure the |site_instance| is not freed when this function returns.
-  // FIXME(zcbenz): We should adjust OverrideSiteInstanceForNavigation's
-  // interface to solve this.
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&Noop, base::RetainedRef(site_instance)));
+  if (is_new_instance) {
+    // Make sure the |site_instance| is not freed
+    // when this function returns.
+    // FIXME(zcbenz): We should adjust
+    // OverrideSiteInstanceForNavigation's interface to solve this.
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&Noop, base::RetainedRef(site_instance)));
 
-  // Remember the original web contents for the pending renderer process.
-  auto pending_process = (*new_instance)->GetProcess();
-  pending_processes_[pending_process->GetID()] =
-      content::WebContents::FromRenderFrameHost(render_frame_host);
+    // Remember the original web contents for the pending renderer process.
+    auto pending_process = site_instance->GetProcess();
+    pending_processes_[pending_process->GetID()] = web_contents;
+  }
+}
+
+// We are storing weak_ptr, is it fundamental to maintain the map up-to-date
+// when an instance is destroyed.
+void AtomBrowserClient::SiteInstanceDeleting(
+    content::SiteInstance* site_instance) {
+  for (auto iter = site_per_affinities.begin();
+      iter != site_per_affinities.end(); ++iter) {
+    if (iter->second == site_instance) {
+      site_per_affinities.erase(iter);
+      break;
+    }
+  }
 }
 
 void AtomBrowserClient::AppendExtraCommandLineSwitches(

atom/browser/atom_browser_client.h

@@ -113,6 +113,8 @@ class AtomBrowserClient : public brightray::BrowserClient,
                            base::TerminationStatus status,
                            int exit_code) override;
 
+  void SiteInstanceDeleting(content::SiteInstance* site_instance) override;
+
  private:
   bool ShouldCreateNewSiteInstance(content::RenderFrameHost* render_frame_host,
                                    content::BrowserContext* browser_context,
@@ -134,6 +136,10 @@ class AtomBrowserClient : public brightray::BrowserClient,
 
   std::map<int, ProcessPreferences> process_preferences_;
   std::map<int, base::ProcessId> render_process_host_pids_;
+
+  // list of site per affinity. weak_ptr to prevent instance locking
+  std::map<std::string, content::SiteInstance*> site_per_affinities;
+
   base::Lock process_preferences_lock_;
 
   std::unique_ptr<AtomResourceDispatcherHostDelegate>

atom/browser/web_contents_preferences.cc

@@ -237,6 +237,22 @@ bool WebContentsPreferences::IsPreferenceEnabled(
   return bool_value;
 }
 
+bool WebContentsPreferences::GetPreferenceString(
+    const std::string& attribute_name,
+    content::WebContents* web_contents,
+    std::string* strValue) {
+    WebContentsPreferences* self;
+    if (!web_contents)
+        return false;
+
+    self = FromWebContents(web_contents);
+    if (!self)
+        return false;
+
+    base::DictionaryValue& web_preferences = self->web_preferences_;
+    return web_preferences.GetString(attribute_name, strValue);
+}
+
 bool WebContentsPreferences::IsSandboxed(content::WebContents* web_contents) {
   return IsPreferenceEnabled("sandbox", web_contents);
 }
@@ -256,6 +272,12 @@ bool WebContentsPreferences::DisablePopups(
   return IsPreferenceEnabled("disablePopups", web_contents);
 }
 
+bool WebContentsPreferences::GetAffinity(
+    content::WebContents* web_contents,
+    std::string* string_value) {
+    return GetPreferenceString("affinity", web_contents, string_value);
+}
+
 // static
 void WebContentsPreferences::OverrideWebkitPrefs(
     content::WebContents* web_contents, content::WebPreferences* prefs) {

atom/browser/web_contents_preferences.h

@@ -39,10 +39,15 @@ class WebContentsPreferences
 
   static bool IsPreferenceEnabled(const std::string& attribute_name,
                                   content::WebContents* web_contents);
+  static bool GetPreferenceString(const std::string& attribute_name,
+                                  content::WebContents* web_contents,
+                                  std::string* strValue);
   static bool IsSandboxed(content::WebContents* web_contents);
   static bool UsesNativeWindowOpen(content::WebContents* web_contents);
   static bool DisablePopups(content::WebContents* web_contents);
   static bool IsPluginsEnabled(content::WebContents* web_contents);
+  static bool GetAffinity(content::WebContents* web_contents,
+                          std::string* string_value);
 
   // Modify the WebPreferences according to |web_contents|'s preferences.
   static void OverrideWebkitPrefs(