Disarm LockToOrigin for extensions under --isolate-extensions.

chrome/browser/extensions/process_manager_browsertest.cc

 // 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.
 
 #include "extensions/browser/process_manager.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/extensions/browser_action_test_util.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/common/value_builder.h"
 #include "extensions/test/background_page_watcher.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
 namespace extensions {
 
@@ skipping 486 matching lines @@
   EXPECT_EQ(baseline_keepalive + 1, pm->GetLazyKeepaliveCount(extension.get()));
   pm->OnNetworkRequestDone(frame_host, 1);
   EXPECT_EQ(baseline_keepalive, pm->GetLazyKeepaliveCount(extension.get()));
 
   // Simulate only a request completion for this ID and ensure it doesn't result
   // in keepalive decrement.
   pm->OnNetworkRequestDone(frame_host, 2);
   EXPECT_EQ(baseline_keepalive, pm->GetLazyKeepaliveCount(extension.get()));
 }
 
+IN_PROC_BROWSER_TEST_F(ProcessManagerBrowserTest, ExtensionProcessReuse) {
+  const size_t kNumExtensions = 3;
+  content::RenderProcessHost::SetMaxRendererProcessCount(kNumExtensions - 1);
+  ProcessManager* pm = ProcessManager::Get(profile());
+
+  std::set<int> processes;
+  std::set<const Extension*> installed_extensions;
+
+  // Create 3 extensions, which is more than the process limit.
+  for (int i = 1; i <= static_cast<int>(kNumExtensions); ++i) {
+    const Extension* extension =
+        CreateExtension(base::StringPrintf("Extension %d", i), true);
+    installed_extensions.insert(extension);
+    ExtensionHost* extension_host =
+        pm->GetBackgroundHostForExtension(extension->id());
+
+    EXPECT_EQ(extension->url(),
+              extension_host->host_contents()->GetSiteInstance()->GetSiteURL());
+
+    processes.insert(extension_host->render_process_host()->GetID());
+  }
+
+  EXPECT_EQ(kNumExtensions, installed_extensions.size());
+
+  if (content::AreAllSitesIsolatedForTesting()) {
+    EXPECT_EQ(kNumExtensions, processes.size()) << "Extension process reuse is "
+                                                   "expected to be disabled in "
+                                                   "--site-per-process.";
+  } else {
+    EXPECT_LT(processes.size(), kNumExtensions)
+        << "Expected extension process reuse, but none happened.";
+  }
+
+  // Interact with each extension background page by setting and reading back
+  // the cookie. This would fail for one of the two extensions in a shared
+  // process, if that process is locked to a single origin. This is a regression
+  // test for http://crbug.com/600441.
+  for (const Extension* extension : installed_extensions) {
+    content::DOMMessageQueue queue;
+    ExecuteScriptInBackgroundPageNoWait(
+        extension->id(),
+        "document.cookie = 'extension_cookie';"
+        "window.domAutomationController.send(document.cookie);");
+    std::string message;
+    ASSERT_TRUE(queue.WaitForMessage(&message));
+    EXPECT_EQ(message, "\"extension_cookie\"");
+  }
+}
+
 }  // namespace extensions